@lostgradient/weft 0.13.0 → 0.14.0

package/README.md

@@ -1,6 +1,6 @@
 # Weft
 
-A Bun-native durable execution engine. Current release: `0.13.0`.
+A Bun-native durable execution engine. Current release: `0.14.0`.
 
 Install the library from npm as `@lostgradient/weft`:
 

package/dist/cli/help-text.d.ts

@@ -1,11 +1,11 @@
-export declare const HELP_TEXT = "\nweft - Bun-native durable execution engine\n\nUsage: weft [command] [options]\n\nCommands:\n  serve           Start the Weft server (default)\n  doctor          Run diagnostics on the Weft database\n  conformance     Run RemoteWorker protocol conformance checks\n  schedule        Manage recurring schedules\n  timeline        Inspect workflow timeline and replay history\n  version:check   Check workflow version compatibility\n  validate        Lint workflow registrations for design-time anti-patterns\n  codegen         Generate TypeScript declarations from a registry snapshot\n  api             Inspect and invoke catalog operations on a running server\n  server          Inspect a running server's health and operation surface\n  workflow        List, inspect, start, signal, and cancel workflows on a server\n  tail            Stream a workflow's events as Server-Sent Events\n  completions     Generate or install shell completion scripts\n  version         Print the installed Weft version\n\nVersion (leading token only; a subcommand owns its own option line):\n  weft version | weft --version | weft -v   Print the installed Weft version\n\nServe Options:\n  -p, --port <port>           Server port (default: 7233)\n  -d, --database <path>       Database file path (default: ./weft.db)\n  -s, --storage <backend>     Storage backend: sqlite, lmdb, memory (default: sqlite)\n  -w, --workflows <path>      Path to workflow module to register on startup\n  -h, --help                  Show this help message\n";
+export declare const HELP_TEXT = "\nweft - Bun-native durable execution engine\n\nUsage: weft [command] [options]\n\nCommands:\n  serve           Start the Weft server (default)\n  doctor          Run diagnostics on the Weft database\n  conformance     Run RemoteWorker protocol conformance checks\n  schedule        Manage recurring schedules\n  timeline        Inspect workflow timeline and replay history\n  version:check   Check workflow version compatibility\n  validate        Lint workflow definitions for design-time anti-patterns\n  codegen         Generate TypeScript declarations from a registry snapshot\n  api             Inspect and invoke catalog operations on a running server\n  server          Inspect a running server's health and operation surface\n  workflow        List, inspect, start, signal, and cancel workflows on a server\n  tail            Stream a workflow's events as Server-Sent Events\n  completions     Generate or install shell completion scripts\n  version         Print the installed Weft version\n\nVersion (leading token only; a subcommand owns its own option line):\n  weft version | weft --version | weft -v   Print the installed Weft version\n\nServe Options:\n  -p, --port <port>           Server port (default: 7233)\n  -d, --database <path>       Database file path (default: ./weft.db)\n  -s, --storage <backend>     Storage backend: sqlite, lmdb, memory (default: sqlite)\n  -w, --workflows <path>      Path to workflow module to register on startup\n  -h, --help                  Show this help message\n";
 export declare const API_HELP_TEXT = "\nweft api - Inspect and invoke catalog operations on a running server\n\nUsage:\n  weft api --list [options]\n  weft api --describe <operation-name> [options]\n  weft api <operation-name> [--input <json> | --input-file <path|->] [options]\n\nOptions:\n      --server <url>       Server URL (default: WEFT_ADDR, profile, run lockfile, or localhost)\n      --token <token>      Bearer token (default: WEFT_TOKEN)\n      --profile <name>     Profile from ~/.weft/config (default: WEFT_PROFILE or default_profile)\n      --input <json>       JSON object input for the operation\n      --input-file <path>  Read JSON object input from a file, or '-' for stdin\n      --list               List catalog operations\n      --describe <name>    Print one operation's schema and metadata\n      --yes                Confirm destructive operations without prompting\n  -j, --json               Emit machine-readable JSON output\n  -h, --help               Show this help message\n\nExit codes:\n  0   Success\n  1   Operation failed or destructive operation was not confirmed\n  2   Connection error\n  3   Usage or input validation error\n";
 export declare const CONFORMANCE_HELP_TEXT = "\nweft conformance - Run RemoteWorker protocol conformance checks\n\nUsage: weft conformance [options] -- <worker-command> [args...]\n\nThe worker command receives:\n  WEFT_WORKER_URL\n  WEFT_WORKER_QUEUE\n  WEFT_WORKER_ACTIVITIES\n  WEFT_WORKER_PROTOCOL_VERSION\n\nOptions:\n      --timeout <ms>       Per-check timeout in milliseconds (default: 15000)\n  -j, --json               Output results as JSON\n  -h, --help               Show this help message\n";
 export declare const DOCTOR_HELP_TEXT = "\nweft doctor - Run diagnostics on the Weft database\n\nUsage: weft doctor [options]\n\nOptions:\n  -d, --database <path>   Database file path (default: ./weft.db)\n  -j, --json              Output results as JSON\n  -h, --help              Show this help message\n";
 export declare const VERSION_CHECK_HELP_TEXT = "\nweft version:check - Check workflow version compatibility\n\nUsage: weft version:check [options]\n\nOptions:\n  -d, --database <path>     Database file path (default: ./weft.db)\n  -w, --workflows <path>    Path to workflows module\n  -j, --json                Output results as JSON\n  -h, --help                Show this help message\n";
 export declare const TIMELINE_HELP_TEXT = "\nweft timeline - Inspect workflow timeline and replay history\n\nUsage:\n  weft timeline <workflowId> [options]\n  weft timeline <workflowId> --diff <fromStep> <toStep> [options]\n\nOptions:\n  -d, --database <path>     Database file path (default: ./weft.db)\n      --step <step>         Show replay details for one checkpoint step\n      --diff                Diff two checkpoint steps (requires two positional step numbers)\n  -h, --help                Show this help message\n";
