Turbo Laravel

https://github.com/hotwired-laravel/turbo-laravel
Admin
Turbo Laravel gives you a set of conventions to make the most out of the Hotwire stack in Laravel...
Tokens:81,098
Snippets:598
Trust Score:6.1
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Run turbo:install Artisan Command

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/installation.md

Runs the turbo:install Artisan command to add the Turbo.js dependency and publish necessary files.

```bash
php artisan turbo:install
```

--------------------------------

### Install Turbo Laravel via Composer

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/installation.md

Installs the Turbo Laravel package via Composer.

```bash
composer require hotwired-laravel/turbo-laravel
```

--------------------------------

### Example redirect URL with flash message

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/hotwire-native.md

Example redirect URL when a Hotwire Native request flashes a message. The flash message is appended to the query string.

```text
/recede_historical_location?status=Tray%20created.
```

--------------------------------

### Broadcast to Private and Presence Channels

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Shows how to broadcast to private and presence string channels using broadcastToPrivateChannel() and broadcastToPresenceChannel(). Both examples use a Closure to configure the broadcast.

```php
// Broadcast to private channels...
turbo_stream()
    ->append('notifications', 'Hello World')
    ->broadcastToPrivateChannel('user.123', fn ($broadcast) => $broadcast->toOthers())

// Broadcast to presence channels...
turbo_stream()
    ->append('notifications', 'Hello World')
    ->broadcastToPresenceChannel('chat.123', fn ($broadcast) => $broadcast->toOthers());
```

--------------------------------

### Using custom Turbo Stream action 'log'

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/overview.md

Uses the custom 'log' Turbo Stream action defined in the previous JavaScript example. When activated, it prints 'Hello World' to the DevTools Console.

```html
<turbo-stream action="log" message="Hello World"></turbo-stream>
```

--------------------------------

### Return flash messages from a controller with turbo_stream()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

Example controller that returns a Turbo Stream response with a flash message appended to the 'notifications' element. This is the starting point for creating a custom macro.

```php
class ChirpsController extends Controller
{
    public function destroy(Request $request, Chirp $chirp)
    {
        $this->authorize('delete', $chirp);

        $chirp->delete();

        if ($request->wantsTurboStream()) {
            return turbo_stream([
                turbo_stream($chirp),
                turbo_stream()->append('notifications', view('layouts.notification', [
                    'message' => __('Chirp deleted.'),
                ])),
            ]);
        }

        // ...
    }
}
```

--------------------------------

### Simulate Turbo Frame requests with $this->fromTurboFrame()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-tests/SKILL.md

Use $this->fromTurboFrame() to simulate a request from a specific Turbo Frame by setting the Turbo-Frame header. The examples show asserting the frame content and a successful response.

```php
$this->fromTurboFrame(dom_id($post))
    ->get(route('posts.edit', $post))
    ->assertSee('<turbo-frame id="' . dom_id($post) . '">', false);

$this->fromTurboFrame(dom_id($post, 'create_comment'))
    ->post(route('posts.comments.store', $post), ['content' => 'Hello'])
    ->assertOk();
```

--------------------------------

### Use a public channel with <x-turbo::stream-from>

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Control the channel type by passing a `type` attribute. This example uses a public channel instead of the default private channel.

```blade
<x-turbo::stream-from :source="$post" type="public" />
```

--------------------------------

### Simulate Hotwire Native requests with $this->hotwireNative()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-tests/SKILL.md

Use $this->hotwireNative() to simulate a request from a Hotwire Native mobile client. The example asserts a redirect with a status message using assertRedirectRecede().

```php
$this->hotwireNative()->post(route('comments.store'), ['content' => 'Hello'])
    ->assertRedirectRecede(['status' => __('Comment created.')]);
```

--------------------------------

### Controller returning turbo_stream() for Turbo requests

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/testing.md

Example controller for a Turbo Stream response. It uses request()->wantsTurboStream() to return a turbo_stream() response for Turbo requests, otherwise redirects to the index route.

```php
class TodosController
{
    public function store()
    {
        $todo = auth()->user()->todos()->create(request()->validate([
            'content' => ['required'],
        ]));

        if (request()->wantsTurboStream()) {
            return turbo_stream($todo);
        }

        return redirect()->route('todos.index');
    }
}
```

--------------------------------

### Simulate Turbo visits with InteractsWithTurbo and $this->turbo()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/testing.md

Use the InteractsWithTurbo trait and the $this->turbo() method to simulate a Turbo visit by adding the Accept: text/vnd.turbo-stream.html header. This lets you test that your controller returns a Turbo Streams response instead of plain HTML. The example shows a test that creates a comment via a Turbo POST request and asserts the response is OK and the comment is persisted.

```php
use HotwiredLaravel\TurboLaravel\Testing\InteractsWithTurbo;

class CreateCommentsTest extends TestCase
{
    use InteractsWithTurbo;

    /** @test */
    public function creates_comments()
    {
        $post = Post::factory()->create();

        $this->assertCount(0, $post->comments);

        $this->turbo()->post(route('posts.comments.store', $post), [
            'content' => 'Hello World',
        ])->assertOk();

        $this->assertCount(1, $post->refresh()->comments);
        $this->assertEquals('Hello World', $post->comments->first()->content);
    }
}
```

--------------------------------

