@lostgradient/weft 0.2.1 → 0.4.0

package/dist/core/events/schedule-events.js

@@ -0,0 +1,29 @@
+export class ScheduleFiredEvent extends Event {
+  static type = "schedule:fired";
+  scheduleId;
+  workflowId;
+  firedAt;
+  occurrence;
+  constructor(scheduleId, workflowId, firedAt, occurrence) {
+    super(ScheduleFiredEvent.type);
+    this.scheduleId = scheduleId;
+    this.workflowId = workflowId;
+    this.firedAt = firedAt;
+    this.occurrence = occurrence;
+  }
+}
+
+export class ScheduleMissedFireEvent extends Event {
+  static type = "schedule:missed-fire";
+  scheduleId;
+  missedCount;
+  windowStart;
+  windowEnd;
+  constructor(scheduleId, missedCount, windowStart, windowEnd) {
+    super(ScheduleMissedFireEvent.type);
+    this.scheduleId = scheduleId;
+    this.missedCount = missedCount;
+    this.windowStart = windowStart;
+    this.windowEnd = windowEnd;
+  }
+}

package/dist/core/events/signal-events.d.ts

@@ -8,9 +8,8 @@
  * import { Engine, SignalReceivedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('signal:received', (e: Event) => {
- *   const ev = e as SignalReceivedEvent;
- *   console.log(ev.workflowId, 'received signal', ev.signalName);
+ * engine.addEventListener(SignalReceivedEvent.type, (event) => {
+ *   console.log(event.workflowId, 'received signal', event.signalName);
  * });
  * ```
  */
@@ -31,9 +30,8 @@ export declare class SignalReceivedEvent extends Event {
  * import { Engine, SignalDeliveredEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('signal:delivered', (e: Event) => {
- *   const ev = e as SignalDeliveredEvent;
- *   console.log('signal', ev.signalName, 'delivered to', ev.workflowId);
+ * engine.addEventListener(SignalDeliveredEvent.type, (event) => {
+ *   console.log('signal', event.signalName, 'delivered to', event.workflowId);
  * });
  * ```
  */

package/dist/core/events/system-events.d.ts

@@ -9,9 +9,8 @@ import type { ConstraintViolation } from '../constraint.ts';
  * import { Engine, CheckpointSizeWarningEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine({ checkpointSizeWarningThreshold: 32_000 });
- * engine.addEventListener('checkpoint:size-warning', (e: Event) => {
- *   const ev = e as CheckpointSizeWarningEvent;
- *   console.warn(ev.workflowId, 'checkpoint at step', ev.step, 'is', ev.sizeBytes, 'bytes');
+ * engine.addEventListener(CheckpointSizeWarningEvent.type, (event) => {
+ *   console.warn(event.workflowId, 'checkpoint at step', event.step, 'is', event.sizeBytes, 'bytes');
  * });
  * ```
  */
@@ -33,9 +32,8 @@ export declare class CheckpointSizeWarningEvent extends Event {
  * import { Engine, DevelopmentWarningEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine({ development: true });
- * engine.addEventListener('development:warning', (e: Event) => {
- *   const ev = e as DevelopmentWarningEvent;
- *   console.warn('[dev]', ev.message, 'paths:', ev.fieldPaths);
+ * engine.addEventListener(DevelopmentWarningEvent.type, (event) => {
+ *   console.warn('[dev]', event.message, 'paths:', event.fieldPaths);
  * });
  * ```
  */
@@ -63,9 +61,8 @@ export declare class CleanupWarningEvent extends Event {
  * import { Engine, StorageSizeReportedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('storage:size-reported', (e: Event) => {
- *   const ev = e as StorageSizeReportedEvent;
- *   console.log('total storage:', ev.sizeBytes, 'bytes');
+ * engine.addEventListener(StorageSizeReportedEvent.type, (event) => {
+ *   console.log('total storage:', event.sizeBytes, 'bytes');
  * });
  * ```
  */
@@ -74,6 +71,22 @@ export declare class StorageSizeReportedEvent extends Event {
     readonly sizeBytes: number;
     constructor(sizeBytes: number);
 }
+/** Fired when a remote worker successfully registers with the server runtime. */
+export declare class WorkerConnectedEvent extends Event {
+    static readonly type: "worker:connected";
+    readonly workerId: string;
+    readonly queue: string;
+    readonly activities: readonly string[];
+    readonly concurrency: number;
+    constructor(workerId: string, queue: string, activities: readonly string[], concurrency: number);
+}
+/** Fired when a registered remote worker is removed after disconnect handling. */
+export declare class WorkerDisconnectedEvent extends Event {
+    static readonly type: "worker:disconnected";
+    readonly workerId: string;
+    readonly inFlightTaskCount: number;
+    constructor(workerId: string, inFlightTaskCount: number);
+}
 /**
  * Fired on the {@link Engine} when a built-in alert metric breaches its
  * threshold. Read `e.metric`, `e.threshold`, `e.currentValue`, and
@@ -84,9 +97,8 @@ export declare class StorageSizeReportedEvent extends Event {
  * import { Engine, AlertFiredEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('alert:fired', (e: Event) => {
- *   const ev = e as AlertFiredEvent;
- *   console.warn('alert fired:', ev.metric, 'current:', ev.currentValue, 'threshold:', ev.threshold);
+ * engine.addEventListener(AlertFiredEvent.type, (event) => {
+ *   console.warn('alert fired:', event.metric, 'current:', event.currentValue, 'threshold:', event.threshold);
  * });
  * ```
  */
@@ -108,9 +120,8 @@ export declare class AlertFiredEvent extends Event {
  * import { Engine, AlertResolvedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('alert:resolved', (e: Event) => {
- *   const ev = e as AlertResolvedEvent;
- *   console.log('alert resolved:', ev.metric, 'value back to', ev.currentValue);
+ * engine.addEventListener(AlertResolvedEvent.type, (event) => {
+ *   console.log('alert resolved:', event.metric, 'value back to', event.currentValue);
  * });
  * ```
  */
@@ -132,10 +143,9 @@ export declare class AlertResolvedEvent extends Event {
  * import { Engine, ConstraintViolatedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('constraint:violated', (e: Event) => {
- *   const ev = e as ConstraintViolatedEvent;
- *   console.warn('constraint', ev.constraintName, 'violated in', ev.workflowId,
- *     'action:', ev.onViolation);
+ * engine.addEventListener(ConstraintViolatedEvent.type, (event) => {
+ *   console.warn('constraint', event.constraintName, 'violated in', event.workflowId,
+ *     'action:', event.onViolation);
  * });
  * ```
  */

package/dist/core/events/system-events.js

@@ -46,6 +46,32 @@ export class StorageSizeReportedEvent extends Event {
   }
 }
 
+export class WorkerConnectedEvent extends Event {
+  static type = "worker:connected";
+  workerId;
+  queue;
+  activities;
+  concurrency;
+  constructor(workerId, queue, activities, concurrency) {
+    super(WorkerConnectedEvent.type);
+    this.workerId = workerId;
+    this.queue = queue;
+    this.activities = activities;
+    this.concurrency = concurrency;
+  }
+}
+
+export class WorkerDisconnectedEvent extends Event {
+  static type = "worker:disconnected";
+  workerId;
+  inFlightTaskCount;
+  constructor(workerId, inFlightTaskCount) {
+    super(WorkerDisconnectedEvent.type);
+    this.workerId = workerId;
+    this.inFlightTaskCount = inFlightTaskCount;
+  }
+}
+
 export class AlertFiredEvent extends Event {
   static type = "alert:fired";
   metric;

package/dist/core/events/update-events.d.ts

@@ -8,9 +8,8 @@
  * import { Engine, UpdateReceivedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('update:received', (e: Event) => {
- *   const ev = e as UpdateReceivedEvent;
- *   console.log('update', ev.name, 'received for', ev.workflowId, '(id:', ev.updateId, ')');
+ * engine.addEventListener(UpdateReceivedEvent.type, (event) => {
+ *   console.log('update', event.name, 'received for', event.workflowId, '(id:', event.updateId, ')');
  * });
  * ```
  */
@@ -32,12 +31,11 @@ export declare class UpdateReceivedEvent extends Event {
  * import { Engine, UpdateCompletedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('update:completed', (e: Event) => {
- *   const ev = e as UpdateCompletedEvent;
- *   if (ev.error) {
- *     console.error('update', ev.name, 'failed:', ev.error);
+ * engine.addEventListener(UpdateCompletedEvent.type, (event) => {
+ *   if (event.error) {
+ *     console.error('update', event.name, 'failed:', event.error);
  *   } else {
- *     console.log('update', ev.name, 'result:', ev.result);
+ *     console.log('update', event.name, 'result:', event.result);
  *   }
  * });
  * ```

package/dist/core/events/workflow-events.d.ts

@@ -1,4 +1,24 @@
 import type { TerminationReason } from '../types/history-policy.ts';
+/**
+ * Fired on the {@link Engine} after a workflow definition is successfully
+ * registered. Same-reference idempotent registration does not emit this event.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowDefinitionRegisteredEvent, workflow } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowDefinitionRegisteredEvent.type, (event) => {
+ *   console.log('registered workflow:', event.workflowType);
+ * });
+ * engine.register(workflow({ name: 'ping' }).execute(async function* () { return 'pong'; }));
+ * ```
+ */
+export declare class WorkflowDefinitionRegisteredEvent extends Event {
+    static readonly type: "workflow:definition-registered";
+    readonly workflowType: string;
+    constructor(workflowType: string);
+}
 /**
  * Fired on the {@link Engine} when a new workflow execution begins. Listen via
  * `engine.addEventListener('workflow:started', handler)` and read
@@ -9,9 +29,8 @@ import type { TerminationReason } from '../types/history-policy.ts';
  * import { workflow, Engine, WorkflowStartedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('workflow:started', (e: Event) => {
- *   const ev = e as WorkflowStartedEvent;
- *   console.log('started', ev.workflowId, ev.workflowType);
+ * engine.addEventListener(WorkflowStartedEvent.type, (event) => {
+ *   console.log('started', event.workflowId, event.workflowType);
  * });
  * engine.register(workflow({ name: 'ping' }).execute(async function* () { return 'pong'; }));
  * await engine.start('ping', null);
@@ -34,9 +53,8 @@ export declare class WorkflowStartedEvent extends Event {
  * import { workflow, Engine, WorkflowCompletedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('workflow:completed', (e: Event) => {
- *   const ev = e as WorkflowCompletedEvent;
- *   console.log('completed in', ev.duration, 'ms, result:', ev.result);
+ * engine.addEventListener(WorkflowCompletedEvent.type, (event) => {
+ *   console.log('completed in', event.duration, 'ms, result:', event.result);
  * });
  * engine.register(workflow({ name: 'ping' }).execute(async function* () { return 'pong'; }));
  * await (await engine.start('ping', null)).result();
@@ -59,9 +77,8 @@ export declare class WorkflowCompletedEvent extends Event {
  * import { workflow, Engine, WorkflowFailedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('workflow:failed', (e: Event) => {
- *   const ev = e as WorkflowFailedEvent;
- *   console.error('workflow', ev.workflowId, 'failed:', ev.error.message);
+ * engine.addEventListener(WorkflowFailedEvent.type, (event) => {
+ *   console.error('workflow', event.workflowId, 'failed:', event.error.message);
  * });
  * engine.register(workflow({ name: 'boom' }).execute(async function* () { throw new Error('oops'); }));
  * await engine.start('boom', null).then(h => h.result()).catch(() => undefined);
@@ -83,9 +100,8 @@ export declare class WorkflowFailedEvent extends Event {
  * import { Engine, workflow, WorkflowCancelledEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('workflow:cancelled', (e: Event) => {
- *   const ev = e as WorkflowCancelledEvent;
- *   console.log('cancelled', ev.workflowId);
+ * engine.addEventListener(WorkflowCancelledEvent.type, (event) => {
+ *   console.log('cancelled', event.workflowId);
  * });
  * engine.register(
  *   workflow({ name: 'slow' }).execute(async function* (
@@ -117,9 +133,8 @@ export declare class WorkflowCancelledEvent extends Event {
  * import { Engine, WorkflowTimedOutEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('workflow:timed-out', (e: Event) => {
- *   const ev = e as WorkflowTimedOutEvent;
- *   console.log(ev.workflowId, 'timed out after', ev.elapsed, 'ms (', ev.timeoutType, ')');
+ * engine.addEventListener(WorkflowTimedOutEvent.type, (event) => {
+ *   console.log(event.workflowId, 'timed out after', event.elapsed, 'ms (', event.timeoutType, ')');
  * });
  * ```
  */
@@ -148,9 +163,8 @@ export declare const WORKFLOW_TERMINAL_EVENT_TYPES: ReadonlySet<string>;
  * import { Engine, WorkflowResumedEvent } from '@lostgradient/weft';
  *
  * const engine = new Engine();
- * engine.addEventListener('workflow:resumed', (e: Event) => {
- *   const ev = e as WorkflowResumedEvent;
- *   console.log('resumed', ev.workflowId, 'from step', ev.fromStep);
+ * engine.addEventListener(WorkflowResumedEvent.type, (event) => {
+ *   console.log('resumed', event.workflowId, 'from step', event.fromStep);
  * });
  * ```
  */
@@ -160,6 +174,28 @@ export declare class WorkflowResumedEvent extends Event {
     readonly fromStep: number;
     constructor(workflowId: string, fromStep: number);
 }
+/**
+ * Fired when a running workflow is explicitly suspended via
+ * `handle.suspend()` / `engine.suspend(id)`. Suspension is a non-terminal pause:
+ * the workflow keeps its checkpoint and is later resumable. This event is
+ * intentionally NOT in {@link WORKFLOW_TERMINAL_EVENT_TYPES} — a suspended
+ * workflow has not ended, and `handle.result()` stays pending.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowSuspendedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowSuspendedEvent.type, (event) => {
+ *   console.log('suspended', event.workflowId);
+ * });
+ * ```
+ */
+export declare class WorkflowSuspendedEvent extends Event {
+    static readonly type: "workflow:suspended";
+    readonly workflowId: string;
+    constructor(workflowId: string);
+}
 /**
  * Reason carried by {@link WorkflowRecoverySkippedEvent}.
  *
@@ -184,8 +220,7 @@ export type WorkflowRecoverySkippedReason = 'type-not-registered';
  *
  * const engine = new Engine();
  * engine.addEventListener(WorkflowRecoverySkippedEvent.type, (event) => {
- *   const skipped = event as WorkflowRecoverySkippedEvent;
- *   console.warn('skipped recovery for', skipped.workflowType);
+ *   console.warn('skipped recovery for', event.workflowType);
  * });
  * ```
  */
@@ -196,3 +231,56 @@ export declare class WorkflowRecoverySkippedEvent extends Event {
     readonly reason: WorkflowRecoverySkippedReason;
     constructor(workflowId: string, workflowType: string, reason: WorkflowRecoverySkippedReason);
 }
+/**
+ * The lifecycle stage a {@link WorkflowTeardownEvent} reports for a workflow's
+ * definition-level `finalizer` (issue #446):
+ *
+ * - `'completed'`: the finalizer succeeded — the external resource recorded via
+ *   `ctx.setFinalizerState` has been torn down.
+ * - `'failed'`: a single attempt failed; the engine backs off and re-fires unless the
+ *   dead-letter horizon is reached. Per-attempt observability — fires on every retry.
+ * - `'dead-lettered'`: the retry horizon was reached without success; the external
+ *   resource may be leaked. The durable record is `KEYS.teardownDeadLetter`, which
+ *   survives purge so the leak is auditable after the workflow record is gone.
+ *
+ * @example
+ * ```ts
+ * import type { WorkflowTeardownStatus } from '@lostgradient/weft';
+ *
+ * const status: WorkflowTeardownStatus = 'dead-lettered';
+ * void status;
+ * ```
+ */
+export type WorkflowTeardownStatus = 'completed' | 'failed' | 'dead-lettered';
+/**
+ * Fired on the {@link Engine} as a workflow's definition-level `finalizer` progresses
+ * through teardown after a `cancelled`/`timed-out` terminal (issue #446). One event
+ * type carries the stage in `status`; `attempts` is the attempt count; `error` is the
+ * failure message on `'failed'`/`'dead-lettered'` (absent on `'completed'`). The schema is
+ * stable and compact, and `status` is low-cardinality; `workflowId`/`workflowType` are
+ * naturally high-cardinality identifiers. Keep `'failed'` listeners side-effect-light —
+ * they fire on every retry.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowTeardownEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowTeardownEvent.type, (event) => {
+ *   if (event.status === 'dead-lettered') {
+ *     console.error('LEAKED resource: teardown for', event.workflowId, 'gave up after', event.attempts);
+ *   } else {
+ *     console.log('teardown', event.status, 'for', event.workflowId, 'attempt', event.attempts);
+ *   }
+ * });
+ * ```
+ */
+export declare class WorkflowTeardownEvent extends Event {
+    static readonly type: "workflow:teardown";
+    readonly workflowId: string;
+    readonly workflowType: string;
+    readonly status: WorkflowTeardownStatus;
+    readonly attempts: number;
+    readonly error: string | undefined;
+    constructor(workflowId: string, workflowType: string, status: WorkflowTeardownStatus, attempts: number, error?: string);
+}

package/dist/core/events/workflow-events.js

@@ -1,3 +1,12 @@
+export class WorkflowDefinitionRegisteredEvent extends Event {
+  static type = "workflow:definition-registered";
+  workflowType;
+  constructor(workflowType) {
+    super(WorkflowDefinitionRegisteredEvent.type);
+    this.workflowType = workflowType;
+  }
+}
+
 export class WorkflowStartedEvent extends Event {
   static type = "workflow:started";
   workflowId;
@@ -77,6 +86,15 @@ export class WorkflowResumedEvent extends Event {
   }
 }
 
+export class WorkflowSuspendedEvent extends Event {
+  static type = "workflow:suspended";
+  workflowId;
+  constructor(workflowId) {
+    super(WorkflowSuspendedEvent.type);
+    this.workflowId = workflowId;
+  }
+}
+
 export class WorkflowRecoverySkippedEvent extends Event {
   static type = "workflow:recovery-skipped";
   workflowId;
@@ -89,3 +107,20 @@ export class WorkflowRecoverySkippedEvent extends Event {
     this.reason = reason;
   }
 }
+
+export class WorkflowTeardownEvent extends Event {
+  static type = "workflow:teardown";
+  workflowId;
+  workflowType;
+  status;
+  attempts;
+  error;
+  constructor(workflowId, workflowType, status, attempts, error) {
+    super(WorkflowTeardownEvent.type);
+    this.workflowId = workflowId;
+    this.workflowType = workflowType;
+    this.status = status;
+    this.attempts = attempts;
+    this.error = error;
+  }
+}

package/dist/core/failure-categories.js

@@ -6,6 +6,8 @@ export const FAILURE_CATEGORIES = [
   "system"
 ];
 const currentFailureCategories = new Set(FAILURE_CATEGORIES), timeoutErrorNames = new Set([
+  "ActivityScheduleToCloseTimeoutError",
+  "ActivityPerAttemptTimeoutError",
   "MCPToolTimeoutError",
   "ReviewTimeoutError",
   "UpdateTimeoutError",
@@ -23,31 +25,17 @@ const cancellationErrorNames = new Set([
   "ResourceExhaustedError",
   "OutOfMemoryError",
   "StorageQuotaExceededError"
-]), legacyFailureCategoryMapping = {
-  action: "application",
-  memory: "resource",
-  planning: "application",
-  reflection: "application",
-  system: "system"
-}, failureCategorySearchAliases = {
-  application: ["application", "action", "planning", "reflection"],
-  timeout: ["timeout"],
-  cancellation: ["cancellation"],
-  resource: ["resource", "memory"],
-  system: ["system"]
-};
+]);
 export function isFailureCategory(value) {
   return currentFailureCategories.has(value);
 }
 export function normalizeFailureCategory(value) {
   if (isFailureCategory(value))
     return value;
-  if (typeof value !== "string")
-    return;
-  return legacyFailureCategoryMapping[value];
+  return;
 }
 export function failureCategorySearchValues(category) {
-  return failureCategorySearchAliases[category];
+  return [category];
 }
 export function classifyErrorAsFailureCategory(error, options = {}) {
   if (!(error instanceof Error))

package/dist/core/fault-code.d.ts

@@ -4,8 +4,10 @@
  * onto the wire so clients can branch on the failure programmatically rather
  * than string-matching a human message:
  *
- *   - REST: `{ error: { code, message, data? } }` (see `fault-to-http.ts`).
- *   - JSON-RPC: `data.weftCode` (see `fault-to-json-rpc.ts`).
+ *   - REST operation routes: HTTP status plus `{ error: string }` for declared
+ *     faults, with `EngineFailure` masked to `"Internal server error"`.
+ *   - JSON-RPC: `error.data.weftCode` plus `error.data.httpStatus` (see
+ *     `fault-to-json-rpc.ts`).
  *
  * The type lives in `core` — not `server` — because both the server (which
  * produces faults) and the client (which consumes them off the wire) need it,
@@ -23,6 +25,9 @@ import type { FailureCategory } from './types/identity.ts';
  * be added additively, and the `satisfies` map below forces every new code to
  * declare its failure category at compile time.
  *
+ * See `documentation/reference/api-errors.md#faultcode` for the REST HTTP
+ * status and JSON-RPC error-data mappings for every public fault code.
+ *
  * @example
  * ```ts
  * import { HttpClientError, type FaultCode } from '@lostgradient/weft';
@@ -34,7 +39,7 @@ import type { FailureCategory } from './types/identity.ts';
  * void describe;
  * ```
  */
-export type FaultCode = 'Unauthorized' | 'Forbidden' | 'NotFound' | 'Conflict' | 'Unprocessable' | 'Timeout' | 'NotImplemented' | 'UnsupportedTransport' | 'SubscriptionOverflow' | 'InvalidParams' | 'MethodNotFound' | 'EngineFailure';
+export type FaultCode = 'Unauthorized' | 'Forbidden' | 'NotFound' | 'Conflict' | 'Unprocessable' | 'Timeout' | 'PayloadTooLarge' | 'NotImplemented' | 'UnsupportedTransport' | 'SubscriptionOverflow' | 'InvalidParams' | 'MethodNotFound' | 'EngineFailure';
 /**
  * Maps each wire {@link FaultCode} onto a {@link FailureCategory}.
  *
@@ -61,6 +66,7 @@ export declare const FAULT_CODE_TO_FAILURE_CATEGORY: Readonly<{
     readonly InvalidParams: "application";
     readonly MethodNotFound: "application";
     readonly Timeout: "timeout";
+    readonly PayloadTooLarge: "resource";
     readonly SubscriptionOverflow: "resource";
     readonly NotImplemented: "system";
     readonly UnsupportedTransport: "system";

package/dist/core/fault-code.js

@@ -7,6 +7,7 @@ export const FAULT_CODE_TO_FAILURE_CATEGORY = Object.freeze({
   InvalidParams: "application",
   MethodNotFound: "application",
   Timeout: "timeout",
+  PayloadTooLarge: "resource",
   SubscriptionOverflow: "resource",
   NotImplemented: "system",
   UnsupportedTransport: "system",

package/dist/core/inline-execution-strategy.context-options.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Dependency shapes and the context-options builder used by
+ * {@link InlineExecutionStrategy}. Kept beside the strategy so the strategy
+ * module stays focused on generator lifecycle and context bookkeeping.
+ *
+ * @module core/inline-execution-strategy.context-options
+ */
+import type { ContextOptions } from './context.ts';
+import type { ComposedWorkflowInterceptor } from './interceptor.ts';
+import type { SearchAttributeSchema, WorkflowFunction } from './types.ts';
+import type { WorkflowLogRecord } from './types/workflow-log.ts';
+/** Capabilities the engine injects into the inline strategy at construction. */
+export interface InlineExecutionDependencies {
+    getRegistration: (workflowType: string) => {
+        handler: WorkflowFunction;
+        version: string;
+        searchAttributes?: SearchAttributeSchema;
+    } | undefined;
+    getNow: () => number;
+    resolveWorkflowType?: (target: string | Function) => string;
+    maxNestingDepth: number;
+    development?: boolean;
+    getComposedWorkflowInterceptor?: () => ComposedWorkflowInterceptor | null;
+    registerCancelHandler?: (workflowId: string, handler: () => Promise<void> | void) => () => void;
+    /**
+     * Durably record a `ctx.setFinalizerState(value)` payload for a workflow (#446).
+     * The engine stages it as a pending atomic side-effect so it commits with the
+     * next checkpoint or the terminal batch. Absent in worker mode.
+     */
+    recordFinalizerState?: (workflowId: string, value: unknown) => void;
+    /**
+     * Look up the non-serialized per-run `services` value for a workflow, exposed
+     * to the body as `ctx.services`. Returns `undefined` when none was supplied.
+     */
+    getWorkflowServices?: (workflowId: string) => unknown;
+    /**
+     * The host log sink (`EngineOptions.onLog`) for `ctx.log` records, or
+     * `undefined` for the default console behavior. Engine-scoped, so it takes no
+     * workflow id.
+     */
+    getLogSink?: () => ((record: WorkflowLogRecord) => void) | undefined;
+}
+/** A registration resolved through {@link InlineExecutionDependencies.getRegistration}, narrowed to the present case. */
+export type InlineWorkflowRegistration = NonNullable<ReturnType<InlineExecutionDependencies['getRegistration']>>;
+/** Parameters for starting a workflow run on the inline strategy. */
+export type InlineStartWorkflowParameters = {
+    workflowId: string;
+    workflowType: string;
+    input: unknown;
+    checkpoint: ArrayBuffer | Uint8Array;
+    nestingDepth?: number;
+    executionStateOwnerId?: string;
+    startedAt?: number;
+    sleepReferenceTime?: number;
+    deadline?: number;
+    headers?: [string, string][];
+};
+/** Build the {@link ContextOptions} for a single inline workflow run from the injected dependencies and start parameters. */
+export declare function createInlineContextOptions(dependencies: InlineExecutionDependencies, registration: InlineWorkflowRegistration, parameters: InlineStartWorkflowParameters, workflowAbort: AbortController): ContextOptions;
+/**
+ * Keep only the defined optional inline-strategy dependencies. Under
+ * `exactOptionalPropertyTypes` a key set to `undefined` is rejected while an
+ * absent key is fine, so each optional is included only when present. Lives here
+ * (rather than inline in `createExecutionStrategyBundle`) so its conditional
+ * spreads do not tip that function over the cyclomatic-complexity cap.
+ */
+export declare function optionalInlineDependencies(candidates: {
+    [Key in 'getComposedWorkflowInterceptor' | 'registerCancelHandler' | 'recordFinalizerState' | 'getWorkflowServices' | 'getLogSink']: InlineExecutionDependencies[Key] | undefined;
+}): Partial<InlineExecutionDependencies>;