-export declare const SCHEDULE_HELP_TEXT = "\nweft schedule - Manage recurring schedules\n\nUsage:\n  weft schedule list [options]\n  weft schedule create <workflowType> <cronExpression> [options]\n  weft schedule create <workflowType> --every <duration> [options]\n  weft schedule pause <scheduleId> [options]\n  weft schedule resume <scheduleId> [options]\n  weft schedule cancel <scheduleId> [options]\n\nProvide a cron expression positional OR an --every interval (e.g. \"30s\", \"1h\"),\nbut not both. Interval schedules fire one period after creation, then every\nperiod after that.\n\nOptions:\n  -d, --database <path>     Database file path (default: ./weft.db)\n  -s, --storage <backend>   Storage backend: sqlite, lmdb (default: sqlite)\n  -w, --workflows <path>    Path to workflow registrations module (required for create)\n      --every <duration>    Interval cadence for create (e.g. 30s, 5m, 1h); mutually exclusive with the cron positional\n      --input <json>        JSON input payload for create (default: null)\n      --id <id>             Custom schedule id for create\n      --overlap <policy>    Overlap policy: skip, queue, cancel-running, allow\n      --backfill            Run missed ticks on recovery\n      --jitter <duration>   Deterministic dispatch jitter for create (e.g. 30s, 5m)\n  -j, --json                Output results as JSON\n  -h, --help                Show this help message\n";
-export declare const VALIDATE_HELP_TEXT = "\nweft validate - Lint workflow registrations for design-time anti-patterns\n\nUsage: weft validate <entry.ts>... [options]\n\nArguments:\n  <entry.ts>...           One or more TypeScript modules or glob patterns that\n                          resolve to workflow registrations and/or activity\n                          definitions.\n\nOptions:\n  -j, --json              Output results as JSON\n  -h, --help              Show this help message\n\nExit codes:\n  0   No errors (warnings may be present)\n  1   One or more errors detected\n  2   Entry file could not be loaded (takes precedence over validation errors)\n\nJSON output:\n  { entries, valid, hasLoadErrors, hasValidationErrors }\n\nChecks performed:\n  unbounded-retry               Activity retry.maxAttempts is Infinity\n  stateful-without-compensator  Non-idempotent activity has no compensate fn\n";
+export declare const SCHEDULE_HELP_TEXT = "\nweft schedule - Manage recurring schedules\n\nUsage:\n  weft schedule list [options]\n  weft schedule create <workflowType> <cronExpression> [options]\n  weft schedule create <workflowType> --every <duration> [options]\n  weft schedule pause <scheduleId> [options]\n  weft schedule resume <scheduleId> [options]\n  weft schedule cancel <scheduleId> [options]\n\nProvide a cron expression positional OR an --every interval (e.g. \"30s\", \"1h\"),\nbut not both. Interval schedules fire one period after creation, then every\nperiod after that.\n\nOptions:\n  -d, --database <path>     Database file path (default: ./weft.db)\n  -s, --storage <backend>   Storage backend: sqlite, lmdb (default: sqlite)\n  -w, --workflows <path>    Path to workflow definitions module (required for create)\n      --every <duration>    Interval cadence for create (e.g. 30s, 5m, 1h); mutually exclusive with the cron positional\n      --input <json>        JSON input payload for create (default: null)\n      --id <id>             Custom schedule id for create\n      --overlap <policy>    Overlap policy: skip, queue, cancel-running, allow\n      --backfill            Run missed ticks on recovery\n      --jitter <duration>   Deterministic dispatch jitter for create (e.g. 30s, 5m)\n  -j, --json                Output results as JSON\n  -h, --help                Show this help message\n";
+export declare const VALIDATE_HELP_TEXT = "\nweft validate - Lint workflow definitions for design-time anti-patterns\n\nUsage: weft validate <entry.ts>... [options]\n\nArguments:\n  <entry.ts>...           One or more TypeScript modules or glob patterns that\n                          resolve to workflow definitions and/or activity\n                          definitions.\n\nOptions:\n  -j, --json              Output results as JSON\n  -h, --help              Show this help message\n\nExit codes:\n  0   No errors (warnings may be present)\n  1   One or more errors detected\n  2   Entry file could not be loaded (takes precedence over validation errors)\n\nJSON output:\n  { entries, valid, hasLoadErrors, hasValidationErrors }\n\nChecks performed:\n  unbounded-retry               Activity retry.maxAttempts is Infinity\n  stateful-without-compensator  Non-idempotent activity has no compensate fn\n";
 export declare const SERVER_HELP_TEXT = "\nweft server - Inspect a running server's health and operation surface\n\nUsage:\n  weft server health [options]\n  weft server info [options]\n\nOptions:\n      --server <url>       Server URL (default: WEFT_ADDR, profile, run lockfile, or localhost)\n      --token <token>      Bearer token (default: WEFT_TOKEN)\n      --profile <name>     Profile from ~/.weft/config\n      --wait               (health) Poll until the server is reachable\n      --wait-timeout <ms>  (health) Maximum time to wait, in milliseconds (default: 30000)\n  -j, --json               Emit machine-readable JSON output\n  -q, --quiet              Suppress success/error text (use the exit code)\n  -h, --help               Show this help message\n\nExit codes:\n  0   Healthy\n  1   Unreachable / unhealthy\n  2   Connection error\n";
 export declare const WORKFLOW_HELP_TEXT = "\nweft workflow - List, inspect, start, signal, and cancel workflows on a server\n\nUsage:\n  weft workflow ls [--type <type>] [--status <status>] [--limit <n>] [options]\n  weft workflow get <workflow-id> [options]\n  weft workflow events <workflow-id> [options]\n  weft workflow start <workflow-type> [--input <json> | --input-file <path|->] [--id <id>] [options]\n  weft workflow cancel <workflow-id> [--yes] [--dry-run] [options]\n  weft workflow signal <workflow-id> <signal-name> [--input <json> | --input-file <path|->] [options]\n\nOptions:\n      --server <url>       Server URL (default: WEFT_ADDR, profile, run lockfile, or localhost)\n      --token <token>      Bearer token (default: WEFT_TOKEN)\n      --profile <name>     Profile from ~/.weft/config\n      --type <type>        (ls) Filter by workflow type\n      --status <status>    (ls) Filter by workflow status\n      --limit <n>          (ls) Maximum number of rows\n      --input <json>       (start/signal) JSON input payload\n      --input-file <path>  (start/signal) Read JSON input from a file, or '-' for stdin\n      --id <id>            (start) Explicit workflow id\n  -y, --yes                (cancel) Confirm without prompting\n      --dry-run            (cancel) Print affected count without cancelling\n  -j, --json               Emit machine-readable output (NDJSON for lists)\n  -q, --quiet              Print ids only / suppress success text\n  -h, --help               Show this help message\n\nExit codes:\n  0   Success\n  1   Operation failed or destructive operation was not confirmed\n  2   Connection error\n  3   Usage or input error\n  4   Operation unavailable on this server (version skew)\n";
 export declare const TAIL_HELP_TEXT = "\nweft tail - Stream a workflow's events as Server-Sent Events\n\nUsage:\n  weft tail <workflow-id> [options]\n\nOptions:\n      --server <url>       Server URL (default: WEFT_ADDR, profile, run lockfile, or localhost)\n      --token <token>      Bearer token (default: WEFT_TOKEN)\n      --profile <name>     Profile from ~/.weft/config\n  -j, --json               Emit one JSON object per line (NDJSON)\n  -q, --quiet              Do not echo events to stdout\n  -h, --help               Show this help message\n\nPress Ctrl-C to stop tailing; the stream ends cleanly with exit code 0.\n";