### Use dom_class() with context prefix

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Pass a context prefix as the second parameter to dom_class() to generate a prefixed DOM class. For example, 'reactions_list_comment'.

```php
dom_class($comment, 'reactions_list');
```

--------------------------------

### TurboStream::fake() test example

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/testing.md

Use TurboStream::fake() to capture broadcasts. The example shows two tests: one asserting no broadcast on validation failure, and another asserting a broadcast with specific target, action, partial view, data, and channel. Note: set turbo-laravel.queue to false when using automatic model changes broadcasting.

```php
use App\Models\Todo;
use HotwiredLaravel\TurboLaravel\Facades\TurboStream;
use HotwiredLaravel\TurboLaravel\Broadcasting\PendingBroadcast;

class CreatesCommentsTest extends TestCase
{
    /** @test */
    public function content_is_required()
    {
        TurboStream::fake();

        $todo = Todo::factory()->create();

        $this->turbo()->post(route('todos.comments.store', $todo), [
            'content' => null,
        ])->assertInvalid(['content']);

        TurboStream::assertNothingWasBroadcasted();
    }

    /** @test */
    public function creates_comments()
    {
        TurboStream::fake();

        $todo = Todo::factory()->create();

        $this->turbo()->post(route('todos.comments.store', $todo), [
            'content' => 'Hey, this is really nice!',
        ])->assertTurboStream();

        TurboStream::assertBroadcasted(function (PendingBroadcast $broadcast) use ($todo) {
            return $broadcast->target === 'comments'
                && $broadcast->action === 'append'
                && $broadcast->partialView === 'comments.partials.comment'
                && $broadcast->partialData['comment']->is($todo->comments->first())
                && count($broadcast->channels) === 1
                && $broadcast->channels[0]->name === sprintf('private-%s', $todo->broadcastChannel());
        });
    }
}
```

--------------------------------

### Register a broadcast channel authorization route

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Register the broadcast auth route for your model in `routes/channels.php`. This example authorizes a user to listen to a Post channel if they belong to the post's team.

```php
use App\Models\Post;
use App\Models\User;
use Illuminate\Support\Facades\Broadcast;

Broadcast::channel(Post::class, function (User $user, Post $post) {
    return $user->belongsToTeam($post->team);
});
```

--------------------------------

### Combined refresh method and scroll behavior component and its output

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Use `<x-turbo::refreshes-with>` to set both the refresh method and scroll behavior in one component. The example renders two `<meta>` tags.

```blade
<x-turbo::refreshes-with method="morph" scroll="preserve" />
```

```html
<meta name="turbo-refresh-method" content="morph">
<meta name="turbo-refresh-scroll" content="preserve">
```

--------------------------------

### Flash messages with recedeOrRedirectTo and ->with()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/hotwire-native.md

Flash messages using ->with() are added to the query string for Hotwire Native requests instead of the session. For example, redirects to /recede_historical_location?status=Tray%20created.

```php
use HotwiredLaravel\TurboLaravel\Http\Controllers\Concerns\InteractsWithHotwireNativeNavigation;

class TraysController extends Controller
{
    use InteractsWithHotwireNativeNavigation;

    public function store()
    {
        // Tray creation...

        return $this->recedeOrRedirectTo(route('trays.show', $tray))
            ->with('status', __('Tray created.'));
    }
}
```

--------------------------------

### Include content for Hotwire Native clients with @hotwirenative

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/hotwire-native.md

Use this Blade directive to include content only for Hotwire Native clients. The example adds a mobile-only stylesheet.

```blade
@hotwirenative
    <link rel="stylesheet" href="mobile.css">
@endhotwirenative
```

--------------------------------

### Lazy loading frames with :src and loading

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-frames/SKILL.md

Frames can defer loading content using the `:src` attribute. The first example fetches immediately on page load; the second uses `loading="lazy"` to fetch when the frame enters the viewport.

```blade
{{-- Eager lazy load: fetches immediately when the page loads --}}
<x-turbo::frame :id="$post" :src="route('posts.comments.index', $post)">
    <p>Loading comments...</p>
</x-turbo::frame>

{{-- Viewport lazy load: fetches when the frame enters the viewport --}}
<x-turbo::frame :id="$post" :src="route('posts.comments.index', $post)" loading="lazy">
    <p>Loading comments...</p>
</x-turbo::frame>
```

--------------------------------

### Turbo Stream Blade Example

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Use this Blade component to append content to a target element via a Turbo Stream. The action is 'append' and the target is 'messages', adding a new message div.

```blade
<x-turbo::stream action="append" target="messages">
    <div id="message_1">My new message!</div>
</x-turbo::stream>
```

--------------------------------

### Refresh method Blade component and its output

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Configure the Turbo refresh method (replace or morph) using `<x-turbo::refresh-method>`. The example uses `method="morph"` and renders a `<meta>` tag with `content="morph"`.

```blade
<x-turbo::refresh-method method="morph" />
```

```blade
<meta name="turbo-refresh-method" content="morph">
```

--------------------------------

### <x-turbo::page-view-transition />

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Adds a meta tag to enable same-origin view transitions.

```APIDOC
## <x-turbo::page-view-transition />

### Description
Adds a `<meta name="view-transition" content="same-origin">` tag to the page, enabling same-origin view transitions.

### Usage Example
```blade
<x-turbo::page-view-transition />
```
```

