2025-10-06までの原文変更点反映。

Author: HiroKws

original-en/authentication.md

@@ -567,7 +567,6 @@ Next, we will define a route that will handle the form request from the "confirm
 ```php
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Hash;
-use Illuminate\Support\Facades\Redirect;
 
 Route::post('/confirm-password', function (Request $request) {
     if (! Hash::check($request->password, $request->user()->password)) {

original-en/broadcasting.md

@@ -1697,3 +1697,22 @@ channel().notification((notification) => {
 ```
 
 In this example, all notifications sent to `App\Models\User` instances via the `broadcast` channel would be received by the callback. A channel authorization callback for the `App.Models.User.{id}` channel is included in your application's `routes/channels.php` file.
+
+<a name="stop-listening-for-notifications"></a>
+#### Stop Listening for Notifications
+
+If you would like to stop listening to notifications without [leaving the channel](#leaving-a-channel), you may use the `stopListeningForNotification` method:
+
+```js
+const callback = (notification) => {
+    console.log(notification.type);
+}
+
+// Start listening...
+Echo.private(`App.Models.User.${userId}`)
+    .notification(callback);
+
+// Stop listening (callback must be the same)...
+Echo.private(`App.Models.User.${userId}`)
+    .stopListeningForNotification(callback);
+```

original-en/database.md

@@ -391,7 +391,7 @@ DB::transaction(function () {
     DB::update('update users set votes = 1');
 
     DB::delete('delete from posts');
-}, 5);
+}, attempts: 5);
 ```
 
 <a name="manually-using-transactions"></a>

original-en/eloquent-factories.md

@@ -505,7 +505,7 @@ If you already have model instances that you would like to be attached to the mo
 ```php
 $roles = Role::factory()->count(3)->create();
 
-$user = User::factory()
+$users = User::factory()
     ->count(3)
     ->hasAttached($roles, ['active' => true])
     ->create();
@@ -555,7 +555,7 @@ Polymorphic "many to many" (`morphToMany` / `morphedByMany`) relationships may b
 use App\Models\Tag;
 use App\Models\Video;
 