package/dist/cli/help-text.js

@@ -10,7 +10,7 @@ Commands:
   schedule        Manage recurring schedules
   timeline        Inspect workflow timeline and replay history
   version:check   Check workflow version compatibility
-  validate        Lint workflow registrations for design-time anti-patterns
+  validate        Lint workflow definitions for design-time anti-patterns
   codegen         Generate TypeScript declarations from a registry snapshot
   api             Inspect and invoke catalog operations on a running server
   server          Inspect a running server's health and operation surface
@@ -117,7 +117,7 @@ period after that.
 Options:
   -d, --database <path>     Database file path (default: ./weft.db)
   -s, --storage <backend>   Storage backend: sqlite, lmdb (default: sqlite)
-  -w, --workflows <path>    Path to workflow registrations module (required for create)
+  -w, --workflows <path>    Path to workflow definitions module (required for create)
       --every <duration>    Interval cadence for create (e.g. 30s, 5m, 1h); mutually exclusive with the cron positional
       --input <json>        JSON input payload for create (default: null)
       --id <id>             Custom schedule id for create
@@ -127,13 +127,13 @@ Options:
   -j, --json                Output results as JSON
   -h, --help                Show this help message
 `, VALIDATE_HELP_TEXT = `
-weft validate - Lint workflow registrations for design-time anti-patterns
+weft validate - Lint workflow definitions for design-time anti-patterns
 
 Usage: weft validate <entry.ts>... [options]
 
 Arguments:
   <entry.ts>...           One or more TypeScript modules or glob patterns that
-                          resolve to workflow registrations and/or activity
+                          resolve to workflow definitions and/or activity
                           definitions.
 
 Options:

package/dist/cli/operation-catalog-snapshot.d.ts

@@ -1,5 +1,5 @@
+import type { FaultCode } from '../core/fault-code.ts';
 import type { ErasedOperation, OperationKind, TransportAvailability } from '../server/operation-catalog.ts';