--------------------------------

### Update view components

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/upgrade.md

Run this command to update your views from the old component syntax '<x-turbo-*' to the new format '<x-turbo::*'.

```bash
find app resources tests -type f -exec sed -i 's/x-turbo-/x-turbo::/g' {} +
```

--------------------------------

### Configure insertsBy to prepend

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Configure automatic broadcasts to use 'prepend' instead of the default 'append' for newly created models by setting the 'insertsBy' key.

```php
class Comment extends Model
{
    use Broadcasts;

    protected $broadcasts = [
        'insertsBy' => 'prepend',
    ];
}
```

--------------------------------

### <x-turbo::refreshes-with method="morph" scroll="preserve" />

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Configures page refresh behavior.

```APIDOC
## <x-turbo::refreshes-with method="morph" scroll="preserve" />

### Description
Configures page refresh behavior, including morphing and scroll preservation.

### Parameters
- **method** (string) - Optional - The refresh method (e.g., morph).
- **scroll** (string) - Optional - Scroll behavior (e.g., preserve).

### Usage Example
```blade
<x-turbo::refreshes-with method="morph" scroll="preserve" />
```
```

--------------------------------

### Include content for non-Hotwire Native clients with @unlesshotwirenative

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/hotwire-native.md

Use this Blade directive to include content only for non-Hotwire Native clients. The example shows a heading for regular web users.

```blade
@unlesshotwirenative
    <h1>Hello, Non-Hotwire Native Users!</h1>
@endunlesshotwirenative
```

--------------------------------

### Check Hotwire Native visit with Turbo::isHotwireNativeVisit()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/hotwire-native.md

Use the Turbo facade to check if the current request is a Hotwire Native visit. Requires importing the Turbo facade.

```php
use HotwiredLaravel\TurboLaravel\Facades\Turbo;

if (Turbo::isHotwireNativeVisit()) {
    // ...
}
```

--------------------------------

### <x-turbo::stream-from :source="$model" />

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Listens for broadcasts on the model's channel.

```APIDOC
## <x-turbo::stream-from :source="$model" />

### Description
Listens for broadcasts on the model's channel. By default, the channel is private; set `type="public"` to use a public channel.

### Parameters
- **source** (Model) - Required - The model instance whose broadcast channel to listen to.
- **type** (string) - Optional - The channel type. Defaults to `private`. Use `public` for public channels.

### Usage Example
```blade
<x-turbo::stream-from :source="$post" />
<x-turbo::stream-from :source="$post" type="public" />
```
```

--------------------------------

### Assert broadcast count with assertBroadcastedTimes()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-tests/SKILL.md

Use TurboStream::assertBroadcastedTimes() to assert that a broadcast matching a condition was sent a specific number of times. The example expects two broadcasts with the 'append' action.

```php
TurboStream::fake();

Post::create(['title' => 'First']);
Post::create(['title' => 'Second']);

TurboStream::assertBroadcastedTimes(
    fn ($broadcast) => $broadcast->action === 'append',
    times: 2,
);
```

--------------------------------

### Use before with custom view

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

For before and after methods, specify the view template separately since the model/string only sets the target.

```php
turbo_stream()
    ->before($comment)
    ->view('comments.partials.flash_message', [
        'message' => __('Comment created!'),
    ]);
```

--------------------------------

### Manual page refresh broadcasts with booted()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Manual equivalent of the $broadcastsRefreshes property. Defines booted() to broadcast page refreshes on created, updated, and deleted events, using broadcastRefreshTo for created and broadcastRefresh for updated and deleted.

```php
use Illuminate\Broadcasting\Channel;

class Comment extends Model
{
    use Broadcasts;

    public static function booted()
    {
        static::created(function ($comment) {
            $comment->broadcastRefreshTo("comments")->later();
        });

        static::updated(function ($comment) {
            $comment->broadcastRefresh()->later();
        });

        static::deleted(function ($comment) {
            $comment->broadcastRefresh();
        });
    }
}
```

--------------------------------

### Require new package and remove old

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/upgrade.md

Use these commands to require the new package 'hotwired-laravel/turbo-laravel' version ^2.0 and remove the old package 'hotwired/turbo-laravel'.

```bash
composer require hotwired-laravel/turbo-laravel:^2.0
```

```bash
composer remove hotwired/turbo-laravel
```

--------------------------------

### Simulate Turbo Stream visits with $this->turbo()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-tests/SKILL.md

Use $this->turbo() to simulate requests that accept Turbo Stream responses by setting the appropriate Accept header. Then assert the response with assertTurboStream().

```php
$this->turbo()->post(route('posts.store'), ['title' => 'Test'])
    ->assertTurboStream();

$this->turbo()->put(route('posts.update', $post), ['title' => 'Updated'])
    ->assertTurboStream();

$this->turbo()->delete(route('posts.destroy', $post))
    ->assertTurboStream();
```

--------------------------------

### List of Hotwire Native redirect helpers

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/hotwire-native.md

Available redirect helpers from the InteractsWithHotwireNativeNavigation trait. Each helper sends a corresponding signal (recede, resume, refresh) to the Hotwire Native client or falls back to a regular redirect.

