fix conflicts

Author: taylorotwell

configuration.md

@@ -322,13 +322,11 @@ When accessing this hidden route, you will then be redirected to the `/` route o
 
 By default, Laravel determines if your application is in maintenance mode using a file-based system. This means to activate maintenance mode, the `php artisan down` command has to be executed on each server hosting your application.
 
-Alternatively, Laravel offers a cache-based method for handling maintenance mode. This method requires running the `php artisan down` command on just one server. To use this approach, modify the "driver" setting in the `config/app.php` file of your application to `cache`. Then, select a cache `store` that is accessible by all your servers. This ensures the maintenance mode status is consistently maintained across every server:
+Alternatively, Laravel offers a cache-based method for handling maintenance mode. This method requires running the `php artisan down` command on just one server. To use this approach, modify the maintenance mode variables in your application's `.env` file. You should select a cache `store` that is accessible by all of your servers. This ensures the maintenance mode status is consistently maintained across every server:
 
-```php
-'maintenance' => [
-    'driver' => 'cache',
-    'store' => 'database',
-],
+```ini
+APP_MAINTENANCE_DRIVER=cache
+APP_MAINTENANCE_STORE=database
 ```
 
 <a name="pre-rendering-the-maintenance-mode-view"></a>

container.md

@@ -349,6 +349,8 @@ You can create your own contextual attributes by implementing the `Illuminate\Co
 
 namespace App\Attributes;
 
+use Attribute;
+use Illuminate\Contracts\Container\Container;
 use Illuminate\Contracts\Container\ContextualAttribute;
 
 #[Attribute(Attribute::TARGET_PARAMETER)]

errors.md

@@ -32,7 +32,7 @@ During local development, you should set the `APP_DEBUG` environment variable to
 <a name="reporting-exceptions"></a>
 ### Reporting Exceptions
 
