2025-08-11までの原文変更点反映。

Author: HiroKws

original-en/broadcasting.md

@@ -69,7 +69,7 @@ By default, broadcasting is not enabled in new Laravel applications. You may ena
 php artisan install:broadcasting
 ```
 
-The `install:broadcasting` command with prompt you for which event broadcasting service you would like to use. In addition, it will create the `config/broadcasting.php` configuration file and the `routes/channels.php` file where you may register your application's broadcast authorization routes and callbacks.
+The `install:broadcasting` command will prompt you for which event broadcasting service you would like to use. In addition, it will create the `config/broadcasting.php` configuration file and the `routes/channels.php` file where you may register your application's broadcast authorization routes and callbacks.
 
 Laravel supports several broadcast drivers out of the box: [Laravel Reverb](/docs/{{version}}/reverb), [Pusher Channels](https://pusher.com/channels), [Ably](https://ably.com), and a `log` driver for local development and debugging. Additionally, a `null` driver is included which allows you to disable broadcasting during testing. A configuration example is included for each of these drivers in the `config/broadcasting.php` configuration file.
 

original-en/collections.md

@@ -128,6 +128,7 @@ For the majority of the remaining collection documentation, we'll discuss each m
 [diffAssocUsing](#method-diffassocusing)
 [diffKeys](#method-diffkeys)
 [doesntContain](#method-doesntcontain)
+[doesntContainStrict](#method-doesntcontainstrict)
 [dot](#method-dot)
 [dump](#method-dump)
 [duplicates](#method-duplicates)
@@ -843,6 +844,11 @@ $collection->doesntContain('product', 'Bookcase');
 
 The `doesntContain` method uses "loose" comparisons when checking item values, meaning a string with an integer value will be considered equal to an integer of the same value.
 
+<a name="method-doesntcontainstrict"></a>
+#### `doesntContainStrict()` {.collection-method}
+
+This method has the same signature as the [doesntContain](#method-doesntcontain) method; however, all values are compared using "strict" comparisons.
+
 <a name="method-dot"></a>
 #### `dot()` {.collection-method}
 

original-en/container.md

@@ -178,6 +178,9 @@ $this->app->singletonIf(Transistor::class, function (Application $app) {
 });
 ```
 
+<a name="singleton-attribute"></a>
+#### Singleton Attribute
+
 Alternatively, you may mark an interface or class with the `#[Singleton]` attribute to indicate to the container that it should be resolved one time:
 
 ```php
@@ -217,6 +220,9 @@ $this->app->scopedIf(Transistor::class, function (Application $app) {
 });
 ```
 
+<a name="scoped-attribute"></a>
+#### Scoped Attribute
+
 Alternatively, you may mark an interface or class with the `#[Scoped]` attribute to indicate to the container that it should be resolved one time within a given Laravel request / job lifecycle:
 
 ```php
@@ -272,6 +278,45 @@ public function __construct(
 ) {}
 ```
 