```php
$this->recedeOrRedirectTo(string $url);
$this->resumeOrRedirectTo(string $url);
$this->refreshOrRedirectTo(string $url);
$this->recedeOrRedirectBack(string $fallbackUrl, array $options = []);
$this->resumeOrRedirectBack(string $fallbackUrl, array $options = []);
$this->refreshOrRedirectBack(string $fallbackUrl, array $options = []);
```

--------------------------------

### Pass string target and content to append

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

Uses a string as the target and a string as the content for the append action.

```php
turbo_stream()->append('statuses', __('Comment created!'));
```

--------------------------------

### Listen to a broadcast channel with <turbo-echo-stream-source>

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Add this custom HTML tag to any Blade view to start receiving Turbo Stream broadcasts for the given channel. The channel name follows Laravel's model broadcasting conventions.

```blade
<turbo-echo-stream-source
    channel="App.Models.Post.{{ $post->id }}"
/>
```

--------------------------------

### Turbo Stream append action example

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/overview.md

A Turbo Stream that appends the contents of its <template> tag to the element with DOM ID 'comments'. The action attribute 'append' and target attribute 'comments' are required; the target expects a DOM ID.

```html
<turbo-stream action="append" target="comments">
    <template>
        ...
    </template>
</turbo-stream>
```

--------------------------------

### Simulate Hotwire Native Requests

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/testing.md

Use the hotwireNative() method to set the User-Agent header, simulating a request from a Hotwire Native client.

```php
use HotwiredLaravel\TurboLaravel\Testing\InteractsWithTurbo;

class CreateCommentsTest extends TestCase
{
    use InteractsWithTurbo;

    /** @test */
    public function creating_comments_from_native_recedes()
    {
        $post = Post::factory()->create();

        $this->assertCount(0, $post->comments);

        $this->hotwireNative()->post(route('posts.comments.store', $post), [
            'content' => 'Hello World',
        ])->assertOk();

        $this->assertCount(1, $post->refresh()->comments);
        $this->assertEquals('Hello World', $post->comments->first()->content);
    }
}
```

--------------------------------

### Setup: Add InteractsWithTurbo trait to test class

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-tests/SKILL.md

Add the InteractsWithTurbo trait to your test class or base TestCase to enable Turbo-specific testing methods. The turbo-laravel.queue config is automatically set to false during testing for synchronous broadcast processing.

```php
use HotwiredLaravel\TurboLaravel\Testing\InteractsWithTurbo;

class PostTest extends TestCase
{
    use InteractsWithTurbo;
}
```

--------------------------------

### Use turbo_stream() helper

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Use the turbo_stream() helper to generate Turbo Streams. It works the same as the Response::turboStream() macro and may be easier to use.

```php
use function HotwiredLaravel\TurboLaravel\turbo_stream;

turbo_stream()->append($comment);
```

--------------------------------

### Refresh scroll behavior Blade component and its output

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Configure the Turbo scroll behavior (reset or preserve) using `<x-turbo::refresh-scroll>`. The example uses `scroll="preserve"` and renders a `<meta>` tag with `content="preserve"`.

```blade
<x-turbo::refresh-scroll scroll="preserve" />
```

```blade
<meta name="turbo-refresh-scroll" content="preserve">
```

--------------------------------

### Pass view instance as content to append

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

Passes a view instance as the content parameter to the append shorthand.

```php
turbo_stream()->append('some_dom_id', view('greetings', [
    'name' => 'Tester',
]));
```

--------------------------------

### Generate DOM IDs with @domid Blade Directive

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Use the @domid Blade directive to generate a DOM ID from a model's basename and ID, e.g., post_123. The second example adds a prefix, producing comments_post_123 for a Post with ID 123.

```blade
<turbo-frame id="@domid($post)">
    <!-- Content -->
</turbo-frame>
```

```blade
<turbo-frame id="@domid($post, 'comments')">
    <!-- Comments -->
</turbo-frame>
```

--------------------------------

### <x-turbo::stream action="append" :target="$model">

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Renders a `<turbo-stream>` element with the specified action and target.

```APIDOC
## <x-turbo::stream action="append" :target="$model">

### Description
Renders a `<turbo-stream>` element. The `action` attribute specifies the stream action (e.g., append). The `target` attribute specifies the target element, which can be a model instance for automatic ID resolution. The `<template>` wrapper is omitted for brevity.

### Parameters
- **action** (string) - Required - The Turbo Stream action (e.g., append, prepend, replace).
- **target** (string|Model) - Required - The target element ID or a model instance for automatic ID resolution.

### Usage Example
```blade
<x-turbo::stream action="append" :target="$post" />
```
```

--------------------------------

### Override partials pattern with Turbo::usePartialsSubfolderPattern()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/conventions.md

Call Turbo::usePartialsSubfolderPattern() from AppServiceProvider::boot() to override the default partials location pattern to the {plural}.partials.{singular} convention.

```php
<?php

namespace App\Providers;

use HotwiredLaravel\TurboLaravel\Facades\Turbo;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Turbo::usePartialsSubfolderPattern();
    }
}

```

--------------------------------

### Prefetching control with data-turbo-preload

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-drive/SKILL.md

Turbo prefetches links on mouseenter by default. Use data-turbo-preload="false" to disable prefetching for a specific link, or data-turbo-preload to eagerly preload a link on page load.

