docs: document platform-level cancellation via external signal

Add documentation for the `signal` option on `newTurn()`, which lets
the server pass `req.signal` to abort turns on request cancellation or
serverless function timeout. Updates cancel feature page (new section),
turns concept page (abort signal section), and server transport
internals (newTurn description).

Author: mschristensen

docs/concepts/turns.md

@@ -110,12 +110,13 @@ On the client, each `send()` call returns its own `ActiveTurn`. Cancellation is
 
 ## The abort signal
 
-Each server-side turn exposes an `AbortSignal` that fires when the turn is cancelled:
+Each server-side turn exposes an `AbortSignal` that fires when the turn is cancelled. The signal has two sources: Ably cancel messages from clients, and an optional external signal (typically `req.signal`) for platform-level cancellation like request cancellation or serverless function timeout.
 
 ```typescript
 const turn = transport.newTurn({
   turnId,
   clientId,
+  signal: req.signal, // platform-level cancellation (optional)
   onCancel: async (request) => {
     // Return false to reject the cancel (turn continues)
     // Return true to allow it (abortSignal fires)
@@ -132,6 +133,8 @@ const turn = transport.newTurn({
 const result = streamText({ model, messages, abortSignal: turn.abortSignal });
 ```
 
-The `onCancel` hook lets you authorize cancellation - useful for preventing one user from cancelling another user's turn. The `onAbort` hook runs after the signal fires, giving you a chance to write final data before the stream closes.
+The `onCancel` hook lets you authorize cancellation - useful for preventing one user from cancelling another user's turn. It only fires for Ably cancel messages, not for the external signal. The `onAbort` hook runs after the signal fires from either source, giving you a chance to write final data before the stream closes.
+
+See [Platform-level cancellation](../features/cancel.md#platform-level-cancellation) for details on the `signal` option.
 
 For the internal mechanics, see [TurnManager](../internals/transport-components.md#turnmanager) and [pipeStream](../internals/transport-components.md#pipestream) for how abort signals flow through the system, and [Wire protocol](../internals/wire-protocol.md#turn-lifecycle-over-the-wire) for the message sequence on the channel.

docs/features/cancel.md

@@ -102,6 +102,24 @@ sequenceDiagram
 
 The client closes its local streams immediately on cancel - it doesn't wait for the server to confirm. The server-side turn ends with `reason: 'cancelled'`, which all clients see via turn lifecycle events.
 
+## Platform-level cancellation
+
+Ably cancel messages are the primary cancellation path, but the server may also need to abort a turn when the platform signals shutdown - the HTTP request is cancelled, or a serverless function hits its execution timeout.
+
+Pass the platform's abort signal to `newTurn()` via the `signal` option:
+
+```typescript
+const turn = transport.newTurn({
+  turnId,
+  clientId,
+  signal: req.signal, // fires on request cancellation or function timeout
+});
+```
+
+When the external signal fires, it aborts the turn through the same path as an Ably cancel message - `turn.abortSignal` fires, `streamText` stops generation, and `pipeStream` closes the stream. The `onCancel` hook is **not** called for platform-level signals (it only fires for Ably cancel messages), but `onAbort` runs normally.
+
+Internally, `AbortSignal.any()` composes the external signal with the turn's own abort controller, so either source triggers the same downstream abort.
+
 ## Cancel on close
 
 Cancel active turns as part of transport teardown:

docs/internals/server-transport.md

@@ -40,7 +40,7 @@ sequenceDiagram
 
 Synchronous - no channel activity. Creates a `Turn` object and registers it for cancel routing immediately, so early cancels (arriving before `start()`) fire the abort signal.
 
-Each turn gets its own `AbortController`. The `abortSignal` property exposes it so the server app can pass it to LLM calls.
+Each turn gets its own `AbortController`. If `opts.signal` is provided (typically `req.signal` from the HTTP request), `AbortSignal.any()` composes it with the controller's signal into a single composite signal. The `abortSignal` property exposes this composite signal so the server app can pass it to LLM calls. Either source - an Ably cancel message or the external signal - triggers the same downstream abort.
 
 ### start