-$videos = Video::factory()
+$video = Video::factory()
     ->hasAttached(
         Tag::factory()->count(3),
         ['public' => true]
@@ -566,7 +566,7 @@ $videos = Video::factory()
 Of course, the magic `has` method may also be used to create polymorphic "many to many" relationships:
 
 ```php
-$videos = Video::factory()
+$video = Video::factory()
     ->hasTags(3, ['public' => true])
     ->create();
 ```

original-en/http-client.md

@@ -11,6 +11,8 @@
     - [Guzzle Middleware](#guzzle-middleware)
     - [Guzzle Options](#guzzle-options)
 - [Concurrent Requests](#concurrent-requests)
+    - [Request Pooling](#request-pooling)
+    - [Request Batching](#request-batching)
 - [Macros](#macros)
 - [Testing](#testing)
     - [Faking Responses](#faking-responses)
@@ -500,6 +502,9 @@ public function boot(): void
 
 Sometimes, you may wish to make multiple HTTP requests concurrently. In other words, you want several requests to be dispatched at the same time instead of issuing the requests sequentially. This can lead to substantial performance improvements when interacting with slow HTTP APIs.
 
+<a name="request-pooling"></a>
+### Request Pooling
+
 Thankfully, you may accomplish this using the `pool` method. The `pool` method accepts a closure which receives an `Illuminate\Http\Client\Pool` instance, allowing you to easily add requests to the request pool for dispatching:
 
 ```php
@@ -552,6 +557,71 @@ $responses = Http::pool(fn (Pool $pool) => [
 ]);
 ```
 
+<a name="request-batching"></a>
+### Request Batching
+
+Another way of working with concurrent requests in Laravel is to use the `batch` method. Like the `pool` method, it accepts a closure which receives an `Illuminate\Http\Client\Batch` instance, allowing you to easily add requests to the request pool for dispatching, but it also allows you to define completion callbacks:
+
+```php
+use Illuminate\Http\Client\Batch;
+use Illuminate\Http\Client\RequestException;
+use Illuminate\Http\Client\Response;
+use Illuminate\Support\Facades\Http;
+
+$responses = Http::batch(fn (Batch $batch) => [
+    $batch->get('http://localhost/first'),
+    $batch->get('http://localhost/second'),
+    $batch->get('http://localhost/third'),
+])->before(function (Batch $batch) {
+    // The batch has been created but no requests have been initialized...
+})->progress(function (Batch $batch, int|string $key, Response $response) {
+    // An individual request has completed successfully...
+})->then(function (Batch $batch, array $results) {
+    // All requests completed successfully...
+})->catch(function (Batch $batch, int|string $key, Response|RequestException $response) {
+    // First batch request failure detected...
+})->finally(function (Batch $batch, array $results) {
+    // The batch has finished executing...
+})->send();
+```
+
+Like the `pool` method, you can use the `as` method to name your requests:
+
+```php
+$responses = Http::batch(fn (Batch $batch) => [
+    $batch->as('first')->get('http://localhost/first'),
+    $batch->as('second')->get('http://localhost/second'),
+    $batch->as('third')->get('http://localhost/third'),
+])->send();
+```
+
+After a `batch` is started by calling the `send` method, you can't add new requests to it. Trying to do so will result in a `Illuminate\Http\Client\BatchInProgressException` exception being thrown.
+
+<a name="inspecting-batches"></a>
+#### Inspecting Batches
+
+The `Illuminate\Http\Client\Batch` instance that is provided to batch completion callbacks has a variety of properties and methods to assist you in interacting with and inspecting a given batch of requests:
+
+```php
+// The number of requests assigned to the batch...
+$batch->totalRequests;
+ 
+// The number of requests that have not been processed yet...
+$batch->pendingRequests;
+ 
+// The number of requests that have failed...
+$batch->failedRequests;
+
+// The number of requests that have been processed thus far...
+$batch->processedRequests();
+
+// Indicates if the batch has finished executing...
+$batch->finished();
+
+// Indicates if the batch has request failures...
+$batch->hasFailures();
+```
+
 <a name="macros"></a>
 ## Macros
 

original-en/mcp.md

@@ -22,7 +22,7 @@
     - [Prompt Dependency Injection](#prompt-dependency-injection)
     - [Conditional Prompt Registration](#conditional-prompt-registration)
     - [Prompt Responses](#prompt-responses)
-- [Resources](#creating-resources)
+- [Resources](#resources)
     - [Creating Resources](#creating-resources)
     - [Resource URI and MIME Type](#resource-uri-and-mime-type)
     - [Resource Request](#resource-request)

original-en/octane.md

@@ -258,6 +258,23 @@ php artisan octane:start
 
 By default, Octane will start the server on port 8000, so you may access your application in a web browser via `http://localhost:8000`.
 
+<a name="keeping-octane-running-in-production"></a>
+#### Keeping Octane Running in Production
+
+If you are deploying your Octane application to production, you should use a process monitor such as Supervisor to ensure the Octane server stays running. A sample Supervisor configuration file for Octane might look like the following:
+
+```ini
+[program:octane]
+process_name=%(program_name)s_%(process_num)02d
+command=php /home/forge/example.com/artisan octane:start --server=frankenphp --host=127.0.0.1 --port=8000
+autostart=true
+autorestart=true
+user=forge
+redirect_stderr=true
+stdout_logfile=/home/forge/example.com/storage/logs/octane.log
+stopwaitsecs=3600
+```
+
 <a name="serving-your-application-via-https"></a>
 ### Serving Your Application via HTTPS
 

original-en/queues.md

@@ -1470,6 +1470,67 @@ class ProcessSubscriptionRenewal implements ShouldQueue
 }
 ```
 
+<a name="fifo-listeners-mail-and-notifications"></a>
+#### FIFO Listeners, Mail, and Notifications
+
+When utilizing FIFO queues, you will also need to define message groups on listeners, mail, and notifications. Alternatively, you can dispatch queued instances of these objects to a non-FIFO queue.
+
+To define the message group for a [queued event listener](/docs/{{version}}/events#queued-event-listeners), define a `messageGroup` method on the listener. You may also optionally define a `deduplicationId` method:
+
+```php
+<?php
+
+namespace App\Listeners;
+
+use App\Events\OrderShipped;
+
+class SendShipmentNotification
+{
+    // ...
+
+    /**
+     * Get the job's message group.
+     */
+    public function messageGroup(): string
+    {
+        return "shipments";
+    }
+
+    /**
+     * Get the job's deduplication ID.
+     */
+    public function deduplicationId(): string
+    {
+        return "shipment-notification-{$this->shipment->id}";
+    }
+}
+```
+
+When sending a [mail message](/docs/{{version}}/mail) that is going to be queued on a FIFO queue, you should invoke the `onGroup` method and optionally the `withDeduplicator` method when sending the notification:
+
+```php
+use App\Mail\InvoicePaid;
+use Illuminate\Support\Facades\Mail;
+
+$invoicePaid = (new InvoicePaid($invoice))
+    ->onGroup('invoices')
+    ->withDeduplicator(fn () => 'invoices-'.$invoice->id);
+
+Mail::to($request->user())->send($invoicePaid);
+```
+
+When sending a [notification](/docs/{{version}}/notifications) that is going to be queued on a FIFO queue, you should invoke the `onGroup` method and optionally the `withDeduplicator` method when sending the notification:
+
+```php
+use App\Notifications\InvoicePaid;
+
+$invoicePaid = (new InvoicePaid($invoice))
+    ->onGroup('invoices')
+    ->withDeduplicator(fn () => 'invoices-'.$invoice->id);
+
+$user->notify($invoicePaid);
+```
+
 <a name="error-handling"></a>
 ### Error Handling
 
@@ -1563,10 +1624,10 @@ class SyncChatHistory implements ShouldQueue
      */
     public function handle(): void
     {
-        $user->authorize('sync-chat-history');
+        $this->user->authorize('sync-chat-history');
 
         $response = Http::throw()->get(
-            "https://chat.laravel.test/?user={$user->uuid}"
+            "https://chat.laravel.test/?user={$this->user->uuid}"
         );
 
         // ...
@@ -1885,6 +1946,16 @@ $batch = Bus::batch([
 })->allowFailures()->dispatch();
 ```
 
+You may optionally provide a closure to the `allowFailures` method, which will be executed on each job failure:
+
+```php
+$batch = Bus::batch([
+    // ...
+])->allowFailures(function (Batch $batch, $exception) {
+    // Handle individual job failures...
+})->dispatch();
+```
+
 <a name="retrying-failed-batch-jobs"></a>
 #### Retrying Failed Batch Jobs
 

original-en/routing.md

@@ -945,6 +945,29 @@ RateLimiter::for('uploads', function (Request $request) {
 });
 ```
 
+<a name="response-base-rate-limiting"></a>
+#### Response-Based Rate Limiting
+
+In addition to rate limiting incoming requests, Laravel allows you to rate limit based on the response using the `after` method. This is useful when you only want to count certain responses toward the rate limit, such as validation errors, 404 responses, or other specific HTTP status codes.
+
+The `after` method accepts a closure that receives the response and should return `true` if the response should be counted toward the rate limit, or `false` if it should be ignored. This is particularly useful for preventing enumeration attacks by limiting consecutive 404 responses, or allowing users to retry requests that fail validation without exhausting their rate limit on an endpoint that should only throttle successful operations:
+
+```php
+use Illuminate\Cache\RateLimiting\Limit;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\RateLimiter;
+use Symfony\Component\HttpFoundation\Response;
+
+RateLimiter::for('resource-not-found', function (Request $request) {
+    return Limit::perMinute(10)
+        ->by($request->user()?->id ?: $request->ip())
+        ->after(function (Response $response) {
+            // Only count 404 responses toward the rate limit to prevent enumeration...
+            return $response->status() === 404;
+        });
+});
+```
+
 <a name="attaching-rate-limiters-to-routes"></a>
 ### Attaching Rate Limiters to Routes