@tanstack/ai-sandbox 0.2.3 → 0.3.0

package/dist/esm/run.d.ts

@@ -1,27 +1,74 @@
-import { StreamChunk } from '@tanstack/ai';
-import { RunEvent, RunEventLog, RunRecord } from './run-log.js';
-export interface PipeToRunLogOptions {
-    log: RunEventLog;
+import { InternalLogger } from '@tanstack/ai/adapter-internals';
+import { RunRecord, RunStore, StreamChunk, StreamDurability } from '@tanstack/ai';
+/**
+ * The two durable seams a run driver needs: lifecycle record + event log.
+ *
+ * Generic in the log's offset type, and DEFAULTED to `string` so every existing
+ * call site keeps compiling unchanged. The parameter is not decoration: a
+ * backend that brands its cursors — `@tanstack/ai-durable-stream`'s
+ * `durableStream` returns `StreamDurability<DurableStreamOffset>` — is NOT
+ * assignable to `StreamDurability<string>`, because `read` takes an offset and
+ * is therefore contravariant in it. Hardcoding the default here made the
+ * production multi-host backend unusable without a cast (see
+ * `tests/offset-generics.test-d.ts`).
+ */
+export interface RunDeps<TOffset extends string = string> {
+    /** Run lifecycle record (status, thread, timings). */
+    runs: RunStore;
+    /**
+     * Per-run delivery-durable event log the run's chunks are appended to.
+     *
+     * A FACTORY, not an instance, and that is load-bearing rather than stylistic.
+     * A `StreamDurability` is bound to one run — `memoryStream(request)` resolves
+     * its `runId` from the request, and a backend adapter's offsets embed a cursor
+     * into one log. Holding a single instance made two failures reachable:
+     *
+     * - **Silent mis-binding at concurrency 1.** `start({ runId })` accepted an
+     *   arbitrary id while the instance was bound to another, writing the record
+     *   under one id and the events under another with no error raised. Resolving
+     *   the log FROM the `runId` makes that unrepresentable.
+     * - **Cross-talk at concurrency > 1.** Parallel runs interleaved their chunks
+     *   into one log, and whichever finished first called `close()` and
+     *   terminalized every other run's stream.
+     *
+     * Called exactly once per run, at the start of {@link pipeToRunLog}. An
+     * implementation MUST return the same instance for the same `runId` within a
+     * process if it wants `snapshot()` to see its own appends.
+     */
+    durability: (runId: string) => StreamDurability<TOffset>;
+    /**
+     * Optional sink for failures this driver absorbs rather than rejecting with.
+     * A detached run has no caller to receive an error, so without a logger a
+     * failing store or event log is invisible to an operator. Same
+     * `logger?.errors(...)` contract core uses in `stream-to-response.ts`.
+     */
+    logger?: InternalLogger;
+}
+export interface PipeToRunLogOptions<TOffset extends string = string> extends RunDeps<TOffset> {
     runId: string;
-    threadId?: string;
+    threadId: string;
     /** Abort consumption mid-stream; the run finishes as `aborted`. */
     signal?: AbortSignal;
 }
 /**
  * Open the run, append every chunk from `stream`, and finish with the right
  * terminal status. Resolves with the final {@link RunRecord} and never rejects:
- * a thrown stream error is surfaced as a `RUN_ERROR` event + the record's
- * `error`, which is what tailing clients see.
+ * a thrown stream error is surfaced as a `RUN_ERROR` event plus the record's
+ * `error`, which is what tailing clients see. A store or event-log failure
+ * along the way is logged through {@link RunDeps.logger} and still terminalizes
+ * the run rather than escaping to a caller that does not exist.
  *
- * - normal completion → `finish('done')`
- * - a `RUN_ERROR` chunk → append it, then `finish('error', { message, code })`
- * - the stream throws → append a synthesized `RUN_ERROR`, then `finish('error')`
- * - `signal` aborts mid-stream → stop consuming, `finish('aborted')`
+ * - normal completion → `completed`
+ * - a `RUN_ERROR` chunk → append it, then `failed`
+ * - the stream throws → append a synthesized `RUN_ERROR`, then `failed`
+ * - `signal` aborts at ANY point before the stream ends → `aborted`, whether the
+ *   producer keeps yielding, ends its stream, or is never asked for another
+ *   chunk. An abort outranks a clean exit: the run did not complete.
  */
-export declare function pipeToRunLog(stream: AsyncIterable<StreamChunk>, opts: PipeToRunLogOptions): Promise<RunRecord>;
+export declare function pipeToRunLog<TOffset extends string = string>(stream: AsyncIterable<StreamChunk>, opts: PipeToRunLogOptions<TOffset>): Promise<RunRecord>;
 export interface RunControllerStartInput {
     runId: string;
-    threadId?: string;
+    threadId: string;
     stream: AsyncIterable<StreamChunk>;
     /** Abort consumption mid-stream; the run finishes as `aborted`. */
     signal?: AbortSignal;
@@ -32,27 +79,48 @@ export interface RunHandle {
     done: Promise<RunRecord>;
 }
 /**
- * Thin orchestration helper over a {@link RunEventLog}: fire-and-track a run via
- * {@link pipeToRunLog}, tail it from a cursor, and `drain()` all in-flight runs
+ * Thin orchestration helper over {@link RunDeps}: fire-and-track a run via
+ * {@link pipeToRunLog}, tail one run by id, and `drain()` all in-flight runs
  * (e.g. inside a `ctx.waitUntil`). Holds no run state of its own beyond the set
  * of currently in-flight `done` promises.
+ *
+ * Safe for concurrent runs. {@link RunDeps.durability} is a per-run factory, so
+ * each run appends to its own log and no run's `close()` terminalizes another's.
+ * The identity trap this class used to document — `start({ runId })` writing the
+ * lifecycle record under one id and the events under another, silently and at
+ * concurrency 1 — is unrepresentable now that the log is resolved FROM the
+ * `runId`. Every method is keyed by run accordingly: `attach(runId, …)` and
+ * `status(runId)` no longer disagree about whether the surface is per-run.
  */
-export declare class RunController {
-    private readonly log;
+export declare class RunController<TOffset extends string = string> {
+    private readonly deps;
     private readonly inFlight;
-    constructor(log: RunEventLog);
+    constructor(deps: RunDeps<TOffset>);
     /**
      * Kick off `pipeToRunLog` without awaiting it and return the `runId`
      * immediately plus a `done` promise the orchestrator may await or detach.
      */
     start(input: RunControllerStartInput): RunHandle;
-    /** Resumable client tail — replay from `fromSeq`, then live-tail to terminal. */
-    attach(runId: string, opts?: {
-        fromSeq?: number;
-        signal?: AbortSignal;
-    }): AsyncIterable<RunEvent>;
-    /** Current run record, or null if the run is unknown. */
+    /**
+     * Resumable client tail for ONE run — replay from `fromOffset`, then
+     * live-tail. Takes `runId` because the log it reads is per-run; the old
+     * `attach(fromOffset)` signature advertised a multi-run surface the type could
+     * not deliver.
+     */
+    attach(runId: string, fromOffset: TOffset, signal?: AbortSignal): AsyncIterable<{
+        offset: TOffset;
+        chunk: StreamChunk;
+    }>;
+    /** Current run record, or null when the run is unknown. */
     status(runId: string): Promise<RunRecord | null>;
-    /** Await every currently in-flight run's `done` promise. */
+    /**
+     * Await every currently in-flight run's `done` promise.
+     *
+     * Uses `allSettled` rather than `all` because this is typically awaited
+     * inside a `ctx.waitUntil`: `all` would reject on the first failure, abandon
+     * the wait on every other run, and surface that rejection to the platform.
+     * Draining is about keeping the isolate alive until the runs settle; each
+     * run's own outcome is already recorded in its record and log.
+     */
     drain(): Promise<void>;
 }

package/dist/esm/run.js

@@ -1,89 +1,284 @@
 import { EventType } from "@tanstack/ai";
+import { toRunErrorPayload } from "@tanstack/ai/adapter-internals";
+//#region src/run.ts
+/**
+* The "run driver" for the inverted/serverless sandbox model: pump a `chat()`
+* stream into core's two durable seams — a {@link RunStore} for the run's
+* lifecycle record and a {@link StreamDurability} for its event log — so a
+* trigger can return immediately while a durable orchestrator drives the run
+* and clients tail from an opaque offset.
+*
+* The key inversion vs. a classic request/response handler: there is no caller
+* holding the stream open, so nothing to throw an error *back to*. The event log
+* is the only channel — every chunk (including a terminal
+* {@link EventType.RUN_ERROR}) is appended and assigned a resumable offset, and
+* a thrown stream error is recorded as a synthesized `RUN_ERROR` event plus the
+* record's `error` field. Tailing clients therefore always observe failures;
+* {@link pipeToRunLog} never rejects.
+*
+* "Never rejects" is load-bearing rather than aspirational: {@link RunController}
+* consumes the returned promise fire-and-forget, so a rejection would be an
+* unhandled rejection (process-fatal on modern Node, instance-fatal inside a
+* Durable Object) with nobody to report it to. Every store/log call is therefore
+* individually guarded, and because absorbing a failure silently in the one
+* module whose premise is that nobody is listening would make the failure
+* invisible, each guard reports through the optional {@link RunDeps.logger}.
+*/
+/** Whether a chunk is the terminal error event the chat engine emits. */
 function isRunErrorChunk(chunk) {
-  return chunk.type === EventType.RUN_ERROR;
+	return chunk.type === EventType.RUN_ERROR;
 }
-function runErrorFromChunk(chunk) {
-  return chunk.code !== void 0 ? { message: chunk.message, code: chunk.code } : { message: chunk.message };
+/**
+* Narrow a thrown value (or a `RUN_ERROR` chunk's payload) to the record's
+* structured error, keeping the provider's `code` when it supplies one: a bare
+* message is prose that changes between model versions, while `code` is what a
+* consumer branches on to retry, escalate, or show specific UI.
+*/
+function toRunError(error) {
+	const payload = toRunErrorPayload(error);
+	return {
+		message: payload.message,
+		...payload.code === void 0 ? {} : { code: payload.code }
+	};
 }
-function messageOf(error) {
-  return error instanceof Error ? error.message : String(error);
+/**
+* Fold a secondary failure into the primary error, mirroring `combineFailures`
+* in `packages/ai/src/stream-to-response.ts`: the primary cause stays first and
+* keeps its `code`, and the phase that produced the secondary failure is named.
+* The secondary must never *replace* the primary: the provider's error is what
+* an operator needs, and a failure while recording it is the lesser fact.
+*/
+function withSecondaryFailure(primary, secondary, phase) {
+	return {
+		...primary,
+		message: `${primary.message}; ${phase}: ${toRunError(secondary).message}`
+	};
 }
-function syntheticRunError(message) {
-  const chunk = {
-    type: EventType.RUN_ERROR,
-    message
-  };
-  return chunk;
+/** Build the synthetic RUN_ERROR chunk appended when the stream throws. */
+function syntheticRunError(error) {
+	return {
+		type: EventType.RUN_ERROR,
+		message: error.message,
+		...error.code === void 0 ? {} : { code: error.code }
+	};
 }
-async function pipeToRunLog(stream, opts) {
-  const { log, runId, threadId, signal } = opts;
-  await log.open(threadId !== void 0 ? { runId, threadId } : { runId });
-  if (signal?.aborted) {
-    await log.finish(runId, "aborted");
-    return reread(log, runId);
-  }
-  try {
-    for await (const chunk of stream) {
-      if (signal?.aborted) {
-        await log.finish(runId, "aborted");
-        return reread(log, runId);
-      }
-      await log.append(runId, chunk);
-      if (isRunErrorChunk(chunk)) {
-        await log.finish(runId, "error", runErrorFromChunk(chunk));
-        return reread(log, runId);
-      }
-    }
-  } catch (error) {
-    const message = messageOf(error);
-    await log.append(runId, syntheticRunError(message));
-    await log.finish(runId, "error", { message });
-    return reread(log, runId);
-  }
-  await log.finish(runId, "done");
-  return reread(log, runId);
+/**
+* Report through a consumer-supplied logger without letting it break the
+* caller. Every logger call in this module sits inside a `catch` body, so an
+* throwing sink would escape that body and defeat the totality the guards
+* exist to provide. Swallowing here is deliberate: there is no second channel
+* left to report a reporting failure on.
+*/
+function safeLog(logger, message, context) {
+	try {
+		logger?.errors(message, context);
+	} catch {}
 }
-async function reread(log, runId) {
-  const latest = await log.get(runId);
-  if (!latest) throw new Error(`run: record for "${runId}" vanished mid-run`);
-  return latest;
+/**
+* Record the terminal status, terminalize the event log, and answer with the
+* run's final record.
+*
+* TOTAL BY CONSTRUCTION: every step is individually guarded, so this never
+* throws and never rejects. Two consequences the guards buy:
+*
+* - `durability.close()` runs on EVERY exit path, including a failed `update`.
+*   Skipping it would wedge the record at `running` *and* park every live
+*   tailer forever, because a durability `read` only ends once the log closes.
+* - The re-read of the record is best effort. An eventually-consistent or
+*   read-replica store may answer `null` for a run that was just driven, which
+*   must not turn a successful run into a rejection; the locally rebuilt record
+*   is returned instead. It is also preferred outright when `update` failed,
+*   since the store then still holds the stale `running` row.
+*
+* THE TERMINAL WRITE IS NOT GUARANTEED TO LAND, and this function deliberately
+* does not check whether it did. Under `sandboxRunDriver` the `runs` handed in is
+* `fenceRunStore`d (`src/claim.ts`), which SUPPRESSES a terminal write — resolving
+* without writing — when the driver has lost its claim, because a host that no
+* longer owns the run must not declare it over while the successor is streaming
+* it. From here that is indistinguishable from a successful write, on purpose:
+* the epoch belongs to the claim module, not to this generic driver, and the
+* re-read below then answers with the successor's live record, which is the
+* truthful thing to resolve with. A driver wired without a claim (a plain
+* `pipeToRunLog` call) is unfenced and always writes.
+*/
+async function finish(ctx, status, error) {
+	const { runs, durability, runId, logger } = ctx;
+	const patch = {
+		status,
+		finishedAt: Date.now(),
+		...error === void 0 ? {} : { error }
+	};
+	const local = {
+		runId,
+		threadId: ctx.threadId,
+		startedAt: ctx.startedAt,
+		...patch
+	};
+	let recorded = true;
+	try {
+		await runs.update(runId, patch);
+	} catch (updateError) {
+		recorded = false;
+		safeLog(logger, "run: recording the terminal run record failed", {
+			runId,
+			status,
+			error: updateError
+		});
+	}
+	try {
+		await durability.close();
+	} catch (closeError) {
+		safeLog(logger, "run: closing the run event log failed", {
+			runId,
+			status,
+			error: closeError
+		});
+	}
+	if (!recorded) return local;
+	try {
+		const latest = await runs.get(runId);
+		if (latest !== null) return latest;
+		safeLog(logger, "run: record vanished before the terminal re-read", {
+			runId,
+			status
+		});
+	} catch (getError) {
+		safeLog(logger, "run: re-reading the terminal run record failed", {
+			runId,
+			status,
+			error: getError
+		});
+	}
+	return local;
 }
-class RunController {
-  constructor(log) {
-    this.log = log;
-  }
-  log;
-  inFlight = /* @__PURE__ */ new Set();
-  /**
-   * Kick off `pipeToRunLog` without awaiting it and return the `runId`
-   * immediately plus a `done` promise the orchestrator may await or detach.
-   */
-  start(input) {
-    const done = pipeToRunLog(input.stream, {
-      log: this.log,
-      runId: input.runId,
-      ...input.threadId !== void 0 ? { threadId: input.threadId } : {},
-      ...input.signal !== void 0 ? { signal: input.signal } : {}
-    });
-    this.inFlight.add(done);
-    void done.finally(() => this.inFlight.delete(done));
-    return { runId: input.runId, done };
-  }
-  /** Resumable client tail — replay from `fromSeq`, then live-tail to terminal. */
-  attach(runId, opts) {
-    return this.log.read(runId, opts);
-  }
-  /** Current run record, or null if the run is unknown. */
-  status(runId) {
-    return this.log.get(runId);
-  }
-  /** Await every currently in-flight run's `done` promise. */
-  async drain() {
-    await Promise.all([...this.inFlight]);
-  }
+/**
+* Open the run, append every chunk from `stream`, and finish with the right
+* terminal status. Resolves with the final {@link RunRecord} and never rejects:
+* a thrown stream error is surfaced as a `RUN_ERROR` event plus the record's
+* `error`, which is what tailing clients see. A store or event-log failure
+* along the way is logged through {@link RunDeps.logger} and still terminalizes
+* the run rather than escaping to a caller that does not exist.
+*
+* - normal completion → `completed`
+* - a `RUN_ERROR` chunk → append it, then `failed`
+* - the stream throws → append a synthesized `RUN_ERROR`, then `failed`
+* - `signal` aborts at ANY point before the stream ends → `aborted`, whether the
+*   producer keeps yielding, ends its stream, or is never asked for another
+*   chunk. An abort outranks a clean exit: the run did not complete.
+*/
+async function pipeToRunLog(stream, opts) {
+	const { runs, runId, threadId, signal, logger } = opts;
+	const durability = opts.durability(runId);
+	const ctx = {
+		runs,
+		durability,
+		runId,
+		threadId,
+		startedAt: Date.now(),
+		...logger === void 0 ? {} : { logger }
+	};
+	try {
+		await runs.createOrResume({
+			runId,
+			threadId,
+			startedAt: ctx.startedAt
+		});
+		if (signal?.aborted) return finish(ctx, "aborted");
+		for await (const chunk of stream) {
+			if (signal?.aborted) return finish(ctx, "aborted");
+			await durability.append([chunk]);
+			if (isRunErrorChunk(chunk)) return finish(ctx, "failed", toRunError({
+				message: chunk.message,
+				code: chunk.code
+			}));
+		}
+	} catch (streamError) {
+		let recorded = toRunError(streamError);
+		safeLog(logger, "run: the run failed before completing", {
+			runId,
+			error: streamError
+		});
+		try {
+			await durability.append([syntheticRunError(recorded)]);
+		} catch (appendError) {
+			const phase = "appending the synthesized RUN_ERROR failed";
+			safeLog(logger, `run: ${phase}`, {
+				runId,
+				error: appendError
+			});
+			recorded = withSecondaryFailure(recorded, appendError, phase);
+		}
+		return finish(ctx, "failed", recorded);
+	}
+	if (signal?.aborted) return finish(ctx, "aborted");
+	return finish(ctx, "completed");
 }
-export {
-  RunController,
-  pipeToRunLog
+/**
+* Thin orchestration helper over {@link RunDeps}: fire-and-track a run via
+* {@link pipeToRunLog}, tail one run by id, and `drain()` all in-flight runs
+* (e.g. inside a `ctx.waitUntil`). Holds no run state of its own beyond the set
+* of currently in-flight `done` promises.
+*
+* Safe for concurrent runs. {@link RunDeps.durability} is a per-run factory, so
+* each run appends to its own log and no run's `close()` terminalizes another's.
+* The identity trap this class used to document — `start({ runId })` writing the
+* lifecycle record under one id and the events under another, silently and at
+* concurrency 1 — is unrepresentable now that the log is resolved FROM the
+* `runId`. Every method is keyed by run accordingly: `attach(runId, …)` and
+* `status(runId)` no longer disagree about whether the surface is per-run.
+*/
+var RunController = class {
+	deps;
+	inFlight = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/**
+	* Kick off `pipeToRunLog` without awaiting it and return the `runId`
+	* immediately plus a `done` promise the orchestrator may await or detach.
+	*/
+	start(input) {
+		const done = pipeToRunLog(input.stream, {
+			...this.deps,
+			runId: input.runId,
+			threadId: input.threadId,
+			...input.signal !== void 0 ? { signal: input.signal } : {}
+		});
+		this.inFlight.add(done);
+		const forget = () => void this.inFlight.delete(done);
+		done.then(forget, forget);
+		return {
+			runId: input.runId,
+			done
+		};
+	}
+	/**
+	* Resumable client tail for ONE run — replay from `fromOffset`, then
+	* live-tail. Takes `runId` because the log it reads is per-run; the old
+	* `attach(fromOffset)` signature advertised a multi-run surface the type could
+	* not deliver.
+	*/
+	attach(runId, fromOffset, signal) {
+		return this.deps.durability(runId).read(fromOffset, signal);
+	}
+	/** Current run record, or null when the run is unknown. */
+	status(runId) {
+		return this.deps.runs.get(runId);
+	}
+	/**
+	* Await every currently in-flight run's `done` promise.
+	*
+	* Uses `allSettled` rather than `all` because this is typically awaited
+	* inside a `ctx.waitUntil`: `all` would reject on the first failure, abandon
+	* the wait on every other run, and surface that rejection to the platform.
+	* Draining is about keeping the isolate alive until the runs settle; each
+	* run's own outcome is already recorded in its record and log.
+	*/
+	async drain() {
+		await Promise.allSettled([...this.inFlight]);
+	}
 };
-//# sourceMappingURL=run.js.map
+//#endregion
+export { RunController, pipeToRunLog };
+
+//# sourceMappingURL=run.js.map

package/dist/esm/run.js.map

@@ -1 +1 @@
-{"version":3,"file":"run.js","sources":["../../src/run.ts"],"sourcesContent":["/**\n * The \"run driver\" for the inverted/serverless sandbox model: pump a `chat()`\n * stream into a {@link RunEventLog} so a trigger can return immediately while a\n * durable orchestrator drives the run and clients tail from a cursor.\n *\n * The key inversion vs. a classic request/response handler: there is no caller\n * holding the stream open, so nothing to throw an error *back to*. The log is\n * the only channel — every chunk (including a terminal {@link EventType.RUN_ERROR})\n * is persisted under a `seq`, and a thrown stream error is recorded as a\n * synthesized `RUN_ERROR` event plus the record's `error` field. Tailing clients\n * therefore always observe failures; {@link pipeToRunLog} never rejects.\n */\nimport { EventType } from '@tanstack/ai'\nimport type { StreamChunk } from '@tanstack/ai'\nimport type { RunError, RunEvent, RunEventLog, RunRecord } from './run-log'\n\n/** Whether a chunk is the terminal error event the chat engine emits. */\nfunction isRunErrorChunk(\n  chunk: StreamChunk,\n): chunk is StreamChunk & { message: string; code?: string } {\n  return chunk.type === EventType.RUN_ERROR\n}\n\n/** Pull `{ message, code }` off a RUN_ERROR chunk for the run record. */\nfunction runErrorFromChunk(\n  chunk: StreamChunk & { message: string; code?: string },\n): RunError {\n  return chunk.code !== undefined\n    ? { message: chunk.message, code: chunk.code }\n    : { message: chunk.message }\n}\n\n/** Render an unknown thrown value as a stable error message. */\nfunction messageOf(error: unknown): string {\n  return error instanceof Error ? error.message : String(error)\n}\n\n/** Build the synthetic RUN_ERROR chunk appended when the stream throws. */\nfunction syntheticRunError(message: string): StreamChunk {\n  const chunk: { type: EventType.RUN_ERROR; message: string } = {\n    type: EventType.RUN_ERROR,\n    message,\n  }\n  return chunk\n}\n\nexport interface PipeToRunLogOptions {\n  log: RunEventLog\n  runId: string\n  threadId?: string\n  /** Abort consumption mid-stream; the run finishes as `aborted`. */\n  signal?: AbortSignal\n}\n\n/**\n * Open the run, append every chunk from `stream`, and finish with the right\n * terminal status. Resolves with the final {@link RunRecord} and never rejects:\n * a thrown stream error is surfaced as a `RUN_ERROR` event + the record's\n * `error`, which is what tailing clients see.\n *\n * - normal completion → `finish('done')`\n * - a `RUN_ERROR` chunk → append it, then `finish('error', { message, code })`\n * - the stream throws → append a synthesized `RUN_ERROR`, then `finish('error')`\n * - `signal` aborts mid-stream → stop consuming, `finish('aborted')`\n */\nexport async function pipeToRunLog(\n  stream: AsyncIterable<StreamChunk>,\n  opts: PipeToRunLogOptions,\n): Promise<RunRecord> {\n  const { log, runId, threadId, signal } = opts\n  await log.open(threadId !== undefined ? { runId, threadId } : { runId })\n  if (signal?.aborted) {\n    await log.finish(runId, 'aborted')\n    return reread(log, runId)\n  }\n\n  try {\n    for await (const chunk of stream) {\n      if (signal?.aborted) {\n        await log.finish(runId, 'aborted')\n        return reread(log, runId)\n      }\n      await log.append(runId, chunk)\n      if (isRunErrorChunk(chunk)) {\n        await log.finish(runId, 'error', runErrorFromChunk(chunk))\n        return reread(log, runId)\n      }\n    }\n  } catch (error) {\n    // Detached run: no caller to throw to. Record the failure in the log so\n    // tailing clients observe it, then return — do NOT rethrow.\n    const message = messageOf(error)\n    await log.append(runId, syntheticRunError(message))\n    await log.finish(runId, 'error', { message })\n    return reread(log, runId)\n  }\n\n  await log.finish(runId, 'done')\n  return reread(log, runId)\n}\n\n/** Re-read the now-terminal record; the run was just driven, so it must exist. */\nasync function reread(log: RunEventLog, runId: string): Promise<RunRecord> {\n  const latest = await log.get(runId)\n  if (!latest) throw new Error(`run: record for \"${runId}\" vanished mid-run`)\n  return latest\n}\n\nexport interface RunControllerStartInput {\n  runId: string\n  threadId?: string\n  stream: AsyncIterable<StreamChunk>\n  /** Abort consumption mid-stream; the run finishes as `aborted`. */\n  signal?: AbortSignal\n}\n\nexport interface RunHandle {\n  runId: string\n  /** Resolves with the final record once the run reaches a terminal status. */\n  done: Promise<RunRecord>\n}\n\n/**\n * Thin orchestration helper over a {@link RunEventLog}: fire-and-track a run via\n * {@link pipeToRunLog}, tail it from a cursor, and `drain()` all in-flight runs\n * (e.g. inside a `ctx.waitUntil`). Holds no run state of its own beyond the set\n * of currently in-flight `done` promises.\n */\nexport class RunController {\n  private readonly inFlight = new Set<Promise<RunRecord>>()\n\n  constructor(private readonly log: RunEventLog) {}\n\n  /**\n   * Kick off `pipeToRunLog` without awaiting it and return the `runId`\n   * immediately plus a `done` promise the orchestrator may await or detach.\n   */\n  start(input: RunControllerStartInput): RunHandle {\n    const done = pipeToRunLog(input.stream, {\n      log: this.log,\n      runId: input.runId,\n      ...(input.threadId !== undefined ? { threadId: input.threadId } : {}),\n      ...(input.signal !== undefined ? { signal: input.signal } : {}),\n    })\n    this.inFlight.add(done)\n    void done.finally(() => this.inFlight.delete(done))\n    return { runId: input.runId, done }\n  }\n\n  /** Resumable client tail — replay from `fromSeq`, then live-tail to terminal. */\n  attach(\n    runId: string,\n    opts?: { fromSeq?: number; signal?: AbortSignal },\n  ): AsyncIterable<RunEvent> {\n    return this.log.read(runId, opts)\n  }\n\n  /** Current run record, or null if the run is unknown. */\n  status(runId: string): Promise<RunRecord | null> {\n    return this.log.get(runId)\n  }\n\n  /** Await every currently in-flight run's `done` promise. */\n  async drain(): Promise<void> {\n    await Promise.all([...this.inFlight])\n  }\n}\n"],"names":[],"mappings":";AAiBA,SAAS,gBACP,OAC2D;AAC3D,SAAO,MAAM,SAAS,UAAU;AAClC;AAGA,SAAS,kBACP,OACU;AACV,SAAO,MAAM,SAAS,SAClB,EAAE,SAAS,MAAM,SAAS,MAAM,MAAM,KAAA,IACtC,EAAE,SAAS,MAAM,QAAA;AACvB;AAGA,SAAS,UAAU,OAAwB;AACzC,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAGA,SAAS,kBAAkB,SAA8B;AACvD,QAAM,QAAwD;AAAA,IAC5D,MAAM,UAAU;AAAA,IAChB;AAAA,EAAA;AAEF,SAAO;AACT;AAqBA,eAAsB,aACpB,QACA,MACoB;AACpB,QAAM,EAAE,KAAK,OAAO,UAAU,WAAW;AACzC,QAAM,IAAI,KAAK,aAAa,SAAY,EAAE,OAAO,SAAA,IAAa,EAAE,OAAO;AACvE,MAAI,QAAQ,SAAS;AACnB,UAAM,IAAI,OAAO,OAAO,SAAS;AACjC,WAAO,OAAO,KAAK,KAAK;AAAA,EAC1B;AAEA,MAAI;AACF,qBAAiB,SAAS,QAAQ;AAChC,UAAI,QAAQ,SAAS;AACnB,cAAM,IAAI,OAAO,OAAO,SAAS;AACjC,eAAO,OAAO,KAAK,KAAK;AAAA,MAC1B;AACA,YAAM,IAAI,OAAO,OAAO,KAAK;AAC7B,UAAI,gBAAgB,KAAK,GAAG;AAC1B,cAAM,IAAI,OAAO,OAAO,SAAS,kBAAkB,KAAK,CAAC;AACzD,eAAO,OAAO,KAAK,KAAK;AAAA,MAC1B;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AAGd,UAAM,UAAU,UAAU,KAAK;AAC/B,UAAM,IAAI,OAAO,OAAO,kBAAkB,OAAO,CAAC;AAClD,UAAM,IAAI,OAAO,OAAO,SAAS,EAAE,SAAS;AAC5C,WAAO,OAAO,KAAK,KAAK;AAAA,EAC1B;AAEA,QAAM,IAAI,OAAO,OAAO,MAAM;AAC9B,SAAO,OAAO,KAAK,KAAK;AAC1B;AAGA,eAAe,OAAO,KAAkB,OAAmC;AACzE,QAAM,SAAS,MAAM,IAAI,IAAI,KAAK;AAClC,MAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,oBAAoB,KAAK,oBAAoB;AAC1E,SAAO;AACT;AAsBO,MAAM,cAAc;AAAA,EAGzB,YAA6B,KAAkB;AAAlB,SAAA,MAAA;AAAA,EAAmB;AAAA,EAAnB;AAAA,EAFZ,+BAAe,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQhC,MAAM,OAA2C;AAC/C,UAAM,OAAO,aAAa,MAAM,QAAQ;AAAA,MACtC,KAAK,KAAK;AAAA,MACV,OAAO,MAAM;AAAA,MACb,GAAI,MAAM,aAAa,SAAY,EAAE,UAAU,MAAM,SAAA,IAAa,CAAA;AAAA,MAClE,GAAI,MAAM,WAAW,SAAY,EAAE,QAAQ,MAAM,WAAW,CAAA;AAAA,IAAC,CAC9D;AACD,SAAK,SAAS,IAAI,IAAI;AACtB,SAAK,KAAK,QAAQ,MAAM,KAAK,SAAS,OAAO,IAAI,CAAC;AAClD,WAAO,EAAE,OAAO,MAAM,OAAO,KAAA;AAAA,EAC/B;AAAA;AAAA,EAGA,OACE,OACA,MACyB;AACzB,WAAO,KAAK,IAAI,KAAK,OAAO,IAAI;AAAA,EAClC;AAAA;AAAA,EAGA,OAAO,OAA0C;AAC/C,WAAO,KAAK,IAAI,IAAI,KAAK;AAAA,EAC3B;AAAA;AAAA,EAGA,MAAM,QAAuB;AAC3B,UAAM,QAAQ,IAAI,CAAC,GAAG,KAAK,QAAQ,CAAC;AAAA,EACtC;AACF;"}
+{"version":3,"file":"run.js","names":[],"sources":["../../src/run.ts"],"sourcesContent":["/**\n * The \"run driver\" for the inverted/serverless sandbox model: pump a `chat()`\n * stream into core's two durable seams — a {@link RunStore} for the run's\n * lifecycle record and a {@link StreamDurability} for its event log — so a\n * trigger can return immediately while a durable orchestrator drives the run\n * and clients tail from an opaque offset.\n *\n * The key inversion vs. a classic request/response handler: there is no caller\n * holding the stream open, so nothing to throw an error *back to*. The event log\n * is the only channel — every chunk (including a terminal\n * {@link EventType.RUN_ERROR}) is appended and assigned a resumable offset, and\n * a thrown stream error is recorded as a synthesized `RUN_ERROR` event plus the\n * record's `error` field. Tailing clients therefore always observe failures;\n * {@link pipeToRunLog} never rejects.\n *\n * \"Never rejects\" is load-bearing rather than aspirational: {@link RunController}\n * consumes the returned promise fire-and-forget, so a rejection would be an\n * unhandled rejection (process-fatal on modern Node, instance-fatal inside a\n * Durable Object) with nobody to report it to. Every store/log call is therefore\n * individually guarded, and because absorbing a failure silently in the one\n * module whose premise is that nobody is listening would make the failure\n * invisible, each guard reports through the optional {@link RunDeps.logger}.\n */\nimport { EventType } from '@tanstack/ai'\nimport { toRunErrorPayload } from '@tanstack/ai/adapter-internals'\nimport type { InternalLogger } from '@tanstack/ai/adapter-internals'\nimport type {\n  RunError,\n  RunRecord,\n  RunStore,\n  StreamChunk,\n  StreamDurability,\n  TerminalRunStatus,\n} from '@tanstack/ai'\n\n/** Whether a chunk is the terminal error event the chat engine emits. */\nfunction isRunErrorChunk(\n  chunk: StreamChunk,\n): chunk is StreamChunk & { message: string; code?: string } {\n  return chunk.type === EventType.RUN_ERROR\n}\n\n/**\n * Narrow a thrown value (or a `RUN_ERROR` chunk's payload) to the record's\n * structured error, keeping the provider's `code` when it supplies one: a bare\n * message is prose that changes between model versions, while `code` is what a\n * consumer branches on to retry, escalate, or show specific UI.\n */\nfunction toRunError(error: unknown): RunError {\n  const payload = toRunErrorPayload(error)\n  return {\n    message: payload.message,\n    ...(payload.code === undefined ? {} : { code: payload.code }),\n  }\n}\n\n/**\n * Fold a secondary failure into the primary error, mirroring `combineFailures`\n * in `packages/ai/src/stream-to-response.ts`: the primary cause stays first and\n * keeps its `code`, and the phase that produced the secondary failure is named.\n * The secondary must never *replace* the primary: the provider's error is what\n * an operator needs, and a failure while recording it is the lesser fact.\n */\nfunction withSecondaryFailure(\n  primary: RunError,\n  secondary: unknown,\n  phase: string,\n): RunError {\n  return {\n    ...primary,\n    message: `${primary.message}; ${phase}: ${toRunError(secondary).message}`,\n  }\n}\n\n/** Build the synthetic RUN_ERROR chunk appended when the stream throws. */\nfunction syntheticRunError(error: RunError): StreamChunk {\n  const chunk: { type: EventType.RUN_ERROR; message: string; code?: string } = {\n    type: EventType.RUN_ERROR,\n    message: error.message,\n    ...(error.code === undefined ? {} : { code: error.code }),\n  }\n  return chunk\n}\n\n/**\n * The two durable seams a run driver needs: lifecycle record + event log.\n *\n * Generic in the log's offset type, and DEFAULTED to `string` so every existing\n * call site keeps compiling unchanged. The parameter is not decoration: a\n * backend that brands its cursors — `@tanstack/ai-durable-stream`'s\n * `durableStream` returns `StreamDurability<DurableStreamOffset>` — is NOT\n * assignable to `StreamDurability<string>`, because `read` takes an offset and\n * is therefore contravariant in it. Hardcoding the default here made the\n * production multi-host backend unusable without a cast (see\n * `tests/offset-generics.test-d.ts`).\n */\nexport interface RunDeps<TOffset extends string = string> {\n  /** Run lifecycle record (status, thread, timings). */\n  runs: RunStore\n  /**\n   * Per-run delivery-durable event log the run's chunks are appended to.\n   *\n   * A FACTORY, not an instance, and that is load-bearing rather than stylistic.\n   * A `StreamDurability` is bound to one run — `memoryStream(request)` resolves\n   * its `runId` from the request, and a backend adapter's offsets embed a cursor\n   * into one log. Holding a single instance made two failures reachable:\n   *\n   * - **Silent mis-binding at concurrency 1.** `start({ runId })` accepted an\n   *   arbitrary id while the instance was bound to another, writing the record\n   *   under one id and the events under another with no error raised. Resolving\n   *   the log FROM the `runId` makes that unrepresentable.\n   * - **Cross-talk at concurrency > 1.** Parallel runs interleaved their chunks\n   *   into one log, and whichever finished first called `close()` and\n   *   terminalized every other run's stream.\n   *\n   * Called exactly once per run, at the start of {@link pipeToRunLog}. An\n   * implementation MUST return the same instance for the same `runId` within a\n   * process if it wants `snapshot()` to see its own appends.\n   */\n  durability: (runId: string) => StreamDurability<TOffset>\n  /**\n   * Optional sink for failures this driver absorbs rather than rejecting with.\n   * A detached run has no caller to receive an error, so without a logger a\n   * failing store or event log is invisible to an operator. Same\n   * `logger?.errors(...)` contract core uses in `stream-to-response.ts`.\n   */\n  logger?: InternalLogger\n}\n\nexport interface PipeToRunLogOptions<\n  TOffset extends string = string,\n> extends RunDeps<TOffset> {\n  runId: string\n  threadId: string\n  /** Abort consumption mid-stream; the run finishes as `aborted`. */\n  signal?: AbortSignal\n}\n\n/** Everything {@link finish} needs, including the fields it rebuilds a record from. */\ninterface FinishContext {\n  runs: RunStore\n  /**\n   * `close()` only — see {@link finish}. Narrowed to that one member rather than\n   * threading `TOffset` through here, because `close` is the sole method this\n   * context touches and it is offset-free, so a `Pick` accepts a log at ANY\n   * offset instantiation without making `finish` generic for nothing.\n   */\n  durability: Pick<StreamDurability, 'close'>\n  runId: string\n  threadId: string\n  startedAt: number\n  logger?: InternalLogger\n}\n\n/**\n * Report through a consumer-supplied logger without letting it break the\n * caller. Every logger call in this module sits inside a `catch` body, so an\n * throwing sink would escape that body and defeat the totality the guards\n * exist to provide. Swallowing here is deliberate: there is no second channel\n * left to report a reporting failure on.\n */\nfunction safeLog(\n  logger: InternalLogger | undefined,\n  message: string,\n  context: Record<string, unknown>,\n): void {\n  try {\n    logger?.errors(message, context)\n  } catch {\n    // Intentionally empty: see above.\n  }\n}\n\n/**\n * Record the terminal status, terminalize the event log, and answer with the\n * run's final record.\n *\n * TOTAL BY CONSTRUCTION: every step is individually guarded, so this never\n * throws and never rejects. Two consequences the guards buy:\n *\n * - `durability.close()` runs on EVERY exit path, including a failed `update`.\n *   Skipping it would wedge the record at `running` *and* park every live\n *   tailer forever, because a durability `read` only ends once the log closes.\n * - The re-read of the record is best effort. An eventually-consistent or\n *   read-replica store may answer `null` for a run that was just driven, which\n *   must not turn a successful run into a rejection; the locally rebuilt record\n *   is returned instead. It is also preferred outright when `update` failed,\n *   since the store then still holds the stale `running` row.\n *\n * THE TERMINAL WRITE IS NOT GUARANTEED TO LAND, and this function deliberately\n * does not check whether it did. Under `sandboxRunDriver` the `runs` handed in is\n * `fenceRunStore`d (`src/claim.ts`), which SUPPRESSES a terminal write — resolving\n * without writing — when the driver has lost its claim, because a host that no\n * longer owns the run must not declare it over while the successor is streaming\n * it. From here that is indistinguishable from a successful write, on purpose:\n * the epoch belongs to the claim module, not to this generic driver, and the\n * re-read below then answers with the successor's live record, which is the\n * truthful thing to resolve with. A driver wired without a claim (a plain\n * `pipeToRunLog` call) is unfenced and always writes.\n */\nasync function finish(\n  ctx: FinishContext,\n  status: TerminalRunStatus,\n  error?: RunError,\n): Promise<RunRecord> {\n  // NOTE: every logger call below goes through `safeLog`. The logger is\n  // consumer-supplied and is handed arbitrary thrown values, so a sink that\n  // cannot serialize one (a circular payload, say) would otherwise throw from\n  // inside a `catch` body and escape, skipping `durability.close()` and leaving\n  // the run wedged at `'running'` with live tailers parked. The reporting\n  // channel must never be able to break the guarantee it exists to report on.\n  const { runs, durability, runId, logger } = ctx\n  const finishedAt = Date.now()\n  const patch = {\n    status,\n    finishedAt,\n    ...(error === undefined ? {} : { error }),\n  }\n  const local: RunRecord = {\n    runId,\n    threadId: ctx.threadId,\n    startedAt: ctx.startedAt,\n    ...patch,\n  }\n\n  let recorded = true\n  try {\n    await runs.update(runId, patch)\n  } catch (updateError) {\n    recorded = false\n    safeLog(logger, 'run: recording the terminal run record failed', {\n      runId,\n      status,\n      error: updateError,\n    })\n  }\n\n  try {\n    await durability.close()\n  } catch (closeError) {\n    safeLog(logger, 'run: closing the run event log failed', {\n      runId,\n      status,\n      error: closeError,\n    })\n  }\n\n  if (!recorded) return local\n\n  try {\n    const latest = await runs.get(runId)\n    if (latest !== null) return latest\n    safeLog(logger, 'run: record vanished before the terminal re-read', {\n      runId,\n      status,\n    })\n  } catch (getError) {\n    safeLog(logger, 'run: re-reading the terminal run record failed', {\n      runId,\n      status,\n      error: getError,\n    })\n  }\n  return local\n}\n\n/**\n * Open the run, append every chunk from `stream`, and finish with the right\n * terminal status. Resolves with the final {@link RunRecord} and never rejects:\n * a thrown stream error is surfaced as a `RUN_ERROR` event plus the record's\n * `error`, which is what tailing clients see. A store or event-log failure\n * along the way is logged through {@link RunDeps.logger} and still terminalizes\n * the run rather than escaping to a caller that does not exist.\n *\n * - normal completion → `completed`\n * - a `RUN_ERROR` chunk → append it, then `failed`\n * - the stream throws → append a synthesized `RUN_ERROR`, then `failed`\n * - `signal` aborts at ANY point before the stream ends → `aborted`, whether the\n *   producer keeps yielding, ends its stream, or is never asked for another\n *   chunk. An abort outranks a clean exit: the run did not complete.\n */\nexport async function pipeToRunLog<TOffset extends string = string>(\n  stream: AsyncIterable<StreamChunk>,\n  opts: PipeToRunLogOptions<TOffset>,\n): Promise<RunRecord> {\n  const { runs, runId, threadId, signal, logger } = opts\n  // Resolved ONCE, from the runId being driven. Everything below — including\n  // `finish`'s `close()` — uses this one instance, so a factory that mints a\n  // fresh log per call cannot split one run across two logs, and the log can\n  // never belong to a run other than the one whose record is being written.\n  const durability = opts.durability(runId)\n  const ctx: FinishContext = {\n    runs,\n    durability,\n    runId,\n    threadId,\n    startedAt: Date.now(),\n    ...(logger === undefined ? {} : { logger }),\n  }\n\n  try {\n    // Inside the `try` so a store failure at creation is handled like any\n    // other: recorded as a failed run with a terminalized log, not rejected.\n    await runs.createOrResume({ runId, threadId, startedAt: ctx.startedAt })\n    if (signal?.aborted) return finish(ctx, 'aborted')\n\n    for await (const chunk of stream) {\n      if (signal?.aborted) return finish(ctx, 'aborted')\n      await durability.append([chunk])\n      if (isRunErrorChunk(chunk)) {\n        return finish(\n          ctx,\n          'failed',\n          toRunError({ message: chunk.message, code: chunk.code }),\n        )\n      }\n    }\n  } catch (streamError) {\n    // Detached run: no caller to throw to. Record the failure in the log so\n    // tailing clients observe it, then return — do NOT rethrow.\n    let recorded = toRunError(streamError)\n    // Deliberately not \"the stream failed\": `runs.createOrResume` above is\n    // inside this `try`, so an operator reading a wedged run must not be told\n    // the provider stream broke when the store never let the run start.\n    safeLog(logger, 'run: the run failed before completing', {\n      runId,\n      error: streamError,\n    })\n    try {\n      await durability.append([syntheticRunError(recorded)])\n    } catch (appendError) {\n      // The recovery append is itself a failure path. It must not destroy the\n      // cause it was recording, so the provider's error stays primary and this\n      // secondary failure is merged in and logged separately. When the cause IS\n      // a lost claim, this append is refused too and the `finish` below writes\n      // nothing either — a fenced store suppresses the terminal record for the\n      // same reason the fenced log refused the chunk (see `finish`).\n      const phase = 'appending the synthesized RUN_ERROR failed'\n      safeLog(logger, `run: ${phase}`, { runId, error: appendError })\n      recorded = withSecondaryFailure(recorded, appendError, phase)\n    }\n    return finish(ctx, 'failed', recorded)\n  }\n\n  // RE-CHECKED after the loop, and this is the common shape rather than the\n  // exotic one. The in-loop check only fires if the producer yields at least\n  // once MORE after the abort; two ways past it are routine:\n  //\n  // - The producer is signal-aware and reacts by ENDING its stream. `chat()`\n  //   does exactly this, so the loop exits NORMALLY.\n  // - The abort lands BETWEEN two chunks, while the loop is suspended on a\n  //   producer that then finishes on its own.\n  //\n  // Falling through to `'completed'` in either case is a false transcript, not\n  // a cosmetic mislabel: it was measured on the reaper's TTL-expiry path, where\n  // a run the reaper had force-expired — and whose sandbox it had already\n  // destroyed — was recorded as having completed successfully. Any caller whose\n  // producer ends its stream on abort reaches the same gap, a takeover that\n  // loses its claim mid-drive included, which is why the check belongs here and\n  // not in one caller.\n  //\n  // A producer that THREW on the abort is deliberately untouched: it returned\n  // from inside the `catch` above as `'failed'`, because a thrown value is a\n  // reported failure a tailing client must be shown, and this driver's log is\n  // that client's only channel.\n  if (signal?.aborted) return finish(ctx, 'aborted')\n  return finish(ctx, 'completed')\n}\n\nexport interface RunControllerStartInput {\n  runId: string\n  threadId: string\n  stream: AsyncIterable<StreamChunk>\n  /** Abort consumption mid-stream; the run finishes as `aborted`. */\n  signal?: AbortSignal\n}\n\nexport interface RunHandle {\n  runId: string\n  /** Resolves with the final record once the run reaches a terminal status. */\n  done: Promise<RunRecord>\n}\n\n/**\n * Thin orchestration helper over {@link RunDeps}: fire-and-track a run via\n * {@link pipeToRunLog}, tail one run by id, and `drain()` all in-flight runs\n * (e.g. inside a `ctx.waitUntil`). Holds no run state of its own beyond the set\n * of currently in-flight `done` promises.\n *\n * Safe for concurrent runs. {@link RunDeps.durability} is a per-run factory, so\n * each run appends to its own log and no run's `close()` terminalizes another's.\n * The identity trap this class used to document — `start({ runId })` writing the\n * lifecycle record under one id and the events under another, silently and at\n * concurrency 1 — is unrepresentable now that the log is resolved FROM the\n * `runId`. Every method is keyed by run accordingly: `attach(runId, …)` and\n * `status(runId)` no longer disagree about whether the surface is per-run.\n */\nexport class RunController<TOffset extends string = string> {\n  private readonly inFlight = new Set<Promise<RunRecord>>()\n\n  constructor(private readonly deps: RunDeps<TOffset>) {}\n\n  /**\n   * Kick off `pipeToRunLog` without awaiting it and return the `runId`\n   * immediately plus a `done` promise the orchestrator may await or detach.\n   */\n  start(input: RunControllerStartInput): RunHandle {\n    const done = pipeToRunLog(input.stream, {\n      ...this.deps,\n      runId: input.runId,\n      threadId: input.threadId,\n      ...(input.signal !== undefined ? { signal: input.signal } : {}),\n    })\n    this.inFlight.add(done)\n    // Two-argument `then`, deliberately NOT `.finally`: `.finally` returns a new\n    // promise that adopts any rejection, and discarding that promise would make\n    // the rejection unhandled (fatal on modern Node defaults, and it kills the\n    // instance inside a Durable Object). Handling both outcomes here means the\n    // derived promise always settles fulfilled, so nothing is left unhandled\n    // even if `pipeToRunLog`'s \"never rejects\" contract is ever broken.\n    const forget = (): void => void this.inFlight.delete(done)\n    void done.then(forget, forget)\n    return { runId: input.runId, done }\n  }\n\n  /**\n   * Resumable client tail for ONE run — replay from `fromOffset`, then\n   * live-tail. Takes `runId` because the log it reads is per-run; the old\n   * `attach(fromOffset)` signature advertised a multi-run surface the type could\n   * not deliver.\n   */\n  attach(\n    runId: string,\n    fromOffset: TOffset,\n    signal?: AbortSignal,\n  ): AsyncIterable<{ offset: TOffset; chunk: StreamChunk }> {\n    return this.deps.durability(runId).read(fromOffset, signal)\n  }\n\n  /** Current run record, or null when the run is unknown. */\n  status(runId: string): Promise<RunRecord | null> {\n    return this.deps.runs.get(runId)\n  }\n\n  /**\n   * Await every currently in-flight run's `done` promise.\n   *\n   * Uses `allSettled` rather than `all` because this is typically awaited\n   * inside a `ctx.waitUntil`: `all` would reject on the first failure, abandon\n   * the wait on every other run, and surface that rejection to the platform.\n   * Draining is about keeping the isolate alive until the runs settle; each\n   * run's own outcome is already recorded in its record and log.\n   */\n  async drain(): Promise<void> {\n    await Promise.allSettled([...this.inFlight])\n  }\n}\n"],"mappings":"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"}