@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/runtime/index.d.cts

@@ -1,7 +1,8 @@
-import { W as WorkflowContext, h as DurableWorkflow, C as CancellationScope, O as Operation, R as RunOptions, j as Duration, l as SignalDefinition, e as ChildTarget, d as ChildOptions, c as ChildHandle, f as ContinueAsNewOptions, b as CancellationScopeOptions } from '../workflow-J-yYixny.cjs';
-export { A as Activation, s as splitActivations } from '../activation-BBh1p82z.cjs';
-import { W as WorkflowCommand, U as RunEventRecord, a7 as WorkflowTaskRequest, a8 as WorkflowTaskResult, a as WorkflowTaskFailureCause, X as RunTarget } from '../types-CpBBjaGX.cjs';
-import { a as Json, J as JsonObject } from '../types-BGoPzgcl.cjs';
+import { k as WorkflowInterceptorsFactory } from '../interceptors-CqkNZVfI.cjs';
+import { W as WorkflowContext, v as DurableWorkflow, U as UpdateDefinition, K as UpdateHandlerOptions, t as DefaultUpdateHandlerOptions, Q as QueryDefinition, C as CancellationScope, O as Operation, R as RunOptions, e as ActivityDefinition, k as ActivityOptions, z as LocalActivityOptions, x as Duration, G as SignalDefinition, I as SignalHandlerOptions, y as ExternalRunTarget, E as ExternalRunHandle, q as ChildTarget, p as ChildOptions, o as ChildHandle, r as ContinueAsNewOptions, n as CancellationScopeOptions } from '../workflow-DS32Gtws.cjs';
+export { A as Activation, s as splitActivations } from '../activation-DqUfpHzk.cjs';
+import { W as WorkflowCommand, R as RunEventRecord, az as WorkflowTaskRequest, aA as WorkflowTaskResult, a as WorkflowTaskFailureCause, ad as RunTarget, M as Headers } from '../types-Bv2i4cBX.cjs';
+import { a as Json, J as JsonObject } from '../types-V7jEEUaL.cjs';
 
 /**
  * Determinism shims for workflow tasks (C-ABI, spec 04 §4).
@@ -51,10 +52,12 @@ declare function uuidFrom(random: () => number): string;
 
 /**
  * Replay matching (spec 04 §4): each command a replayed activation issues must
- * match the command event recorded at the same position. Activities match on
- * id and `nodeType + operation`, children on id and target, everything else on
- * type and id. A recorded patch marker that the code no longer issues is
- * skipped (the patch was deprecated and removed, spec 06 §4).
+ * match the command event recorded at the same position. Node activities
+ * match on id and `nodeType + operation`, user activities (Phase C) on id,
+ * `kind` and `activityName`, children on id and target, updates on id,
+ * everything else on type and id. A recorded patch marker that the code no
+ * longer issues is skipped (the patch was deprecated and removed, spec 06 §4).
+ * `REJECT_UPDATE` appends no event (11 §2.39), so it is not matched.
  */
 
 /** Why `command` does not match `event`, or undefined when it does. */