```html
<!-- Disable prefetching for a specific link -->
<a href="/heavy-page" data-turbo-preload="false">Heavy page</a>

<!-- Eagerly preload a link (fetches on page load) -->
<a href="/likely-next" data-turbo-preload>Likely next page</a>
```

--------------------------------

### Handmade broadcasts via TurboStream facade

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-streams/SKILL.md

Use the TurboStream facade for broadcasts not tied to a model. Pass content, target, and channel parameters.

```php
use HotwiredLaravel\TurboLaravel\Facades\TurboStream;

TurboStream::broadcastAppend(
    content: view('notifications._notification', ['notification' => $notification]),
    target: 'notifications',
    channel: 'general',
);

TurboStream::broadcastRemove(target: 'notification_1', channel: 'general');
TurboStream::broadcastRefresh(channel: 'general');
```

--------------------------------

### Hotwire Native redirect assertions - assertRedirectRecede, assertRedirectResume, assertRedirectRefresh

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-tests/SKILL.md

For Hotwire Native clients, assert specific redirect path behaviors with optional flash data. Use assertRedirectRecede() for going back, assertRedirectResume() for staying on the current screen, and assertRedirectRefresh() for reloading the current screen.

```php
// Assert a "recede" redirect (go back in the native navigation stack)
$this->hotwireNative()->post(route('comments.store'), ['content' => 'Hello'])
    ->assertRedirectRecede(['status' => __('Comment created.')]);

// Assert a "resume" redirect (stay on the current screen)
$this->hotwireNative()->put(route('settings.update'), ['name' => 'New'])
    ->assertRedirectResume(['status' => __('Settings updated.')]);

// Assert a "refresh" redirect (reload the current screen)
$this->hotwireNative()->post(route('posts.store'), ['title' => 'Test'])
    ->assertRedirectRefresh(['status' => __('Post created.')]);
```

--------------------------------

### Shorthand methods for Turbo Stream actions

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

Lists shorthand methods for common Turbo Stream actions: append, prepend, before, after, replace, update, remove, and refresh.

```php
turbo_stream()->append($comment);
turbo_stream()->prepend($comment);
turbo_stream()->before($comment);
turbo_stream()->after($comment);
turbo_stream()->replace($comment);
turbo_stream()->update($comment);
turbo_stream()->remove($comment);
turbo_stream()->refresh();
```

--------------------------------

### Promoting frame navigation with data-turbo-action

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-frames/SKILL.md

Add `data-turbo-action="advance"` to a link to update the frame content and push the URL to browser history, enabling Back button navigation.

```html
<a href="/posts/1" data-turbo-frame="post_detail" data-turbo-action="advance">View</a>
```

--------------------------------

### Customizing frame rendering with turbo:before-frame-render

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-frames/SKILL.md

Listen to the `turbo:before-frame-render` event to access `event.detail.newFrame` and modify the frame content before it is rendered.

```javascript
document.addEventListener("turbo:before-frame-render", (event) => {
    // Access event.detail.newFrame to modify before rendering
});
```

--------------------------------

### Response Helpers

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Functions to return Turbo Stream responses, either for a model, via a fluent builder, or as a view.

```APIDOC
## Response Helpers

### Description
These helper functions generate Turbo Stream responses.

### Functions

#### turbo_stream($model, ?string $action = null)
- **Parameters**:
  - `$model` (mixed) - Required - The model to generate the stream for.
  - `$action` (string|null) - Optional - The action (e.g., 'prepend'). If not provided, auto-detected from context.
- **Returns**: TurboStreamResponse
- **Description**: Return a Turbo Stream response for a model, auto-detecting the action from context.

#### turbo_stream()->append($target, $content)
- **Parameters**:
  - `$target` (string) - Required - The target element ID.
  - `$content` (mixed) - Required - The content to append.
- **Returns**: TurboStreamBuilder
- **Description**: Return a fluent Turbo Stream builder for appending content.

#### turbo_stream([...]) 
- **Parameters**:
  - `$streams` (array) - Required - An array of Turbo Stream builders.
- **Returns**: TurboStreamResponse
- **Description**: Return multiple streams in a single response.

#### turbo_stream_view($view, $data = [])
- **Parameters**:
  - `$view` (string) - Required - The Blade view name.
  - `$data` (array) - Optional - Data to pass to the view.
- **Returns**: Response
- **Description**: Return a Turbo Stream view, rendering a Blade view with the Turbo Stream content type.

### Examples
```php
return turbo_stream($model);
return turbo_stream($model, 'prepend');

return turbo_stream()->append('posts', view('posts._post', ['post' => $post]));

return turbo_stream([
    turbo_stream()->append('posts', view('posts._post', ['post' => $post])),
    turbo_stream()->update('post_count', view('posts._count', ['count' => $count])),
]);

return turbo_stream_view('posts.turbo.created', ['post' => $post]);
```
```

--------------------------------

### Automatic broadcasting configuration

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-streams/SKILL.md

Enable automatic broadcasts on model lifecycle events. Set $broadcasts to true or customize the insert action with ['insertsBy' => 'prepend']. Use $broadcastsTo or broadcastsTo() to specify the target channel.