-In Laravel, exception reporting is used to log exceptions or send them to an external service [Sentry](https://github.com/getsentry/sentry-laravel) or [Flare](https://flareapp.io). By default, exceptions will be logged based on your [logging](/docs/{{version}}/logging) configuration. However, you are free to log exceptions however you wish.
+In Laravel, exception reporting is used to log exceptions or send them to an external service like [Sentry](https://github.com/getsentry/sentry-laravel) or [Flare](https://flareapp.io). By default, exceptions will be logged based on your [logging](/docs/{{version}}/logging) configuration. However, you are free to log exceptions however you wish.
 
 If you need to report different types of exceptions in different ways, you may use the `report` exception method in your application's `bootstrap/app.php` to register a closure that should be executed when an exception of a given type needs to be reported. Laravel will determine what type of exception the closure reports by examining the type-hint of the closure:
 

helpers.md

@@ -66,6 +66,7 @@ Laravel includes a variety of global "helper" PHP functions. Many of these funct
 [Arr::pull](#method-array-pull)
 [Arr::query](#method-array-query)
 [Arr::random](#method-array-random)
+[Arr::reject](#method-array-reject)
 [Arr::set](#method-array-set)
 [Arr::shuffle](#method-array-shuffle)
 [Arr::sort](#method-array-sort)
@@ -828,6 +829,21 @@ $items = Arr::random($array, 2);
 // [2, 5] - (retrieved randomly)
 ```
 
+<a name="method-array-reject"></a>
+#### `Arr::reject()` {.collection-method}
+
+The `Arr::reject` method removes items from an array using the given closure:
+
+    use Illuminate\Support\Arr;
+
+    $array = [100, '200', 300, '400', 500];
+
+    $filtered = Arr::reject($array, function (string|int $value, int $key) {
+        return is_string($value);
+    });
+
+    // [0 => 100, 2 => 300, 4 => 500]
+
 <a name="method-array-set"></a>
 #### `Arr::set()` {.collection-method}
 

http-tests.md

@@ -989,6 +989,7 @@ Laravel's `Illuminate\Testing\TestResponse` class provides a variety of custom a
 [assertMovedPermanently](#assert-moved-permanently)
 [assertContent](#assert-content)
 [assertNoContent](#assert-no-content)
+[assertStreamed](#assert-streamed)
 [assertStreamedContent](#assert-streamed-content)
 [assertNotFound](#assert-not-found)
 [assertOk](#assert-ok)
@@ -1472,6 +1473,13 @@ Assert that the response has the given HTTP status code and no content:
 $response->assertNoContent($status = 204);
 ```
 
+<a name="assert-streamed"></a>
+#### assertStreamed
+
+Assert that the response was a streamed response:
+
+    $response->assertStreamed();
+
 <a name="assert-streamed-content"></a>
 #### assertStreamedContent
 

notifications.md

@@ -99,7 +99,7 @@ use App\Notifications\InvoicePaid;
 $user->notify(new InvoicePaid($invoice));
 ```
 
-> [!NOTE]  
+> [!NOTE]
 > Remember, you may use the `Notifiable` trait on any of your models. You are not limited to only including it on your `User` model.
 
 <a name="using-the-notification-facade"></a>
@@ -124,7 +124,7 @@ Notification::sendNow($developers, new DeploymentCompleted($deployment));
 
 Every notification class has a `via` method that determines on which channels the notification will be delivered. Notifications may be sent on the `mail`, `database`, `broadcast`, `vonage`, and `slack` channels.
 
-> [!NOTE]  
+> [!NOTE]
 > If you would like to use other delivery channels such as Telegram or Pusher, check out the community driven [Laravel Notification Channels website](http://laravel-notification-channels.com).
 
 The `via` method receives a `$notifiable` instance, which will be an instance of the class to which the notification is being sent. You may use `$notifiable` to determine which channels the notification should be delivered on:
@@ -144,7 +144,7 @@ public function via(object $notifiable): array
 <a name="queueing-notifications"></a>
 ### Queueing Notifications
 
-> [!WARNING]  
+> [!WARNING]
 > Before queueing notifications you should configure your queue and [start a worker](/docs/{{version}}/queues#running-the-queue-worker).
 
 Sending notifications can take time, especially if the channel needs to make an external API call to deliver the notification. To speed up your application's response time, let your notification be queued by adding the `ShouldQueue` interface and `Queueable` trait to your class. The interface and trait are already imported for all notifications generated using the `make:notification` command, so you may immediately add them to your notification class:
@@ -337,7 +337,7 @@ class InvoicePaid extends Notification implements ShouldQueue
 }
 ```
 
-> [!NOTE]  
+> [!NOTE]
 > To learn more about working around these issues, please review the documentation regarding [queued jobs and database transactions](/docs/{{version}}/queues#jobs-and-database-transactions).
 
 <a name="determining-if-the-queued-notification-should-be-sent"></a>
@@ -417,14 +417,14 @@ public function toMail(object $notifiable): MailMessage
 }
 ```
 
-> [!NOTE]  
+> [!NOTE]
 > Note we are using `$this->invoice->id` in our `toMail` method. You may pass any data your notification needs to generate its message into the notification's constructor.
 
 In this example, we register a greeting, a line of text, a call to action, and then another line of text. These methods provided by the `MailMessage` object make it simple and fast to format small transactional emails. The mail channel will then translate the message components into a beautiful, responsive HTML email template with a plain-text counterpart. Here is an example of an email generated by the `mail` channel:
 
 <img src="https://laravel.com/img/docs/notification-example-2.png">
 
-> [!NOTE]  
+> [!NOTE]
 > When sending mail notifications, be sure to set the `name` configuration option in your `config/app.php` configuration file. This value will be used in the header and footer of your mail notification messages.
 
 <a name="error-messages"></a>
@@ -602,7 +602,7 @@ public function toMail(object $notifiable): MailMessage
 }
 ```
 
-> [!NOTE]  
+> [!NOTE]
 > The `attach` method offered by notification mail messages also accepts [attachable objects](/docs/{{version}}/mail#attachable-objects). Please consult the comprehensive [attachable object documentation](/docs/{{version}}/mail#attachable-objects) to learn more.
 
 When attaching files to a message, you may also specify the display name and / or MIME type by passing an `array` as the second argument to the `attach` method:
@@ -916,7 +916,7 @@ php artisan make:notifications-table
 php artisan migrate
 ```
 
-> [!NOTE]  
+> [!NOTE]
 > If your notifiable models are using [UUID or ULID primary keys](/docs/{{version}}/eloquent#uuid-and-ulid-keys), you should replace the `morphs` method with [`uuidMorphs`](/docs/{{version}}/migrations#column-method-uuidMorphs) or [`ulidMorphs`](/docs/{{version}}/migrations#column-method-ulidMorphs) in the notification table migration.
 
 <a name="formatting-database-notifications"></a>
@@ -939,18 +939,26 @@ public function toArray(object $notifiable): array
 }
 ```
 
-When the notification is stored in your application's database, the `type` column will be populated with the notification's class name. However, you may customize this behavior by defining a `databaseType` method on your notification class:
+When a notification is stored in your application's database, the `type` column will be set to the notification's class name by default, and the `read_at` column will be `null`. However, you can customize this behavior by defining the `databaseType` and `initialDatabaseReadAtValue` methods in your notification class:
+
+    use Illuminate\Support\Carbon;
 
 ```php
 /**
  * Get the notification's database type.
- *
- * @return string
  */
 public function databaseType(object $notifiable): string
 {
     return 'invoice-paid';
 }
+
+/**
+ * Get the initial value for the "read_at" column.
+ */
+public function initialDatabaseReadAtValue(): ?Carbon
+{
+    return null;
+}
 ```
 
 <a name="todatabase-vs-toarray"></a>
@@ -981,7 +989,7 @@ foreach ($user->unreadNotifications as $notification) {
 }
 ```
 
-> [!NOTE]  
+> [!NOTE]
 > To access your notifications from your JavaScript client, you should define a notification controller for your application which returns the notifications for a notifiable entity, such as the current user. You may then make an HTTP request to that controller's URL from your JavaScript client.
 
 <a name="marking-notifications-as-read"></a>
@@ -1323,7 +1331,7 @@ public function toSlack(object $notifiable): SlackMessage
                 "type": "plain_text",
                 "text": "Team Announcement"
               }
-            }, 
+            },
             {
               "type": "section",
               "text": {
@@ -1466,7 +1474,7 @@ class User extends Authenticatable
 <a name="notifying-external-slack-workspaces"></a>
 ### Notifying External Slack Workspaces
 
-> [!NOTE]  
+> [!NOTE]
 > Before sending notifications to external Slack workspaces, your Slack App must be [distributed](#slack-app-distribution).
 
 Of course, you will often want to send notifications to the Slack workspaces owned by your application's users. To do so, you will first need to obtain a Slack OAuth token for the user. Thankfully, [Laravel Socialite](/docs/{{version}}/socialite) includes a Slack driver that will allow you to easily authenticate your application's users with Slack and [obtain a bot token](/docs/{{version}}/socialite#slack-bot-scopes).

responses.md

@@ -400,6 +400,39 @@ Route::get('/users.json', function () {
 });
 ```
 
+<a name="event-streams"></a>
+#### Event Streams
+
+The `eventStream` method may be used to return a server-sent events (SSE) streamed response using the `text/event-stream` content type. The `eventStream` method accepts a closure which should [yield](https://www.php.net/manual/en/language.generators.overview.php) responses to the stream as the responses become available:
+
+```php
+Route::get('/chat', function () {
+    return response()->eventStream(function () {
+        $stream = OpenAI::client()->chat()->createStreamed(...);
+
+        foreach ($stream as $response) {
+            yield $response->choices[0];
+        }
+    });
+});
+```
+
+This event stream may be consumed via an [EventSource](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) object by your application's frontend. The `eventStream` method will automatically send a `</stream>` update to the event stream when the stream is complete:
+
+```js
+const source = new EventSource('/chat');
+
+source.addEventListener('update', (event) => {
+    if (event.data === '</stream>') {
+        source.close();
+
+        return;
+    }
+
+    console.log(event.data);
+})
+```
+
 <a name="streamed-downloads"></a>
 #### Streamed Downloads
 

strings.md

@@ -713,7 +713,7 @@ You may disable case sensitivity by setting the `ignoreCase` argument to `true`:
 ```php
 use Illuminate\Support\Str;
 
-$matches = Str::is('*.jpg', 'photo.JPG', ignoreCase: true);     
+$matches = Str::is('*.jpg', 'photo.JPG', ignoreCase: true);
 
 // true
 ```