@@ -71,9 +74,10 @@ declare function matchActivation(commands: readonly WorkflowCommand[], recorded:
 /**
  * Command ids (C-HIST): one counter per kind, in issue order, so a replay that
  * issues the same commands in the same order derives the same ids, and a
- * reordered await is caught as a mismatch. Patch markers use `patch:<id>`.
+ * reordered await is caught as a mismatch. Patch markers use `patch:<id>`;
+ * local activities (R2) use `l<n>`.
  */
-type CommandIdKind = 'a' | 't' | 'c' | 's' | 'x' | 'm';
+type CommandIdKind = 'a' | 't' | 'c' | 's' | 'x' | 'm' | 'l';
 declare class CommandIds {
     private readonly counters;
     /** The next id of a kind: `a1`, `a2`, ... */
@@ -96,6 +100,14 @@ declare function isPatchMarkerId(markerId: string): boolean;
  * finishes it: a replayed activation must have issued exactly the commands it
  * recorded, and the open activation's commands are the task's result.
  *
+ * Updates (C-ABI-H, spec 04 §2): the updates of activation k are delivered
+ * after its input events. A replayed activation re-delivers the updates its
+ * task accepted (`UPDATE_ACCEPTED` in its command block) without running
+ * their validators; the open activation delivers the lease's pending updates
+ * (`request.updates`) with validation. `UPDATE_ADMITTED` is an input event and
+ * is validated like a live request. An update no handler takes by the end of
+ * its activation is rejected (`UpdateNotHandled`).
+ *
  * Pure JavaScript; it runs inside the isolate.
  */
 
@@ -105,7 +117,8 @@ declare const SDK_NAME = "@fluidgrids/workflows";
 declare class ContinueAsNewRequest {
     readonly input: Json;
     readonly options: JsonObject;
-    constructor(input: Json, options: JsonObject);
+    readonly headers: Headers;
+    constructor(input: Json, options: JsonObject, headers?: Headers);
 }
 declare class Scope implements CancellationScope {
     readonly parent: Scope | undefined;
@@ -132,6 +145,8 @@ interface ExecutionInput {
     exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
     request: WorkflowTaskRequest;
     sdkVersion: string;
+    /** The bundle's workflow interceptors (`interceptors` exports), in module order. */
+    interceptors?: readonly WorkflowInterceptorsFactory[];
 }
 /** One workflow task in progress. */
 declare class WorkflowExecution {
@@ -144,7 +159,7 @@ declare class WorkflowExecution {
     private activationOpen;
     private replaying;
     private clock;
-    private readonly random;
+    private readonly randomSource;
     private readonly ids;
     private commands;
     private newCommands;
@@ -183,7 +198,34 @@ declare class WorkflowExecution {
     private readonly signalHandlers;
     private readonly signalWaiters;
     private defaultSignalHandler;
+    private defaultSignalPolicy;
+    private readonly signalPolicies;
     private runningHandlers;
+    /** Running asynchronous handlers by name, for the drain warning (11 §2.18). */
+    private readonly running;
+    private unfinished;
+    /** Updates delivered so far, by id (an update is delivered at most once per task). */
+    private readonly deliveredUpdates;
+    /** Updates delivered in the current activation without a handler yet. */
+    private bufferedUpdates;
+    private readonly updateHandlers;
+    private defaultUpdateHandler;
+    private readonly queryHandlers;
+    private defaultQueryHandler;
+    /** Set while a query handler or an update validator runs: commands and sinks throw. */
+    private readOnly;
+    /** The first state-changing call a read-only handler made, even when it caught the error. */
+    private readOnlyViolation;
+    private searchAttributes;
+    private readonly startHeaders;
+    private readonly inbound;
+    private readonly outbound;
+    private sinkCalls;
+    private sinkCallsDropped;
+    private readonly recordedLocalActivities;
+    private readonly localActivityResults;
+    private readonly localActivities;
+    private memo;
     private conditions;
     private currentDetails;
     readonly context: WorkflowContext;
@@ -192,23 +234,93 @@ declare class WorkflowExecution {
     private continueAsNewSuggested;
     /** The workflow clock. */
     now(): number;
-    /** The next deterministic random number. */
+    /** The next deterministic random number (`Math.random()` and `crypto.getRandomValues()`). */
     nextRandom(): number;
+    /** `ctx.random()`: advances the run's random source, so read-only handlers may not call it. */
+    private random;
+    /**
+     * Throw `QueryHandlerSideEffect` when a query handler or an update validator
+     * calls something that changes the run's deterministic state (the random
+     * source, the command id counters, patches, details). Validators are not run
+     * again on replay, and a worker that keeps a run's state between tasks keeps
+     * whatever a query handler changed, so either would make the next replay
+     * diverge. The violation is remembered, so catching the error does not hide it.
+     */
+    private assertWritable;
+    /** The next command id of a kind; refused in read-only handlers (it advances a counter). */
+    private nextId;
     /** Begin or finish an activation; `done` when there is nothing left to do. */
     step(): 'more' | 'done';
     /** The task's result. Call after `step()` returned `done` and jobs were drained. */
     complete(): WorkflowTaskResult;
+    /**
+     * The local activities the open activation waits for, when the task is a
+     * workflow task that has not failed or closed the run (a run that ends
+     * abandons a local activity it did not await).
+     */
+    private pendingLocalActivityRequests;
     /** Fail the task (the runtime's own failures and code errors). */
     failTask(cause: WorkflowTaskFailureCause, message: string, stackTrace?: string, seq?: number, errorType?: string): void;
     private beginActivation;
+    /**
+     * The updates an activation delivers after its inputs (C-ABI-H): a replayed
+     * activation re-delivers the updates its task accepted (validators
+     * skipped); the open activation of a workflow task delivers the lease's
+     * pending updates. Updates history admitted (`UPDATE_ADMITTED`) arrive as
+     * inputs instead.
+     */
+    private updatesOf;
     private finishActivation;
+    /**
+     * A local activity issued on a replayed activation without a recorded
+     * outcome is fine only when the first execution dropped it in that same
+     * activation: its scope was cancelled (the entry is gone) or the run closed.
+     * One still waiting means the first execution would have requested and
+     * recorded it, so the code diverged from the history.
+     */
+    private checkReplayedLocalActivities;
     private deliver;
     private expectIssued;
     private settleActivity;
     private settleChild;
+    /** Run a signal handler through the inbound `handleSignal` interceptors. */
+    private signalCall;
     private dispatchSignal;
     private takeBuffered;
     private runHandler;
+    /** Count a running asynchronous handler (drain check, `allHandlersFinished`); returns its end. */
+    private trackHandler;
+    private deliverUpdate;
+    private updateHandlerFor;
+    /**
+     * Run `fn` with commands, sinks and every other change to the run's
+     * deterministic state refused (query handlers, update validators). A
+     * refused call fails the whole call with `QueryHandlerSideEffect`, even
+     * when the code caught the error it threw.
+     */
+    private readOnlyCall;
+    /**
+     * Validate, accept and run one update. A validator error rejects it
+     * (`REJECT_UPDATE`, no history); otherwise `ACCEPT_UPDATE` is issued and
+     * the handler's result or failure completes it (`COMPLETE_UPDATE`). A
+     * handler that throws something other than a failure class fails the task,
+     * as a signal handler does.
+     */
+    private runUpdate;
+    private completeUpdate;
+    /** Reject the updates of this activation that no handler took (`UpdateNotHandled`). */
+    private rejectUnhandledUpdates;
+    handleUpdate(update: UpdateDefinition<unknown, unknown> | string, handler: (args: unknown) => unknown, options?: UpdateHandlerOptions<unknown>): void;
+    setDefaultUpdateHandler(first: ((name: string, args: unknown) => unknown) | DefaultUpdateHandlerOptions, second?: ((name: string, args: unknown) => unknown) | DefaultUpdateHandlerOptions): void;
+    private dispatchBufferedUpdates;
+    handleQuery(query: QueryDefinition<unknown, unknown> | string, handler: (args: unknown) => unknown): void;
+    setDefaultQueryHandler(handler: (name: string, args: unknown) => unknown): void;
+    /**
+     * The drain check of 11 §2.18 when the workflow finishes: handlers still
+     * running with policy `WARN_AND_ABANDON` give one warning line and
+     * `unfinishedHandlers` in the result. A replay never reports them.
+     */
+    private checkUnfinishedHandlers;
     private startFunction;
     private onReturn;
     private isFailureType;
@@ -227,6 +339,24 @@ declare class WorkflowExecution {
     private stack;
     private never;
     scheduleActivity<In, Out>(scope: Scope, operation: Operation<In, Out>, options: RunOptions<In>): Promise<Out>;
+    /**
+     * `ctx.activity` (Phase C): a user activity on a self-hosted task queue
+     * (`SCHEDULE_ACTIVITY` of kind `user`). The queue is the option, else the
+     * declaration's, else the run's own.
+     */
+    userActivity<In, Out>(scope: Scope, activity: ActivityDefinition<In, Out> | string, options: ActivityOptions<In>): Promise<Out>;
+    /** Run the outbound `scheduleActivity` interceptors, then issue the command. */
+    private issueActivity;
+    private pushActivity;
+    /**
+     * `ctx.localActivity` (11 §2.12). A replayed activation returns the outcome
+     * its history recorded; the open activation takes the outcome the worker
+     * passed in `localActivityResults`, or asks for the local activity
+     * (`localActivityRequested`) and waits for the same task to run again.
+     * Either way the outcome is recorded with `RECORD_LOCAL_ACTIVITY` at the
+     * call, so a replay issues the same command at the same position.
+     */
+    localActivity<In, Out>(scope: Scope, operation: unknown, options: LocalActivityOptions<In> | undefined): Promise<Out>;
     startTimer(scope: Scope, durationMs: number, summary: string | undefined): Promise<void>;
     /** Start a durable timer; `timerId` is undefined when no timer was needed or issued. */
     private timer;
@@ -236,38 +366,71 @@ declare class WorkflowExecution {
     /** Resolve conditions whose predicate now holds; true when any did. */
     private checkConditions;
     signalReceived<P>(scope: Scope, signal: SignalDefinition<P> | string): Promise<P>;
-    onSignal(signal: SignalDefinition<unknown> | string, handler: (payload: unknown) => unknown): void;
+    onSignal(signal: SignalDefinition<unknown> | string, handler: (payload: unknown) => unknown, options?: SignalHandlerOptions): void;
     setDefaultSignalHandler(handler: (name: string, payload: unknown) => unknown): void;
+    /** The command target of a run handle (11 §2.1, §2.24). */
+    externalTarget(target: ExternalRunTarget): RunTarget;
+    runHandle(target: ExternalRunTarget): ExternalRunHandle;
     private childTarget;
     private childCommand;
+    /**
+     * Run the outbound `startChild` interceptors around a child start. `go`
+     * starts the child with the options the interceptors leave (input and
+     * headers).
+     */
+    private interceptChild;
     private startChildRun;
     /** What cancelling the scope of a child's awaitable does (see `ChildOptions.cancellationType`). */
     private onChildCancel;
     child<Out>(scope: Scope, target: ChildTarget<Out>, options: ChildOptions): Promise<Out>;
     private childResult;
     startChild<Out>(scope: Scope, target: ChildTarget<Out>, options: ChildOptions): Promise<ChildHandle<Out>>;
+    private startChildHandle;
     signalExternal(target: RunTarget, name: string, payload: unknown): Promise<void>;
+    private pushSignal;
     cancelExternal(target: RunTarget): Promise<void>;
+    private pushCancel;
     sideEffect<T extends Json>(fn: () => T): T;
+    private recordSideEffect;
     patched(patchId: string, deprecated: boolean): boolean;
     setCurrentDetails(markdown: string): void;
     upsertContext(entries: JsonObject): void;
+    /** `ctx.upsertSearchAttributes` (Phase C): a null value removes an attribute. */
+    upsertSearchAttributes(attributes: JsonObject): void;
+    /** A `ctx.sinks.<sink>.<fn>(...args)` call: recorded once, never on replay (11 §2.31). */
+    private callSink;
+    private sinksProxy;
+    /** `ctx.continueAsNew`: a rejection with the request, after the outbound interceptors. */
+    continueAsNewCall(input: unknown, options: ContinueAsNewOptions): Promise<never>;
     /** The request a `ctx.continueAsNew` call throws; the run ends with `CONTINUE_AS_NEW`. */
     continueAsNew(input: unknown, options: ContinueAsNewOptions): ContinueAsNewRequest;
     cancellationScope<T>(parent: Scope, fn: (ctx: WorkflowContext) => Promise<T>, options: CancellationScopeOptions): Promise<T>;
     /** Waits for the signal handlers regardless of cancellation, as Temporal does. */
     allHandlersFinished(): Promise<void>;
     private pendingStacks;
+    /**
+     * Answer a custom query (Phase C): the handler registered for the name, else
+     * the default handler, run read-only through the inbound `handleQuery`
+     * interceptors. No handler gives `rejected`.
+     */
+    private answerCustomQuery;
     private answerQueries;
     private contextFor;
 }
 
 /** The global a tier-2 bundle defines. */
 declare const RUNTIME_GLOBAL = "__fluidgridsRuntime";
-/** The runtime ABI, protocol 1. */
+/**
+ * The runtime ABI, protocol 1. `capabilities` (C-ABI-H, from C-R1) lists what
+ * the runtime answers beyond Phase B: `updates`, `queries` (custom and default
+ * handlers) and `dynamic` (dynamic workflows and default handlers). A bundle
+ * built before C-R1 has none, and the service refuses updates and custom
+ * queries for its runs (DC4).
+ */
 interface FluidgridsRuntimeAbi {
     readonly protocol: 1;
     readonly sdkVersion: string;
+    readonly capabilities?: readonly string[];
     start(requestJson: string): void;
     step(): 'more' | 'done';
     complete(): string;
@@ -278,6 +441,12 @@ interface WorkflowRegistry {
     exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
     /** Export names declared by more than one module; starting one fails the task. */
     ambiguous: ReadonlySet<string>;
+    /** The bundle's dynamic workflow (Phase C), which serves names no export has. */
+    dynamic?: DurableWorkflow<never, unknown>;
+    /** True when more than one dynamic workflow is exported; a dynamic start fails the task. */
+    dynamicAmbiguous?: boolean;
+    /** Workflow interceptor factories (`interceptors` exports), in module order. */
+    interceptors?: readonly WorkflowInterceptorsFactory[];
 }
 /** Build the registry from the bundle's modules (`[path, namespace]` pairs). */
 declare function buildWorkflowRegistry(modules: ReadonlyArray<readonly [string, Record<string, unknown>]>): WorkflowRegistry;

package/dist/runtime/index.d.ts

@@ -1,7 +1,8 @@
-import { W as WorkflowContext, h as DurableWorkflow, C as CancellationScope, O as Operation, R as RunOptions, j as Duration, l as SignalDefinition, e as ChildTarget, d as ChildOptions, c as ChildHandle, f as ContinueAsNewOptions, b as CancellationScopeOptions } from '../workflow-C2a05WUJ.js';
-export { A as Activation, s as splitActivations } from '../activation-DnhG7SmF.js';
-import { W as WorkflowCommand, U as RunEventRecord, a7 as WorkflowTaskRequest, a8 as WorkflowTaskResult, a as WorkflowTaskFailureCause, X as RunTarget } from '../types-DV-HX_Gt.js';
-import { a as Json, J as JsonObject } from '../types-BGoPzgcl.js';
+import { k as WorkflowInterceptorsFactory } from '../interceptors-CNcr2dlk.js';
+import { W as WorkflowContext, v as DurableWorkflow, U as UpdateDefinition, K as UpdateHandlerOptions, t as DefaultUpdateHandlerOptions, Q as QueryDefinition, C as CancellationScope, O as Operation, R as RunOptions, e as ActivityDefinition, k as ActivityOptions, z as LocalActivityOptions, x as Duration, G as SignalDefinition, I as SignalHandlerOptions, y as ExternalRunTarget, E as ExternalRunHandle, q as ChildTarget, p as ChildOptions, o as ChildHandle, r as ContinueAsNewOptions, n as CancellationScopeOptions } from '../workflow-BGnv8SS6.js';
+export { A as Activation, s as splitActivations } from '../activation-xpx1oWuo.js';
+import { W as WorkflowCommand, R as RunEventRecord, az as WorkflowTaskRequest, aA as WorkflowTaskResult, a as WorkflowTaskFailureCause, ad as RunTarget, M as Headers } from '../types-DGx-b9eq.js';
+import { a as Json, J as JsonObject } from '../types-V7jEEUaL.js';
 
 /**
  * Determinism shims for workflow tasks (C-ABI, spec 04 §4).
@@ -51,10 +52,12 @@ declare function uuidFrom(random: () => number): string;
 
 /**
  * Replay matching (spec 04 §4): each command a replayed activation issues must
- * match the command event recorded at the same position. Activities match on
- * id and `nodeType + operation`, children on id and target, everything else on
- * type and id. A recorded patch marker that the code no longer issues is
- * skipped (the patch was deprecated and removed, spec 06 §4).
+ * match the command event recorded at the same position. Node activities
+ * match on id and `nodeType + operation`, user activities (Phase C) on id,
+ * `kind` and `activityName`, children on id and target, updates on id,
+ * everything else on type and id. A recorded patch marker that the code no
+ * longer issues is skipped (the patch was deprecated and removed, spec 06 §4).
+ * `REJECT_UPDATE` appends no event (11 §2.39), so it is not matched.
  */
 
 /** Why `command` does not match `event`, or undefined when it does. */
@@ -71,9 +74,10 @@ declare function matchActivation(commands: readonly WorkflowCommand[], recorded:
 /**
  * Command ids (C-HIST): one counter per kind, in issue order, so a replay that
  * issues the same commands in the same order derives the same ids, and a
- * reordered await is caught as a mismatch. Patch markers use `patch:<id>`.
+ * reordered await is caught as a mismatch. Patch markers use `patch:<id>`;
+ * local activities (R2) use `l<n>`.
  */
-type CommandIdKind = 'a' | 't' | 'c' | 's' | 'x' | 'm';
+type CommandIdKind = 'a' | 't' | 'c' | 's' | 'x' | 'm' | 'l';
 declare class CommandIds {
     private readonly counters;
     /** The next id of a kind: `a1`, `a2`, ... */
@@ -96,6 +100,14 @@ declare function isPatchMarkerId(markerId: string): boolean;
  * finishes it: a replayed activation must have issued exactly the commands it
  * recorded, and the open activation's commands are the task's result.
  *
+ * Updates (C-ABI-H, spec 04 §2): the updates of activation k are delivered
+ * after its input events. A replayed activation re-delivers the updates its
+ * task accepted (`UPDATE_ACCEPTED` in its command block) without running
+ * their validators; the open activation delivers the lease's pending updates
+ * (`request.updates`) with validation. `UPDATE_ADMITTED` is an input event and
+ * is validated like a live request. An update no handler takes by the end of
+ * its activation is rejected (`UpdateNotHandled`).
+ *
  * Pure JavaScript; it runs inside the isolate.
  */
 
@@ -105,7 +117,8 @@ declare const SDK_NAME = "@fluidgrids/workflows";
 declare class ContinueAsNewRequest {
     readonly input: Json;
     readonly options: JsonObject;
-    constructor(input: Json, options: JsonObject);
+    readonly headers: Headers;
+    constructor(input: Json, options: JsonObject, headers?: Headers);
 }
 declare class Scope implements CancellationScope {
     readonly parent: Scope | undefined;
@@ -132,6 +145,8 @@ interface ExecutionInput {
     exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
     request: WorkflowTaskRequest;
     sdkVersion: string;
+    /** The bundle's workflow interceptors (`interceptors` exports), in module order. */
+    interceptors?: readonly WorkflowInterceptorsFactory[];
 }
 /** One workflow task in progress. */
 declare class WorkflowExecution {
@@ -144,7 +159,7 @@ declare class WorkflowExecution {
     private activationOpen;
     private replaying;
     private clock;
-    private readonly random;
+    private readonly randomSource;
     private readonly ids;
     private commands;
     private newCommands;
@@ -183,7 +198,34 @@ declare class WorkflowExecution {
     private readonly signalHandlers;
     private readonly signalWaiters;
     private defaultSignalHandler;
+    private defaultSignalPolicy;
+    private readonly signalPolicies;
     private runningHandlers;
+    /** Running asynchronous handlers by name, for the drain warning (11 §2.18). */
+    private readonly running;
+    private unfinished;
+    /** Updates delivered so far, by id (an update is delivered at most once per task). */
+    private readonly deliveredUpdates;
+    /** Updates delivered in the current activation without a handler yet. */
+    private bufferedUpdates;
+    private readonly updateHandlers;
+    private defaultUpdateHandler;
+    private readonly queryHandlers;
+    private defaultQueryHandler;
+    /** Set while a query handler or an update validator runs: commands and sinks throw. */
+    private readOnly;
+    /** The first state-changing call a read-only handler made, even when it caught the error. */
+    private readOnlyViolation;
+    private searchAttributes;
+    private readonly startHeaders;
+    private readonly inbound;
+    private readonly outbound;
+    private sinkCalls;
+    private sinkCallsDropped;
+    private readonly recordedLocalActivities;
+    private readonly localActivityResults;
+    private readonly localActivities;
+    private memo;
     private conditions;
     private currentDetails;
     readonly context: WorkflowContext;
@@ -192,23 +234,93 @@ declare class WorkflowExecution {
     private continueAsNewSuggested;
     /** The workflow clock. */
     now(): number;
-    /** The next deterministic random number. */
+    /** The next deterministic random number (`Math.random()` and `crypto.getRandomValues()`). */
     nextRandom(): number;
+    /** `ctx.random()`: advances the run's random source, so read-only handlers may not call it. */
+    private random;
+    /**
+     * Throw `QueryHandlerSideEffect` when a query handler or an update validator
+     * calls something that changes the run's deterministic state (the random
+     * source, the command id counters, patches, details). Validators are not run
+     * again on replay, and a worker that keeps a run's state between tasks keeps
+     * whatever a query handler changed, so either would make the next replay
+     * diverge. The violation is remembered, so catching the error does not hide it.
+     */
+    private assertWritable;
+    /** The next command id of a kind; refused in read-only handlers (it advances a counter). */
+    private nextId;
     /** Begin or finish an activation; `done` when there is nothing left to do. */
     step(): 'more' | 'done';
     /** The task's result. Call after `step()` returned `done` and jobs were drained. */
     complete(): WorkflowTaskResult;
+    /**
+     * The local activities the open activation waits for, when the task is a
+     * workflow task that has not failed or closed the run (a run that ends
+     * abandons a local activity it did not await).
+     */
+    private pendingLocalActivityRequests;
     /** Fail the task (the runtime's own failures and code errors). */
     failTask(cause: WorkflowTaskFailureCause, message: string, stackTrace?: string, seq?: number, errorType?: string): void;
     private beginActivation;
+    /**
+     * The updates an activation delivers after its inputs (C-ABI-H): a replayed
+     * activation re-delivers the updates its task accepted (validators
+     * skipped); the open activation of a workflow task delivers the lease's
+     * pending updates. Updates history admitted (`UPDATE_ADMITTED`) arrive as
+     * inputs instead.
+     */
+    private updatesOf;
     private finishActivation;
+    /**
+     * A local activity issued on a replayed activation without a recorded
+     * outcome is fine only when the first execution dropped it in that same
+     * activation: its scope was cancelled (the entry is gone) or the run closed.
+     * One still waiting means the first execution would have requested and
+     * recorded it, so the code diverged from the history.
+     */
+    private checkReplayedLocalActivities;
     private deliver;
     private expectIssued;
     private settleActivity;
     private settleChild;
+    /** Run a signal handler through the inbound `handleSignal` interceptors. */
+    private signalCall;
     private dispatchSignal;
     private takeBuffered;
     private runHandler;
+    /** Count a running asynchronous handler (drain check, `allHandlersFinished`); returns its end. */
+    private trackHandler;
+    private deliverUpdate;
+    private updateHandlerFor;
+    /**
+     * Run `fn` with commands, sinks and every other change to the run's
+     * deterministic state refused (query handlers, update validators). A
+     * refused call fails the whole call with `QueryHandlerSideEffect`, even
+     * when the code caught the error it threw.
+     */
+    private readOnlyCall;
+    /**
+     * Validate, accept and run one update. A validator error rejects it
+     * (`REJECT_UPDATE`, no history); otherwise `ACCEPT_UPDATE` is issued and
+     * the handler's result or failure completes it (`COMPLETE_UPDATE`). A
+     * handler that throws something other than a failure class fails the task,
+     * as a signal handler does.
+     */
+    private runUpdate;
+    private completeUpdate;
+    /** Reject the updates of this activation that no handler took (`UpdateNotHandled`). */
+    private rejectUnhandledUpdates;
+    handleUpdate(update: UpdateDefinition<unknown, unknown> | string, handler: (args: unknown) => unknown, options?: UpdateHandlerOptions<unknown>): void;
+    setDefaultUpdateHandler(first: ((name: string, args: unknown) => unknown) | DefaultUpdateHandlerOptions, second?: ((name: string, args: unknown) => unknown) | DefaultUpdateHandlerOptions): void;
+    private dispatchBufferedUpdates;
+    handleQuery(query: QueryDefinition<unknown, unknown> | string, handler: (args: unknown) => unknown): void;
+    setDefaultQueryHandler(handler: (name: string, args: unknown) => unknown): void;
+    /**
+     * The drain check of 11 §2.18 when the workflow finishes: handlers still
+     * running with policy `WARN_AND_ABANDON` give one warning line and
+     * `unfinishedHandlers` in the result. A replay never reports them.
+     */
+    private checkUnfinishedHandlers;
     private startFunction;
     private onReturn;
     private isFailureType;
@@ -227,6 +339,24 @@ declare class WorkflowExecution {
     private stack;
     private never;
     scheduleActivity<In, Out>(scope: Scope, operation: Operation<In, Out>, options: RunOptions<In>): Promise<Out>;
+    /**
+     * `ctx.activity` (Phase C): a user activity on a self-hosted task queue
+     * (`SCHEDULE_ACTIVITY` of kind `user`). The queue is the option, else the
+     * declaration's, else the run's own.
+     */
+    userActivity<In, Out>(scope: Scope, activity: ActivityDefinition<In, Out> | string, options: ActivityOptions<In>): Promise<Out>;
+    /** Run the outbound `scheduleActivity` interceptors, then issue the command. */
+    private issueActivity;
+    private pushActivity;
+    /**
+     * `ctx.localActivity` (11 §2.12). A replayed activation returns the outcome
+     * its history recorded; the open activation takes the outcome the worker
+     * passed in `localActivityResults`, or asks for the local activity
+     * (`localActivityRequested`) and waits for the same task to run again.
+     * Either way the outcome is recorded with `RECORD_LOCAL_ACTIVITY` at the
+     * call, so a replay issues the same command at the same position.
+     */
+    localActivity<In, Out>(scope: Scope, operation: unknown, options: LocalActivityOptions<In> | undefined): Promise<Out>;
     startTimer(scope: Scope, durationMs: number, summary: string | undefined): Promise<void>;
     /** Start a durable timer; `timerId` is undefined when no timer was needed or issued. */
     private timer;
@@ -236,38 +366,71 @@ declare class WorkflowExecution {
     /** Resolve conditions whose predicate now holds; true when any did. */
     private checkConditions;
     signalReceived<P>(scope: Scope, signal: SignalDefinition<P> | string): Promise<P>;
-    onSignal(signal: SignalDefinition<unknown> | string, handler: (payload: unknown) => unknown): void;
+    onSignal(signal: SignalDefinition<unknown> | string, handler: (payload: unknown) => unknown, options?: SignalHandlerOptions): void;
     setDefaultSignalHandler(handler: (name: string, payload: unknown) => unknown): void;
+    /** The command target of a run handle (11 §2.1, §2.24). */
+    externalTarget(target: ExternalRunTarget): RunTarget;
+    runHandle(target: ExternalRunTarget): ExternalRunHandle;
     private childTarget;
     private childCommand;
+    /**
+     * Run the outbound `startChild` interceptors around a child start. `go`
+     * starts the child with the options the interceptors leave (input and
+     * headers).
+     */
+    private interceptChild;
     private startChildRun;
     /** What cancelling the scope of a child's awaitable does (see `ChildOptions.cancellationType`). */
     private onChildCancel;
     child<Out>(scope: Scope, target: ChildTarget<Out>, options: ChildOptions): Promise<Out>;
     private childResult;
     startChild<Out>(scope: Scope, target: ChildTarget<Out>, options: ChildOptions): Promise<ChildHandle<Out>>;
+    private startChildHandle;
     signalExternal(target: RunTarget, name: string, payload: unknown): Promise<void>;
+    private pushSignal;
     cancelExternal(target: RunTarget): Promise<void>;
+    private pushCancel;
     sideEffect<T extends Json>(fn: () => T): T;
+    private recordSideEffect;
     patched(patchId: string, deprecated: boolean): boolean;
     setCurrentDetails(markdown: string): void;
     upsertContext(entries: JsonObject): void;
+    /** `ctx.upsertSearchAttributes` (Phase C): a null value removes an attribute. */
+    upsertSearchAttributes(attributes: JsonObject): void;
+    /** A `ctx.sinks.<sink>.<fn>(...args)` call: recorded once, never on replay (11 §2.31). */
+    private callSink;
+    private sinksProxy;
+    /** `ctx.continueAsNew`: a rejection with the request, after the outbound interceptors. */
+    continueAsNewCall(input: unknown, options: ContinueAsNewOptions): Promise<never>;
     /** The request a `ctx.continueAsNew` call throws; the run ends with `CONTINUE_AS_NEW`. */
     continueAsNew(input: unknown, options: ContinueAsNewOptions): ContinueAsNewRequest;
     cancellationScope<T>(parent: Scope, fn: (ctx: WorkflowContext) => Promise<T>, options: CancellationScopeOptions): Promise<T>;
     /** Waits for the signal handlers regardless of cancellation, as Temporal does. */
     allHandlersFinished(): Promise<void>;
     private pendingStacks;
+    /**
+     * Answer a custom query (Phase C): the handler registered for the name, else
+     * the default handler, run read-only through the inbound `handleQuery`
+     * interceptors. No handler gives `rejected`.
+     */
+    private answerCustomQuery;
     private answerQueries;
     private contextFor;
 }
 
 /** The global a tier-2 bundle defines. */
 declare const RUNTIME_GLOBAL = "__fluidgridsRuntime";
-/** The runtime ABI, protocol 1. */
+/**
+ * The runtime ABI, protocol 1. `capabilities` (C-ABI-H, from C-R1) lists what
+ * the runtime answers beyond Phase B: `updates`, `queries` (custom and default
+ * handlers) and `dynamic` (dynamic workflows and default handlers). A bundle
+ * built before C-R1 has none, and the service refuses updates and custom
+ * queries for its runs (DC4).
+ */
 interface FluidgridsRuntimeAbi {
     readonly protocol: 1;
     readonly sdkVersion: string;
+    readonly capabilities?: readonly string[];
     start(requestJson: string): void;
     step(): 'more' | 'done';
     complete(): string;
@@ -278,6 +441,12 @@ interface WorkflowRegistry {
     exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
     /** Export names declared by more than one module; starting one fails the task. */
     ambiguous: ReadonlySet<string>;
+    /** The bundle's dynamic workflow (Phase C), which serves names no export has. */
+    dynamic?: DurableWorkflow<never, unknown>;
+    /** True when more than one dynamic workflow is exported; a dynamic start fails the task. */
+    dynamicAmbiguous?: boolean;
+    /** Workflow interceptor factories (`interceptors` exports), in module order. */
+    interceptors?: readonly WorkflowInterceptorsFactory[];
 }
 /** Build the registry from the bundle's modules (`[path, namespace]` pairs). */
 declare function buildWorkflowRegistry(modules: ReadonlyArray<readonly [string, Record<string, unknown>]>): WorkflowRegistry;