```php
class Comment extends Model
{
    use Broadcasts;

    // Enable auto-broadcasting (broadcasts on create, update, delete)
    protected $broadcasts = true;

    // Customize insert action (default is 'append')
    protected $broadcasts = ['insertsBy' => 'prepend'];

    // Specify which model's channel to broadcast to
    protected $broadcastsTo = 'post';

    // Or define dynamically
    public function broadcastsTo()
    {
        return $this->post;
    }
}
```

--------------------------------

### Manual broadcasting methods on model

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-streams/SKILL.md

Call broadcast methods directly on a model instance. Use toOthers() to exclude the current user and later() to queue the broadcast for async processing.

```php
$comment->broadcastAppend();
$comment->broadcastPrepend();
$comment->broadcastReplace();
$comment->broadcastUpdate();
$comment->broadcastRemove();
$comment->broadcastBefore('some_target');
$comment->broadcastAfter('some_target');
$comment->broadcastRefresh();

// Broadcast only to other users (exclude current user)
$comment->broadcastAppend()->toOthers();

// Queue the broadcast for async processing
$comment->broadcastAppend()->later();
```

--------------------------------

### Targeting Multiple Elements with *All Methods

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-streams/SKILL.md

Use the *All methods (appendAll, replaceAll, removeAll) to target multiple elements by CSS selector instead of a single DOM ID.

```php
return turbo_stream()->appendAll('.comment', view('comments._comment', ['comment' => $comment]));
return turbo_stream()->replaceAll('.notification', view('notifications._notification'));
return turbo_stream()->removeAll('.old-item');
```

--------------------------------

### Broadcast with Closure Configuration

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Broadcasts to a public channel while configuring the PendingBroadcast via a Closure. The Closure receives the PendingBroadcast and can call methods like toOthers().

```php
turbo_stream()
    ->append('notifications', 'Hello World')
    ->broadcastTo('general', fn ($broadcast) => $broadcast->toOthers());
```

--------------------------------

### Listening for broadcasts with stream-from

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-streams/SKILL.md

Use the <x-turbo::stream-from> component in Blade views to subscribe to a channel. Default is private (requires channel auth); use type="public" for public channels.

```blade
{{-- Private channel (default) — requires channel auth --}}
<x-turbo::stream-from :source="$post" />

{{-- Public channel — no auth needed --}}
<x-turbo::stream-from :source="$post" type="public" />
```

--------------------------------

### Use xAll shorthand methods to target multiple elements

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

Use these shorthand methods to set the `targets` attribute with a CSS selector instead of a single `target` ID. Except for `removeAll`, each accepts inline content, a Laravel View instance, or an `HtmlSafe` instance as the second parameter.

```php
turbo_stream()->appendAll('.comment', 'Some content');
turbo_stream()->prependAll('.comment', 'Some content');
turbo_stream()->updateAll('.comment', 'Some content');
turbo_stream()->replaceAll('.comment', 'Some content');
turbo_stream()->beforeAll('.comment', 'Some content');
turbo_stream()->afterAll('.comment', 'Some content');
turbo_stream()->removeAll('.comment');
```

--------------------------------

### Custom partials path with Turbo::resolvePartialsPathUsing()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/conventions.md

Define a custom partials path pattern using Turbo::resolvePartialsPathUsing(). Accepts a string with {singular} and {plural} placeholders or a Closure that receives the model instance and returns a dot-notation view pattern.

```php
<?php

namespace App\Providers;

use HotwiredLaravel\TurboLaravel\Facades\Turbo;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Turbo::resolvePartialsPathUsing('{plural}.partials.{singular}');

        // Or...

        Turbo::resolvePartialsPathUsing(fn ($model) => 'partials.{singular}');
    }
}

```

--------------------------------

### Set multiple targets with the targets() builder method

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

When using the Turbo Stream builders, specify a CSS selector with the plural `targets()` method instead of the singular `target()` method to match multiple elements.

```php
turbo_stream()
    ->targets('.comment')
    ->action('append')
    ->view('comments.partials.comment', ['comment' => $comment]);
```

--------------------------------

### Asset tracking with data-turbo-track

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-drive/SKILL.md

Mark assets with data-turbo-track="reload" so Turbo reloads the page when they change (e.g., after a deploy). When Turbo detects tracked assets have changed, it performs a full page reload instead of a Turbo visit.

```html
<link rel="stylesheet" href="/app.css?v=123" data-turbo-track="reload">
<script src="/app.js?v=123" data-turbo-track="reload"></script>
```

--------------------------------

### response()->turboStreamView()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Response macro that works similarly to the turbo_stream_view() function, providing a convenient way to return a Turbo Stream view response.

```APIDOC
## response()->turboStreamView()

### Description
Response macro that works similarly to the `turbo_stream_view()` function. It was added to the response for convenience.

### Method
Macro on the Laravel response instance.

### Usage
```php
return response()->turboStreamView(...);
```

### Notes
- This macro is a convenience wrapper around the `turbo_stream_view()` function.
```

--------------------------------

### response()->turboStream()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Response macro that works similarly to the turbo_stream() function, providing a convenient way to return a Turbo Stream response.

```APIDOC
## response()->turboStream()

### Description
Response macro that works similarly to the `turbo_stream()` function. It was added to the response for convenience.

### Method
Macro on the Laravel response instance.

### Usage
```php
return response()->turboStream(...);
```

### Notes
- This macro is a convenience wrapper around the `turbo_stream()` function.
```