-import type { FaultCode } from '../server/operation-fault.ts';
 import type { ParamSource, ResponseShape } from '../server/rest-binding.ts';
 export type CatalogRestBindingSnapshot = {
     readonly method: string;

package/dist/cli/schedule.js

@@ -51,10 +51,8 @@ function parseScheduleInput(input) {
 }
 async function registerScheduleWorkflows(engine, workflowsPath, loadRegistrationsFromModule) {
   const loaded = await loadRegistrationsFromModule(workflowsPath);
-  for (const [workflowType, registration] of Object.entries(loaded.registrations)) {
-    const definition = { ...registration, name: workflowType };
+  for (const definition of Object.values(loaded.registrations))
     registerOnRuntimeEngine(runtimeWorkflowEngine(engine), definition);
-  }
 }
 async function executeScheduleCreate(options, engine, loadRegistrationsFromModule) {
   const validationError = getScheduleCreateValidationError(options);

package/dist/cli/serve-registrations.d.ts

@@ -1,6 +1,6 @@
 import type { ActivityDefinition } from '../core/activity.ts';
 import type { Engine } from '../core/engine.ts';
-import type { WorkflowRegistration } from '../diagnostics/validate.ts';
+import type { WorkflowDefinition } from '../core/types.ts';
 /**
  * Convert a plain-object `ActivityDefinition` into a callable function that
  * satisfies the engine's `isActivityDefinition` check (which requires a
@@ -8,8 +8,8 @@ import type { WorkflowRegistration } from '../diagnostics/validate.ts';
  */
 export declare function toActivityCallable(definition: ActivityDefinition): (...args: unknown[]) => unknown;
 /**
- * Register a map of workflow registrations and a list of activity definitions
+ * Register a map of workflow definitions and a list of activity definitions
  * on an engine instance. Plain-object activities are normalized to callables
  * before registration.
  */
-export declare function registerModuleExports(engine: Engine, registrations: Record<string, WorkflowRegistration>, activities: ActivityDefinition[]): void;
+export declare function registerModuleExports(engine: Engine, registrations: Record<string, WorkflowDefinition>, activities: ActivityDefinition[]): void;

package/dist/cli/serve-registrations.js

@@ -13,8 +13,8 @@ export function toActivityCallable(definition) {
 }
 export function registerModuleExports(engine, registrations, activities) {
   const runtime = runtimeWorkflowEngine(engine);
-  for (const [workflowType, registration] of Object.entries(registrations))
-    registerOnRuntimeEngine(runtime, { ...registration, name: workflowType });
+  for (const definition of Object.values(registrations))
+    registerOnRuntimeEngine(runtime, definition);
   for (const activity of activities)
     if (typeof activity === "function")
       engine.register(activity);

package/dist/cli/shutdown.d.ts

@@ -0,0 +1,11 @@
+export declare const CLI_SHUTDOWN_SIGNALS: readonly ["SIGINT", "SIGTERM"];
+export type CliShutdownSignal = (typeof CLI_SHUTDOWN_SIGNALS)[number];
+export type CliShutdownDependencies = {
+    readonly stopServer: () => Promise<void>;
+    readonly removeRunLockfile: () => Promise<void>;
+    readonly disposeStorage: () => void;
+    readonly log: (message: string) => void;
+    readonly reportError: (message: string, error: unknown) => void;
+    readonly exit: (code: 0 | 1) => void;
+};
+export declare function createCliShutdownHandler(dependencies: CliShutdownDependencies): (signal: CliShutdownSignal) => Promise<void>;

package/dist/cli/shutdown.js

@@ -0,0 +1,25 @@
+export const CLI_SHUTDOWN_SIGNALS = ["SIGINT", "SIGTERM"];
+async function runCliShutdown(signal, dependencies) {
+  dependencies.log(`
+Received ${signal}; shutting down...`);
+  try {
+    await dependencies.stopServer();
+    try {
+      await dependencies.removeRunLockfile();
+    } catch (error) {
+      dependencies.reportError("[weft] Failed to remove run lockfile:", error);
+    }
+    dependencies.disposeStorage();
+    dependencies.exit(0);
+  } catch (error) {
+    dependencies.reportError("[weft] Shutdown error:", error);
+    dependencies.exit(1);
+  }
+}
+export function createCliShutdownHandler(dependencies) {
+  let shutdownPromise;
+  return (signal) => {
+    shutdownPromise ??= runCliShutdown(signal, dependencies);
+    return shutdownPromise;
+  };
+}

package/dist/cli/validate.d.ts

@@ -1,5 +1,5 @@
 import type { CommandOutput } from './types.ts';
-/** Validates workflow registration modules and reports load or design-time errors. */
+/** Validates workflow definition modules and reports load or design-time errors. */
 export declare function executeValidate(options: {
     entryPaths: string[];
     json: boolean;

package/dist/cli/version-check.d.ts

@@ -1,5 +1,5 @@
 import type { CommandOutput } from './types.ts';
-/** Checks stored workflow history against the current workflow registrations. */
+/** Checks stored workflow history against the current workflow definitions. */
 export declare function executeVersionCheck(options: {
     database: string;
     workflows: string;

package/dist/cli/version-check.js

@@ -8,7 +8,7 @@ export async function executeVersionCheck(options) {
     };
   const { runVersionCheck } = await import("../diagnostics/version-check.js"), { formatVersionCheckReport } = await import("../diagnostics/format.js"), { BunSQLiteStorage } = await import("../storage/bun-sql.js"), storage = new BunSQLiteStorage(options.database);
   try {
-    const registrations = await import(resolve(process.cwd(), options.workflows)), report = await runVersionCheck(storage, registrations.default);
+    const workflowsPath = resolve(process.cwd(), options.workflows), { loadRegistrationsFromModule } = await import("../diagnostics/validate.js"), { registrations } = await loadRegistrationsFromModule(workflowsPath), report = await runVersionCheck(storage, registrations);
     return { stdout: options.json ? JSON.stringify(report, null, 2) : formatVersionCheckReport(report), exitCode: 0 };
   } finally {
     storage[Symbol.dispose]();

package/dist/cli-main.js

@@ -32,6 +32,7 @@ import {
   WORKFLOW_HELP_TEXT,
   writeRunLockfile
 } from "./cli/index.js";
+import { CLI_SHUTDOWN_SIGNALS, createCliShutdownHandler } from "./cli/shutdown.js";
 import { Engine } from "./core/engine.js";
 import { serve } from "./server/index.js";
 const parsedArguments = (() => {
@@ -67,36 +68,16 @@ if (parsedArguments.command === "version") {
   console.log(`Health check: ${new URL("/v1/health", server.url).href}`);
   console.log(`Storage: ${parsedArguments.storage}`);
   console.log(`Database: ${parsedArguments.database}`);
-  process.on("SIGINT", () => {
-    console.log(`
-Shutting down...`);
-    server.stop().then(async () => {
-      try {
-        await removeRunLockfile(server.url);
-      } catch (error) {
-        console.error("[weft] Failed to remove run lockfile:", error);
-      }
-      storage[Symbol.dispose]();
-      process.exit(0);
-    }).catch((error) => {
-      console.error("[weft] Shutdown error:", error);
-      process.exit(1);
-    });
-  });
-  process.on("SIGTERM", () => {
-    server.stop().then(async () => {
-      try {
-        await removeRunLockfile(server.url);
-      } catch (error) {
-        console.error("[weft] Failed to remove run lockfile:", error);
-      }
-      storage[Symbol.dispose]();
-      process.exit(0);
-    }).catch((error) => {
-      console.error("[weft] Shutdown error:", error);
-      process.exit(1);
-    });
+  const shutdown = createCliShutdownHandler({
+    stopServer: () => server.stop(),
+    removeRunLockfile: () => removeRunLockfile(server.url),
+    disposeStorage: () => storage[Symbol.dispose](),
+    log: (message) => console.log(message),
+    reportError: (message, error) => console.error(message, error),
+    exit: (code) => process.exit(code)
   });
+  for (const signal of CLI_SHUTDOWN_SIGNALS)
+    process.on(signal, () => void shutdown(signal));
 } else if (parsedArguments.command === "doctor") {
   if (parsedArguments.help) {
     console.log(DOCTOR_HELP_TEXT);

package/dist/client/http-client-storage.js

@@ -1,3 +1,4 @@
+import { readBoundedNdjsonResponse } from "../storage/bounded-ndjson-response.js";
 import { decodeBase64ToBytes, encodeBytesToBase64, isRecord } from "../storage/byte-encoding.js";
 import {
   assertStorageBatchOperationCount
@@ -19,42 +20,13 @@ function scanEntry(value) {
     throw Error("HttpClient storage scan response contained an invalid NDJSON entry.");
   return [value.key, decodeBase64ToBytes(value.value)];
 }
-async function releaseScanReader(reader, reachedEndOfStream) {
-  if (!reachedEndOfStream)
-    try {
-      await reader.cancel();
-    } catch {}
-  reader.releaseLock();
-}
 async function* scanResponse(response) {
-  if (response.body === null)
-    return;
-  const reader = response.body.getReader(), decoder = new TextDecoder;
-  let bufferedText = "", bytesRead = 0, reachedEndOfStream = !1;
-  try {
-    while (!0) {
-      const { done, value } = await reader.read();
-      if (done) {
-        reachedEndOfStream = !0;
-        break;
-      }
-      bytesRead += value.byteLength;
-      if (bytesRead > MAX_SCAN_RESPONSE_BYTES)
-        throw Error("HttpClient storage scan response exceeded the maximum allowed size.");
-      bufferedText += decoder.decode(value, { stream: !0 });
-      const lines = bufferedText.split(`
-`);
-      bufferedText = lines.pop() ?? "";
-      for (const line of lines)
-        if (line.trim().length > 0)
-          yield scanEntry(JSON.parse(line));
-    }
-    bufferedText += decoder.decode();
-    if (bufferedText.trim().length > 0)
-      yield scanEntry(JSON.parse(bufferedText));
-  } finally {
-    await releaseScanReader(reader, reachedEndOfStream);
-  }
+  for await (const line of readBoundedNdjsonResponse(response, {
+    maximumBytes: MAX_SCAN_RESPONSE_BYTES,
+    sizeLimitError: () => Error("HttpClient storage scan response exceeded the maximum allowed size.")
+  }))
+    if (line.trim().length > 0)
+      yield scanEntry(JSON.parse(line));
 }
 export function createHttpClientStorage(baseUrl, headers) {
   return {

package/dist/client/http-request.d.ts

@@ -63,7 +63,7 @@ export declare function resolveHttpClientConnection(options: HttpClientOptions):
 /**
  * Error thrown when the server returns a non-2xx response.
  *
- * When the server sends a fault body with a recognized coarse `code`, the wire
+ * When a transport response carries a recognized coarse fault code, the wire
  * value is surfaced as {@link HttpClientError.faultCode} with a derived
  * {@link HttpClientError.category}, so callers can branch without
  * string-matching `message`. Both are `undefined` for the production flat REST
@@ -96,8 +96,8 @@ export declare class HttpClientError extends WeftError<'HttpClientError'> {
     /** HTTP status code of the failed response. */
     readonly status: number;
     /**
-     * The server's stable wire fault code, when the response carried a structured
-     * fault body. `undefined` for plain-string error bodies or unrecognized codes.
+     * The server's stable wire fault code, when the transport response carried a
+     * recognized code. `undefined` for flat REST error bodies or unrecognized codes.
      */
     readonly faultCode?: FaultCode | undefined;
     /**
@@ -107,18 +107,17 @@ export declare class HttpClientError extends WeftError<'HttpClientError'> {
     readonly category?: FailureCategory | undefined;
     /**
      * The fine-grained originating public {@link WeftErrorCode} the server
-     * attached (e.g. `WorkflowNotFoundError`), when the structured fault carried
-     * one. This is what makes cross-transport branching work: a producer can call
+     * attached (e.g. `WorkflowNotFoundError`), when the response carried one.
+     * This is what makes cross-transport branching work: a producer can call
      * `isWeftFault(error, 'WorkflowNotFoundError')` and have it match over HTTP
      * exactly as it matches the in-process typed error. `undefined` when the fault
-     * carried only the coarse {@link faultCode} (most faults) or no structured body.
+     * carried only the coarse {@link faultCode} (most faults) or no recognized code.
      */
     readonly weftCode?: WeftErrorCode | undefined;
     /**
      * The fault's wire `data` payload, when the response carried a structured
-     * body (`{ error, data }` for production REST, nested `{ error: { data } }`
-     * for structured REST responses, or `error.data` for JSON-RPC). Shape is
-     * fault-code-dependent — see {@link FaultCode} and the server's
+     * body (`{ error, data }` for production REST or `error.data` for JSON-RPC).
+     * Shape is fault-code-dependent — see {@link FaultCode} and the server's
      * `OperationFault` per-code `data` union for what each code carries (e.g.
      * `InvalidParams.data.issues`, `NotFound.data.resource`). `undefined` for
      * plain-string error bodies, bodies with no `data` field, or a `data` field

package/dist/client/http-request.js

@@ -1,5 +1,5 @@
 import { resolveConnection } from "../connection.js";
-import { failureCategoryForFaultCode, isFaultCode } from "../core/fault-code.js";
+import { failureCategoryForFaultCode } from "../core/fault-code.js";
 import { isWeftErrorCode, WeftError } from "../core/weft-error.js";
 export function resolveHttpClientConnection(options) {
   const connection = resolveConnection({
@@ -49,34 +49,12 @@ function parseFlatErrorBody(body) {
     ...data === void 0 ? {} : { data }
   };
 }
-function isStructuredErrorBody(value) {
-  if (value === null || typeof value !== "object")
-    return !1;
-  const error = value.error;
-  if (error === null || typeof error !== "object")
-    return !1;
-  return typeof error.message === "string";
-}
-function weftCodeFromData(data) {
-  if (data === null || typeof data !== "object")
-    return;
-  const candidate = data.weftCode;
-  return isWeftErrorCode(candidate) ? candidate : void 0;
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function parseErrorBody(response) {
   try {
     const body = await response.json();
-    if (isStructuredErrorBody(body)) {
-      const { code, message, data } = body.error, weftCode = weftCodeFromData(data), base = { message };
-      if (weftCode !== void 0)
-        base.weftCode = weftCode;
-      if (isRecord(data))
-        base.data = data;
-      return isFaultCode(code) ? { ...base, faultCode: code } : base;
-    }
     if (isFlatErrorBody(body) && body.error)
       return parseFlatErrorBody(body);
     return { message: response.statusText };
@@ -97,8 +75,8 @@ export async function requestResponse(baseUrl, path, baseHeaders, options) {
   if (response.status === 404 && (!options?.method || options.method === "GET"))
     return null;
   if (!response.ok) {
-    const { message, faultCode, weftCode, data } = await parseErrorBody(response);
-    throw new HttpClientError(response.status, message, { faultCode, weftCode, data });
+    const { message, weftCode, data } = await parseErrorBody(response);
+    throw new HttpClientError(response.status, message, { weftCode, data });
   }
   return response;
 }

package/dist/core/context/parallel-operations.d.ts

@@ -1,8 +1,6 @@
 import type { Context } from './index.ts';
 import type { ContextInternals } from './internals.ts';
 import type { ContextOperationRequest } from './operation-request.ts';
-import { assertValidParallelOperationCacheEntry, BranchTopologyChangedError, createParallelOperationCacheEntry, isParallelOperationCacheEntry, type ParallelBranchSlot, type ParallelOperationCacheEntry } from './parallel-cache-entry.ts';
-export { assertValidParallelOperationCacheEntry, BranchTopologyChangedError, createParallelOperationCacheEntry, isParallelOperationCacheEntry, type ParallelBranchSlot, type ParallelOperationCacheEntry, };
 export declare function all(context: Context, internals: ContextInternals, operations: Generator<ContextOperationRequest, unknown, unknown>[]): Generator<ContextOperationRequest, unknown[], unknown>;
 export declare function race(context: Context, internals: ContextInternals, operations: Generator<ContextOperationRequest, unknown, unknown>[], branchNames?: string[]): Generator<ContextOperationRequest, unknown, unknown>;
 export declare function memo<T>(context: Context, internals: ContextInternals, key: string, fn: () => T | Promise<T>): Generator<ContextOperationRequest, T, unknown>;

package/dist/core/context/parallel-operations.js

@@ -6,13 +6,6 @@ import {
   isParallelOperationCacheEntry
 } from "./parallel-cache-entry.js";
 import { captureCallerStack } from "./validation.js";
-
-export {
-  assertValidParallelOperationCacheEntry,
-  BranchTopologyChangedError,
-  createParallelOperationCacheEntry,
-  isParallelOperationCacheEntry
-};
 function reconstructAllResult(entry) {
   return entry.branches.map((slot) => {
     if (slot.status !== "fulfilled")

package/dist/core/engine/callback-checkpoint-persistence.d.ts

@@ -1,3 +1,5 @@
 import type { ContextOperationRequest } from '../context.ts';
+import { type PersistCheckpointCallbacks } from './checkpoint-io.ts';
 import type { Engine } from './index.ts';
+export declare function createCheckpointPersistenceCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): PersistCheckpointCallbacks;
 export declare function persistCheckpointForDataOperation<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string, operation: ContextOperationRequest): Promise<void>;

package/dist/core/engine/callback-checkpoint-persistence.js

@@ -9,8 +9,8 @@ import {
 import { getInternals } from "./internals.js";
 import { swallowPromiseRejection } from "./strategy-helpers.js";
 import { terminateWorkflow } from "./termination.js";
-export function persistCheckpointForDataOperation(engine, workflowId, operation) {
-  return persistCheckpoint(getInternals(engine), workflowId, operation, void 0, {
+export function createCheckpointPersistenceCallbacks(engine) {
+  return {
     appendTimelineBatchOperations: (id, checkpointOperation, step, timestamp, operations) => appendTimelineBatchOperations(getInternals(engine), id, checkpointOperation, step, timestamp, operations),
     swallowPromiseRejection: (promise) => {
       swallowPromiseRejection(promise);
@@ -21,5 +21,8 @@ export function persistCheckpointForDataOperation(engine, workflowId, operation)
       engine.dispatchEvent(event);
     },
     enforceHistoryCircuitBreaker: (id) => terminateWorkflow(getInternals(engine), id, "timed-out", createTerminationCallbacks(engine), HISTORY_CIRCUIT_BREAKER_REASON)
-  }, { timeline: "preserve-pending" });
+  };
+}
+export function persistCheckpointForDataOperation(engine, workflowId, operation) {
+  return persistCheckpoint(getInternals(engine), workflowId, operation, void 0, createCheckpointPersistenceCallbacks(engine), { timeline: "preserve-pending" });
 }

package/dist/core/engine/callback-creators.js

@@ -1,6 +1,5 @@
 import { KEYS } from "../../storage/interface.js";
-import { HISTORY_CIRCUIT_BREAKER_REASON } from "../types.js";
-import { validateAttributeValueSizes } from "./attributes-tags.js";
+import { createCheckpointPersistenceCallbacks } from "./callback-checkpoint-persistence.js";
 import {
   createConstraintCallbacks,
   createLifecycleCallbacks,
@@ -8,12 +7,7 @@ import {
   registerEnsureRetentionSweepInterval
 } from "./callback-creators-core.js";
 import { createOperationRouterCallbacks } from "./callback-creators-router.js";
-import {
-  appendTimelineBatchOperations,
-  persistCheckpoint,
-  pruneCheckpointHistory,
-  validateDevelopmentCheckpoint
-} from "./checkpoint-io.js";
+import { persistCheckpoint, validateDevelopmentCheckpoint } from "./checkpoint-io.js";
 import { evaluateConstraints } from "./constraints.js";
 import {
   getParkedWorkflowResumeDisposition,
@@ -30,8 +24,7 @@ import {
 } from "./retention.js";
 import { hasBufferedSignal } from "./signals.js";
 import { loadWorkflowState, runSerializedWorkflowStateWrite } from "./storage-io.js";
-import { swallowPromiseRejection } from "./strategy-helpers.js";
-import { cleanupWaiters, terminateWorkflow } from "./termination.js";
+import { cleanupWaiters } from "./termination.js";
 export { createUpdateCallbacks } from "./callback-creators-bundles.js";
 export {
   createBroadcastCallbacks,
@@ -64,18 +57,7 @@ export function createInlineParkingCallbacks(engine) {
   };
 }
 export function persistCheckpointForEngine(engine, workflowId, operation, workerCheckpointBytes) {
-  return persistCheckpoint(getInternals(engine), workflowId, operation, workerCheckpointBytes, {
-    appendTimelineBatchOperations: (id, checkpointOperation, step, timestamp, operations) => appendTimelineBatchOperations(getInternals(engine), id, checkpointOperation, step, timestamp, operations),
-    swallowPromiseRejection: (promise) => {
-      swallowPromiseRejection(promise);
-    },
-    validateAttributeValueSizes,
-    pruneCheckpointHistory: (id, step) => pruneCheckpointHistory(getInternals(engine), id, step),
-    dispatchEvent: (event) => {
-      engine.dispatchEvent(event);
-    },
-    enforceHistoryCircuitBreaker: (id) => terminateWorkflow(getInternals(engine), id, "timed-out", createTerminationCallbacks(engine), HISTORY_CIRCUIT_BREAKER_REASON)
-  });
+  return persistCheckpoint(getInternals(engine), workflowId, operation, workerCheckpointBytes, createCheckpointPersistenceCallbacks(engine));
 }
 function ensureRetentionSweepIntervalForEngine(engine) {
   ensureRetentionSweepInterval(getInternals(engine), {

package/dist/core/engine/checkpoint-io.d.ts

@@ -9,7 +9,7 @@ type PendingTimelineEntryValue = {
 export type PersistCheckpointOptions = {
     timeline?: 'record-operation' | 'preserve-pending';
 };
-type PersistCheckpointCallbacks = {
+export type PersistCheckpointCallbacks = {
     appendTimelineBatchOperations: (workflowId: string, operation: ContextOperationRequest, step: number, timestamp: number, operations: BatchOperation[]) => PendingTimelineEntryValue;
     swallowPromiseRejection: (promise: Promise<void>) => void;
     validateAttributeValueSizes: (attributes: Record<string, SearchAttributeValue>) => void;

package/dist/core/engine/operations-coordination.js

@@ -1,6 +1,6 @@
 import {
   isParallelOperationCacheEntry
-} from "../context/parallel-operations.js";
+} from "../context/parallel-cache-entry.js";
 import {
   executeRunAllBranches,
   executeRunAllBranchesSettled

package/dist/core/engine/parallel-dispatch.d.ts

@@ -25,7 +25,7 @@
  * checkpoint-write machinery — see the `parallel-execution.md` guide
  * for the precise durability contract.
  */
-import type { ParallelBranchSlot, ParallelOperationCacheEntry } from '../context/parallel-operations.ts';
+import type { ParallelBranchSlot, ParallelOperationCacheEntry } from '../context/parallel-cache-entry.ts';
 export type ParallelDispatchResult = {
     /** Final slot table — every entry is `fulfilled` or `rejected`. */
     slots: ParallelBranchSlot[];

package/dist/core/engine/parallel-dispatch.js

@@ -1,4 +1,4 @@
-import { createParallelOperationCacheEntry } from "../context/parallel-operations.js";
+import { createParallelOperationCacheEntry } from "../context/parallel-cache-entry.js";
 export function createFirstRejectionCapture() {
   return { hasFirstError: !1, firstError: void 0 };
 }

package/dist/core/engine/review-list-entries.d.ts

@@ -1,4 +1,4 @@
-import type { HumanReviewResult, ReviewRequest } from '../review/index.ts';
+import { type HumanReviewResult, type ReviewRequest } from '../review/index.ts';
 import type { CompletedReviewEntry, PendingReviewEntry } from '../types.ts';
 export declare function toPendingReviewEntry(review: ReviewRequest): PendingReviewEntry;
 export declare function parseStoredReviewRequest(value: Uint8Array): ReviewRequest | null;

package/dist/core/engine/review-list-entries.js

@@ -1,32 +1,8 @@
-import { z } from "zod";
 import { decode } from "../codec.js";
-const storedReviewRequestSchema = z.object({
-  reviewId: z.string(),
-  workflowId: z.string(),
-  artifact: z.unknown().nonoptional(),
-  reviewType: z.string(),
-  reviewers: z.array(z.string()),
-  allowPartial: z.boolean(),
-  timeout: z.number().optional(),
-  webhookUrl: z.string().optional(),
-  createdAt: z.number()
-}), persistedCompletedReviewEntrySchema = z.object({
-  status: z.literal("completed"),
-  reviewId: z.string(),
-  workflowId: z.string(),
-  artifact: z.unknown().nonoptional(),
-  reviewType: z.string(),
-  reviewers: z.array(z.string()),
-  allowPartial: z.boolean(),
-  timeout: z.number().optional(),
-  webhookUrl: z.string().optional(),
-  createdAt: z.number(),
-  decision: z.enum(["approved", "rejected", "needs-changes"]),
-  reviewer: z.string(),
-  feedback: z.string().optional(),
-  sectionDecisions: z.record(z.string(), z.enum(["approved", "rejected"])).optional(),
-  timestamp: z.number()
-});
+import {
+  completedReviewEntrySchema,
+  reviewRequestSchema
+} from "../review/index.js";
 function assignWhenDefined(target, key, value) {
   if (value !== void 0)
     target[key] = value;
@@ -58,7 +34,7 @@ export function parseStoredReviewRequest(value) {
   } catch {
     return null;
   }
-  const parsedReview = storedReviewRequestSchema.safeParse(decodedValue);
+  const parsedReview = reviewRequestSchema.safeParse(decodedValue);
   if (!parsedReview.success)
     return null;
   return normalizeStoredReviewRequest(parsedReview.data);
@@ -110,7 +86,7 @@ export function parseCompletedReviewEntry(value) {
   } catch {
     return null;
   }
-  const parsedReview = persistedCompletedReviewEntrySchema.safeParse(decodedValue);
+  const parsedReview = completedReviewEntrySchema.safeParse(decodedValue);
   if (!parsedReview.success)
     return null;
   return normalizeCompletedReviewEntry(parsedReview.data);

package/dist/core/engine/timeline-coordinator-detail.d.ts

@@ -1,5 +1,5 @@
 import type { ContextOperationRequest } from '../context.ts';
-import type { ParallelBranchSlot } from '../context/parallel-operations.ts';
+import type { ParallelBranchSlot } from '../context/parallel-cache-entry.ts';
 import type { WorkflowTimelineOperationDetail } from '../types.ts';
 import type { EngineInternals } from './internals.ts';
 export declare function operationTimelineDetail(operation: ContextOperationRequest, index: number, outcome: WorkflowTimelineOperationDetail['outcome'], options?: {