+<a name="bind-attribute"></a>
+#### Bind Attribute
+
+Laravel also provides a `Bind` attribute for added convenience. You can apply this attribute to any interface to tell Laravel which implementation should be automatically injected whenever that interface is requested. When using the `Bind` attribute, there is no need to perform any additional service registration in your application's service providers.
+
+In addition, multiple `Bind` attributes may be placed on an interface in order to configure a different implementation that should be injected for a given set of environments:
+
+```php
+<?php
+
+namespace App\Contracts;
+
+use App\Services\FakeEventPusher;
+use App\Services\RedisEventPusher;
+use Illuminate\Container\Attributes\Bind;
+
+#[Bind(RedisEventPusher::class)]
+#[Bind(FakeEventPusher::class, environments: ['local', 'testing'])]
+interface EventPusher
+{
+    // ...
+}
+```
+
+Furthermore, [Singleton](#singleton-attribute) and [Scoped](#scoped-attribute) attributes may be applied to indicate if the container bindings should be resolved once or once per request / job lifecycle:
+
+```php
+use App\Services\RedisEventPusher;
+use Illuminate\Container\Attributes\Bind;
+use Illuminate\Container\Attributes\Singleton;
+
+#[Bind(RedisEventPusher::class)]
+#[Singleton]
+interface EventPusher
+{
+    // ...
+}
+```
+
 <a name="contextual-binding"></a>
 ### Contextual Binding
 

original-en/events.md

@@ -16,6 +16,7 @@
     - [Handling Failed Jobs](#handling-failed-jobs)
 - [Dispatching Events](#dispatching-events)
     - [Dispatching Events After Database Transactions](#dispatching-events-after-database-transactions)
+    - [Deferring Events](#deferring-events)
 - [Event Subscribers](#event-subscribers)
     - [Writing Event Subscribers](#writing-event-subscribers)
     - [Registering Event Subscribers](#registering-event-subscribers)
@@ -799,6 +800,26 @@ class OrderShipped implements ShouldDispatchAfterCommit
 }
 ```
 
+<a name="deferring-events"></a>
+### Deferring Events
+
+Deferred events allow you to delay the dispatching of model events and execution of event listeners until after a specific block of code has completed. This is particularly useful when you need to ensure that all related records are created before event listeners are triggered.
+
+To defer events, provide a closure to the `Event::defer()` method:
+
+```php
+use App\Models\User;
+use Illuminate\Support\Facades\Event;
+
+Event::defer(function () {
+    $user = User::create(['name' => 'Victoria Otwell']);
+
+    $user->posts()->create(['title' => 'My first post!']);
+});
+```
+
+All events triggered within the closure will be dispatched after the closure is executed. This ensures that event listeners have access to all related records that were created during the deferred execution. If an exception occurs within the closure, the deferred events will not be dispatched.
+
 <a name="event-subscribers"></a>
 ## Event Subscribers
 
@@ -935,6 +956,9 @@ test('orders can be shipped', function () {
     // Assert an event was dispatched twice...
     Event::assertDispatched(OrderShipped::class, 2);
 
+    // Assert an event was dispatched once...
+    Event::assertDispatchedOnce(OrderShipped::class);
+
     // Assert an event was not dispatched...
     Event::assertNotDispatched(OrderFailedToShip::class);
 
@@ -970,6 +994,9 @@ class ExampleTest extends TestCase
         // Assert an event was dispatched twice...
         Event::assertDispatched(OrderShipped::class, 2);
 
+        // Assert an event was dispatched once...
+        Event::assertDispatchedOnce(OrderShipped::class);
+
         // Assert an event was not dispatched...
         Event::assertNotDispatched(OrderFailedToShip::class);
 

original-en/helpers.md

@@ -46,6 +46,7 @@ Laravel includes a variety of global "helper" PHP functions. Many of these funct
 [Arr::crossJoin](#method-array-crossjoin)
 [Arr::divide](#method-array-divide)
 [Arr::dot](#method-array-dot)
+[Arr::every](#method-array-every)
 [Arr::except](#method-array-except)
 [Arr::exists](#method-array-exists)
 [Arr::first](#method-array-first)
@@ -79,6 +80,7 @@ Laravel includes a variety of global "helper" PHP functions. Many of these funct
 [Arr::set](#method-array-set)
 [Arr::shuffle](#method-array-shuffle)
 [Arr::sole](#method-array-sole)
+[Arr::some](#method-array-some)
 [Arr::sort](#method-array-sort)
 [Arr::sortDesc](#method-array-sort-desc)
 [Arr::sortRecursive](#method-array-sort-recursive)
@@ -152,6 +154,7 @@ Laravel includes a variety of global "helper" PHP functions. Many of these funct
 [route](#method-route)
 [secure_asset](#method-secure-asset)
 [secure_url](#method-secure-url)
+[to_action](#method-to-action)
 [to_route](#method-to-route)
 [uri](#method-uri)
 [url](#method-url)
@@ -388,6 +391,25 @@ $flattened = Arr::dot($array);
 // ['products.desk.price' => 100]
 ```
 
+<a name="method-array-every"></a>
+#### `Arr::every()` {.collection-method}
+
+The `Arr::every` method ensures that all values in the array pass a given truth test:
+
+```php
+use Illuminate\Support\Arr;
+
+$array = [1, 2, 3];
+
+Arr::every($array, fn ($i) => $i > 0);
+
+// true
+
+Arr::every($array, fn ($i) => $i > 2);
+
+// false
+```
+
 <a name="method-array-except"></a>
 #### `Arr::except()` {.collection-method}
 
@@ -1062,6 +1084,21 @@ $value = Arr::sole($array, fn (string $value) => $value === 'Desk');
 // 'Desk'
 ```
 
+<a name="method-array-some"></a>
+#### `Arr::some()` {.collection-method}
+
+The `Arr::some` method ensures that at least one of the values in the array passes a given truth test:
+
+```php
+use Illuminate\Support\Arr;
+
+$array = [1, 2, 3];
+
+Arr::some($array, fn ($i) => $i > 2);
+
+// true
+```
+
 <a name="method-array-sort"></a>
 #### `Arr::sort()` {.collection-method}
 
@@ -2100,6 +2137,28 @@ $url = secure_url('user/profile');
 $url = secure_url('user/profile', [1]);
 ```
 
+<a name="method-to-action"></a>
+#### `to_action()` {.collection-method}
+
+The `to_action` function generates a [redirect HTTP response](/docs/{{version}}/responses#redirects) for a given controller action:
+
+```php
+use App\Http\Controllers\UserController;
+
+return to_action([UserController::class, 'show'], ['user' => 1]);
+```
+
+If necessary, you may pass the HTTP status code that should be assigned to the redirect and any additional response headers as the third and fourth arguments to the `to_action` method:
+
+```php
+return to_action(
+    [UserController::class, 'show'],
+    ['user' => 1],
+    302,
+    ['X-Framework' => 'Laravel']
+);
+```
+
 <a name="method-to-route"></a>
 #### `to_route()` {.collection-method}
 
@@ -3165,6 +3224,9 @@ By default, deferred functions will only be executed if the HTTP response, Artis
 defer(fn () => Metrics::reportOrder($order))->always();
 ```
 
+> [!WARNING]
+> If you have the **swoole** PHP extension installed, Laravel's `defer` function may conflict with Swoole's own global `defer` function, leading to web server errors. Make sure you call Laravel's `defer` helper by explicitly namespacing it: `use function Illuminate\Support\defer;`
+
 <a name="cancelling-deferred-functions"></a>
 #### Cancelling Deferred Functions
 
@@ -3311,6 +3373,19 @@ $user = Pipeline::send($user)
     ->thenReturn();
 ```
 
+The `withinTransaction` method may be invoked on the pipeline to automatically wrap all steps of the pipeline within a single database transaction:
+
+```php
+$user = Pipeline::send($user)
+    ->withinTransaction()
+    ->through([
+        ProcessOrder::class,
+        TransferFunds::class,
+        UpdateInventory::class,
+    ])
+    ->thenReturn();
+```
+
 <a name="sleep"></a>
 ### Sleep
 

original-en/http-tests.md

@@ -258,7 +258,13 @@ class ExampleTest extends TestCase
 You may also specify which guard should be used to authenticate the given user by passing the guard name as the second argument to the `actingAs` method. The guard that is provided to the `actingAs` method will also become the default guard for the duration of the test:
 
 ```php
-$this->actingAs($user, 'web')
+$this->actingAs($user, 'web');
+```
+
+If you would like to ensure the request is unauthenticated, you may use the `actingAsGuest` method:
+
+```php
+$this->actingAsGuest();
 ```
 
 <a name="debugging-responses"></a>

original-en/mail.md

@@ -1291,6 +1291,9 @@ test('orders can be shipped', function () {
     // Assert a mailable was not sent...
     Mail::assertNotSent(AnotherMailable::class);
 
+    // Assert a mailable was sent twice...
+    Mail::assertSentTimes(OrderShipped::class, 2);
+
     // Assert 3 total mailables were sent...
     Mail::assertSentCount(3);
 });
@@ -1331,6 +1334,9 @@ class ExampleTest extends TestCase
         // Assert a mailable was not sent...
         Mail::assertNotSent(AnotherMailable::class);
 
+        // Assert a mailable was sent twice...
+        Mail::assertSentTimes(OrderShipped::class, 2);
+
         // Assert 3 total mailables were sent...
         Mail::assertSentCount(3);
     }

original-en/migrations.md

@@ -686,6 +686,14 @@ The `enum` method creates a `ENUM` equivalent column with the given valid values
 $table->enum('difficulty', ['easy', 'hard']);
 ```
 
+Of course, you may use the `Enum::cases()` method instead of manually defining an array of allowed values:
+
+```php
+use App\Enums\Difficulty;
+
+$table->enum('difficulty', Difficulty::cases());
+```
+
 <a name="column-method-float"></a>
 #### `float()` {.collection-method}
 

original-en/notifications.md

@@ -1668,6 +1668,9 @@ test('orders can be shipped', function () {
         [$user], AnotherNotification::class
     );
 
+    // Assert a notification was sent twice...
+    Notification::assertSentTimes(WeeklyReminder::class, 2);
+
     // Assert that a given number of notifications were sent...
     Notification::assertCount(3);
 });
@@ -1703,6 +1706,9 @@ class ExampleTest extends TestCase
             [$user], AnotherNotification::class
         );
 
+        // Assert a notification was sent twice...
+        Notification::assertSentTimes(WeeklyReminder::class, 2);
+
         // Assert that a given number of notifications were sent...
         Notification::assertCount(3);
     }

original-en/octane.md

@@ -12,6 +12,7 @@
     - [Watching for File Changes](#watching-for-file-changes)
     - [Specifying the Worker Count](#specifying-the-worker-count)
     - [Specifying the Max Request Count](#specifying-the-max-request-count)
+    - [Specifying the Max Execution Time](#specifying-the-max-execution-time)
     - [Reloading the Workers](#reloading-the-workers)
     - [Stopping the Server](#stopping-the-server)
 - [Dependency Injection and Octane](#dependency-injection-and-octane)
@@ -136,6 +137,17 @@ If the `--log-level` option is explicitly passed to the `php artisan octane:star
 
 You may consult [the official FrankenPHP documentation](https://frankenphp.dev/docs/docker/) for more information on running FrankenPHP with Docker.
 
+<a name="frankenphp-caddyfile"></a>
+#### Custom Caddyfile Configuration
+
+When using FrankenPHP, you may specify a custom Caddyfile using the `--caddyfile` option when starting Octane:
+
+```shell
+php artisan octane:start --server=frankenphp --caddyfile=/path/to/your/Caddyfile
+```
+
+This allows you to customize FrankenPHP's configuration beyond the default settings, such as adding custom middleware, configuring advanced routing, or setting up custom directives. You may consult the [official Caddy documentation](https://caddyserver.com/docs/caddyfile) for more information on Caddyfile syntax and configuration options.
+
 <a name="roadrunner"></a>
 ### RoadRunner
 
@@ -360,6 +372,20 @@ To help prevent stray memory leaks, Octane gracefully restarts any worker once i
 php artisan octane:start --max-requests=250
 ```
 
+<a name="specifying-the-max-execution-time"></a>
+### Specifying the Max Execution Time
+
+By default, Laravel Octane sets a maximum execution time of 30 seconds for incoming requests via the `max_execution_time` option in your application's `config/octane.php` configuration file:
+
+```php
+'max_execution_time' => 30,
+```
+
+This setting defines the maximum number of seconds that an incoming request is allowed to execute before being terminated. Setting this value to `0` will disable the execution time limit entirely. This configuration option is particularly useful for applications that handle long-running requests, such as file uploads, data processing, or API calls to external services.
+
+> [!WARNING]
+> When you modify the `max_execution_time` configuration, you must restart the Octane server for the changes to take effect.
+
 <a name="reloading-the-workers"></a>
 ### Reloading the Workers