--------------------------------

### Check Hotwire Native request with request()->wasFromHotwireNative()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/hotwire-native.md

Use the request macro to check if the current request was made from a Hotwire Native visit.

```php
if (request()->wasFromHotwireNative()) {
    // ...
}
```

--------------------------------

### Enable automatic broadcasts with $broadcasts = true

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Enable automatic broadcasting by setting $broadcasts = true. This hooks the model's Turbo Stream broadcasts on the correct events.

```php
class Comment extends Model
{
    use Broadcasts;

    protected $broadcasts = true;
}
```

--------------------------------

### Using the turbo_stream() Helper for Stream Actions

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-streams/SKILL.md

The turbo_stream() helper can auto-detect the action from model state (created → append, updated → replace, deleted → remove) or accept an explicit action. The fluent builder returns a PendingTurboStreamResponse when called with no arguments and supports all eight actions: append, prepend, before, after, replace, update, remove, and refresh.

```php
// Auto-detect action from context (uses model state: created → append, updated → replace, deleted → remove)
return turbo_stream($model);
return turbo_stream($model, 'prepend');

// Fluent builder (no arguments returns a PendingTurboStreamResponse)
return turbo_stream()->append('posts', view('posts._post', ['post' => $post]));
return turbo_stream()->prepend('posts', view('posts._post', ['post' => $post]));
return turbo_stream()->before(dom_id($post), view('posts._post', ['post' => $newPost]));
return turbo_stream()->after(dom_id($post), view('posts._post', ['post' => $newPost]));
return turbo_stream()->replace($post, view('posts._post', ['post' => $post]));
return turbo_stream()->update($post, view('posts._post', ['post' => $post]));
return turbo_stream()->remove($post);
return turbo_stream()->refresh();
```

--------------------------------

### <x-turbo::exempts-page-from-cache />

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Adds a meta tag to exempt the page from Turbo caching.

```APIDOC
## <x-turbo::exempts-page-from-cache />

### Description
Adds a `<meta name="turbo-cache-control" content="no-cache">` tag to the page, preventing Turbo from caching the page.

### Usage Example
```blade
<x-turbo::exempts-page-from-cache />
```
```

--------------------------------

### Pass content string to before shorthand

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

Use the before shorthand with a content string or HtmlString instance instead of a view section. The second argument is the content to prepend.

```php
turbo_stream()->before($comment, __('Oh, hey!'));
```

--------------------------------

### Lazy-loading Turbo Frame with loading=lazy

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/overview.md

Add loading="lazy" to a lazy-loaded Turbo Frame so it only fetches content when the frame becomes visible in the viewport.

```blade
<turbo-frame id="my_frame" src="{{ route('my.page') }}" loading="lazy">
    <p>Loading...</p>
</turbo-frame>
```

--------------------------------

### HTML response with overridden target

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

Shows the resulting Turbo Stream HTML when the target is overridden to 'post_comments'.

```html
<turbo-stream action="append" target="post_comments">
    <template>
        <div id="comment_123">
            <p>Hello, World</p>
        </div>
    </template>
</turbo-stream>
```

--------------------------------

### Use turbo_stream_view() helper

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Use the turbo_stream_view() helper to render a Blade view containing Turbo Streams. This allows using template extensions and other Blade features.

```php
use function HotwiredLaravel\TurboLaravel\turbo_stream_view;

return turbo_stream_view('comments.turbo.created', [
    'comment' => $comment,
]);
```

--------------------------------

### Scoped navigation with links and forms

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-frames/SKILL.md

Links and forms inside a frame target that same frame by default. The server extracts the matching `<turbo-frame>` from the response and swaps its content.

```blade
<x-turbo::frame :id="$post">
    {{-- Clicking this link fetches the edit page and extracts the matching frame --}}
    <a href="{{ route('posts.edit', $post) }}">Edit</a>

    {{-- Submitting this form updates only this frame with the response --}}
    <form action="{{ route('posts.update', $post) }}" method="POST">
        @csrf
        @method('PUT')
        <input name="title" value="{{ $post->title }}">
        <button type="submit">Save</button>
    </form>
</x-turbo::frame>
```

--------------------------------

### Broadcast from response builder

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-streams/SKILL.md

Chain broadcastTo() on a Turbo Stream response to also broadcast it to a channel.

```php
turbo_stream()
    ->append('posts', view('posts._post', ['post' => $post]))
    ->broadcastTo('general');
```

--------------------------------

### <x-turbo::page-requires-reload />

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Adds a meta tag to force a full page reload on Turbo visits.

```APIDOC
## <x-turbo::page-requires-reload />

### Description
Adds a `<meta name="turbo-visit-control" content="reload">` tag to the page, forcing a full page reload on Turbo visits.

### Usage Example
```blade
<x-turbo::page-requires-reload />
```
```

--------------------------------

### Broadcast custom action with broadcastAction()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Broadcasts a custom Turbo Stream action using broadcastAction(), allowing actions beyond the default ones.

```php
TurboStream::broadcastAction('scroll_to', target: 'todo_123');
```

--------------------------------

### Broadcast on model events

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Hook model events to automatically broadcast Turbo Streams on create, update, and delete. Uses broadcastPrependTo, broadcastReplaceTo, and broadcastRemoveTo with ->later().

```php
class Comment extends Model
{
    use Broadcasts;

    protected static function booted()
    {
        static::created(function (Comment $comment) {
            $comment->broadcastPrependTo($comment->post)->later();
        });

        static::updated(function (Comment $comment) {
            $comment->broadcastReplaceTo($comment->post)->later();
        });

        static::deleted(function (Comment $comment) {
            $comment->broadcastRemoveTo($comment->post)->later();
        });
    }
}
```

--------------------------------

### <x-turbo::exempts-page-from-preview />

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Adds a meta tag to exempt the page from Turbo preview.

```APIDOC
## <x-turbo::exempts-page-from-preview />

### Description
Adds a `<meta name="turbo-cache-control" content="no-preview">` tag to the page, preventing Turbo from showing a preview of the page.

### Usage Example
```blade
<x-turbo::exempts-page-from-preview />
```
```

--------------------------------

### Assert no broadcasts with assertNothingWasBroadcasted()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-tests/SKILL.md

Use TurboStream::assertNothingWasBroadcasted() after TurboStream::fake() to verify that no broadcasts were sent during the intervening actions.

```php
TurboStream::fake();

// ... perform actions that should NOT broadcast ...

TurboStream::assertNothingWasBroadcasted();
```

--------------------------------

### Page refresh broadcasting

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-streams/SKILL.md

Broadcast a page refresh signal instead of granular stream actions. Works best with <x-turbo::refreshes-with method="morph" scroll="preserve" /> in the layout.

```php
class Post extends Model
{
    use Broadcasts;

    // Auto-broadcast page refreshes on model changes
    protected $broadcastsRefreshes = true;
}
```

--------------------------------

### Manually build a Turbo Stream response

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/turbo-streams.md

Builds a Turbo Stream response manually by specifying target, action, and view.

```php
turbo_stream()
    ->target('comments')
    ->action('append')
    ->view('comments.partials.comment', ['comment' => $comment]);
```

--------------------------------

### Configure redirect_guessing_exceptions in config/turbo-laravel.php

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/conventions.md

Configure exceptions to the route guessing behavior in the turbo-laravel config file. When a route matches an exception, the package will still perform the redirection behavior but will not attempt to guess the routes that render the forms on those routes.

```php
return [
    // ...
    'redirect_guessing_exceptions' => [
        '/some-page',
    ],
];
```

--------------------------------

### <x-turbo::frame :id="$model">

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Renders a `<turbo-frame>` element with automatic DOM ID resolution.

```APIDOC
## <x-turbo::frame :id="$model">

### Description
Renders a `<turbo-frame>` element with automatic DOM ID resolution. The `:id` attribute accepts a string, a model instance, or an array `[$model, 'prefix']`.

### Parameters
- **id** (string|Model|array) - Required - The ID for the turbo-frame. Accepts a string, a model instance, or an array with a model and a prefix.

### Usage Example
```blade
<x-turbo::frame :id="$post" />
```
```

--------------------------------

### Broadcast to private or presence channels

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Specifies private or presence string channels instead of public ones using toPrivateChannel() and toPresenceChannel().

```php
TurboStream::broadcastAppend('Hello World')
    ->target('notifications')
    ->toPrivateChannel('user.123');

TurboStream::broadcastAppend('Hello World')
    ->target('notifications')
    ->toPresenceChannel('user.123');
```

--------------------------------

### @turbonative / @endturbonative

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Conditional directives for Turbo Native visits.

```APIDOC
## @turbonative / @endturbonative

### Description
Conditional directives that show content only for Turbo Native visits (alias for Hotwire Native).

### Usage Example
```blade
@turbonative
    <p>This is shown only in Turbo Native.</p>
@endturbonative
```
```

--------------------------------

### @hotwirenative / @endhotwirenative

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/resources/boost/skills/developing-with-turbo-basics/SKILL.md

Conditional directives for Hotwire Native visits.

```APIDOC
## @hotwirenative / @endhotwirenative

### Description
Conditional directives that show content only for Hotwire Native visits.

### Usage Example
```blade
@hotwirenative
    <p>This is shown only in Hotwire Native.</p>
@endhotwirenative
```
```

--------------------------------

### turbo_stream()

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/helpers.md

Generates Turbo Streams. This function works the same as the Response::turboStream() macro and may be easier to use.

```APIDOC
## turbo_stream()

### Description
Generates Turbo Streams. This function works the same as the `Response::turboStream()` macro and may be easier to use.

### Method
Function

### Signature
```php
turbo_stream()
```

### Example
```php
use function HotwiredLaravel\TurboLaravel\turbo_stream;

turbo_stream()->append($comment);
```

### Behavior
- Returns a Turbo Stream builder instance that can be used to append, prepend, replace, etc.
```

--------------------------------

### Render a stream source for a model with <x-turbo::stream-from>

Source: https://github.com/hotwired-laravel/turbo-laravel/blob/2.x/docs/broadcasting.md

Use the Blade component to render a <turbo-echo-stream-source> tag for the given model. It requires the custom element to be available and uses Laravel's conventions to determine the channel name. By default, it expects a private channel, so the user must be authenticated.

```blade
<x-turbo::stream-from :source="$post" />
```
Tokens:
Raw