@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/history/index.d.cts

@@ -1,9 +1,520 @@
-import { W as WorkflowCommand, a as WorkflowTaskFailureCause, R as RetryPolicy, F as Failure, C as ChildCancellationType, P as ParentClosePolicy } from '../types-CpBBjaGX.cjs';
-export { A as ACTIVITY_CANCELLATION_TYPES, b as AcceptUpdateCommand, c as ActivityCancellationType, B as BUILT_IN_QUERIES, d as BuiltInQueryName, e as CHILD_CANCELLATION_TYPES, f as COMMAND_EVENTS, g as COMMAND_EVENT_TYPES, h as COMMAND_TYPES, i as CONTINUE_AS_NEW_SUGGESTED_RATIO, j as CancelTimerCommand, k as CancelWorkflowCommand, l as ChildRunOptions, m as CommandType, n as CompleteUpdateCommand, o as CompleteWorkflowCommand, p as ContinueAsNewCommand, D as DEFAULT_HISTORY_LIMIT, E as ERROR_TYPES, q as EVENT_TYPES, r as EXECUTION_KINDS, s as ExecutionKind, t as FailWorkflowCommand, u as FailureSource, H as HISTORY_LIMIT_EXCEEDED_RATIO, v as HISTORY_PROTOCOL, w as Headers, x as HistoryLimit, I as INPUT_EVENTS, L as LocalActivityRequest, y as PARENT_CLOSE_POLICIES, z as PHASE_B_CORE_COMMANDS, G as PHASE_B_PARITY_COMMANDS, J as PHASE_C_COMMANDS, K as RecordLocalActivityCommand, M as RecordMarkerCommand, N as RecordSideEffectCommand, O as RejectUpdateCommand, Q as RequestCancelActivityCommand, S as RequestCancelExternalRunCommand, T as RunEventDraft, U as RunEventRecord, V as RunEventType, X as RunTarget, Y as ScheduleActivityCommand, Z as SignalRunCommand, _ as StartChildRunCommand, $ as StartTimerCommand, a0 as TASK_FAILURE_CAUSES, a1 as TERMINAL_COMMANDS, a2 as TERMINAL_EVENTS, a3 as TaskLogLine, a4 as UpsertContextCommand, a5 as UpsertSearchAttributesCommand, a6 as WorkflowInfoSnapshot, a7 as WorkflowTaskRequest, a8 as WorkflowTaskResult, a9 as isCommandEvent, aa as isInputEvent } from '../types-CpBBjaGX.cjs';
-import { H as HistoryIssue } from '../file-BOoHZgoQ.cjs';
-export { A as ActivityState, a as ActivityStatus, C as ChildState, b as ChildStatus, E as EventsForCommandsContext, c as EventsForCommandsResult, d as ExternalState, e as HISTORY_FILE_FORMAT, f as HISTORY_FILE_SCHEMA, g as HISTORY_FILE_SCHEMA_ID, h as HISTORY_SCHEMA_FILES, i as HistoryFile, j as HistoryFileError, k as HistoryStateError, R as RUN_EVENT_SCHEMA, l as RUN_EVENT_SCHEMA_ID, m as RunState, n as RunStatus, T as TimerState, W as WORKFLOW_COMMAND_SCHEMA, o as WORKFLOW_COMMAND_SCHEMA_ID, p as WORKFLOW_TASK_SCHEMA, q as WORKFLOW_TASK_SCHEMA_ID, r as applyEvent, s as createHistoryFile, t as eventsForCommands, u as hasUnprocessedInput, v as initialRunState, w as isActivityOpen, x as isChildOpen, y as isCommandEnabled, z as isWorkflowCommandEnabled, B as parseHistoryFile, D as pendingCounts, F as projectRunState, G as serializeHistoryFile, I as taskCompletedEvents, J as utf8Bytes } from '../file-BOoHZgoQ.cjs';
-export { A as Activation, s as splitActivations, u as unseenInputs } from '../activation-BBh1p82z.cjs';
-import '../types-BGoPzgcl.cjs';
+import { W as WorkflowCommand, T as TaskLogLine, Q as QueryResult, U as UnfinishedHandler, a as WorkflowTaskFailureCause, F as Failure, b as WorkflowInfoSnapshot, c as UpdateRequest, d as QueryRequest, R as RunEventRecord, e as RetryPolicy, f as RunRetryPolicy, C as ChildCancellationType, P as ParentClosePolicy } from '../types-Bv2i4cBX.cjs';
+export { A as ACTIVITY_CANCELLATION_TYPES, g as ACTIVITY_NAME_PATTERN, h as AcceptUpdateCommand, i as ActivityCancellationType, B as BUILT_IN_QUERIES, j as BuiltInQueryName, k as CHILD_CANCELLATION_TYPES, l as COMMAND_EVENTS, m as COMMAND_EVENT_TYPES, n as COMMAND_TYPES, o as CONTINUE_AS_NEW_SUGGESTED_RATIO, p as CancelTimerCommand, q as CancelWorkflowCommand, r as ChildRunOptions, s as CommandType, t as CompleteUpdateCommand, u as CompleteWorkflowCommand, v as ContinueAsNewCommand, D as DEFAULT_HISTORY_LIMIT, E as ERROR_TYPES, w as EVENT_TYPES, x as EXECUTION_KINDS, y as ExecutionKind, z as FAIRNESS_KEY_MAX_LENGTH, G as FAIRNESS_WEIGHT_MAX, H as FAIRNESS_WEIGHT_MIN, I as FailWorkflowCommand, J as FailureSource, K as HISTORY_LIMIT_EXCEEDED_RATIO, L as HISTORY_PROTOCOL, M as Headers, N as HistoryLimit, O as INPUT_EVENTS, S as LOCAL_ACTIVITY_MAX_TIMEOUT_MS, V as LocalActivityRequest, X as LocalActivityResult, Y as MAX_ACTIVITY_CONNECTIONS, Z as MAX_HEADERS_BYTES, _ as MAX_SINK_CALLS, $ as PARENT_CLOSE_POLICIES, a0 as PHASE_B_CORE_COMMANDS, a1 as PHASE_B_PARITY_COMMANDS, a2 as PHASE_C_COMMANDS, a3 as RUNTIME_CAPABILITIES, a4 as RUNTIME_RELEASE, a5 as RecordLocalActivityCommand, a6 as RecordMarkerCommand, a7 as RecordSideEffectCommand, a8 as RejectUpdateCommand, a9 as RequestCancelActivityCommand, aa as RequestCancelExternalRunCommand, ab as RunEventDraft, ac as RunEventType, ad as RunTarget, ae as RuntimeCapability, af as ScheduleActivityCommand, ag as ScheduleNodeActivityCommand, ah as ScheduleUserActivityCommand, ai as SignalRunCommand, aj as SinkCall, ak as StartChildRunCommand, al as StartTimerCommand, am as TASK_FAILURE_CAUSES, an as TASK_QUEUE_NAME_PATTERN, ao as TERMINAL_COMMANDS, ap as TERMINAL_EVENTS, aq as UpsertContextCommand, ar as UpsertSearchAttributesCommand, as as VERSIONING_BEHAVIORS, at as VersioningBehavior, au as WORKFLOW_ID_CONFLICT_POLICIES, av as WORKFLOW_ID_REUSE_POLICIES, aw as WORKFLOW_TIMEOUT_TYPES, ax as WorkflowIdConflictPolicy, ay as WorkflowIdReusePolicy, az as WorkflowTaskRequest, aA as WorkflowTaskResult, aB as WorkflowTimeoutType, aC as WorkflowTimeouts, aD as isCommandEvent, aE as isInputEvent } from '../types-Bv2i4cBX.cjs';
+import { H as HistoryIssue, C as CommandGate, a as CommandRelief } from '../file-BxYpwjRQ.cjs';
+export { A as ActivityState, b as ActivityStatus, c as CODE_FEATURE_FLAGS, d as COMMAND_FEATURES, e as CORE_CAN_OPTIONS, f as CORE_CHILD_OPTIONS, g as ChildState, h as ChildStatus, i as CommandFeature, E as EventsForCommandsContext, j as EventsForCommandsResult, k as ExternalState, l as HISTORY_FILE_FORMAT, m as HISTORY_FILE_SCHEMA, n as HISTORY_FILE_SCHEMA_ID, o as HISTORY_SCHEMA_FILES, p as HistoryFile, q as HistoryFileError, r as HistoryStateError, L as LocalActivityState, P as PHASE_B_CORE_FEATURES, s as PHASE_B_PARITY_FEATURES, t as PHASE_C_CODE_FEATURES, u as PHASE_C_FEATURES, v as PHASE_C_FEATURE_FLAGS, R as RUN_EVENT_SCHEMA, w as RUN_EVENT_SCHEMA_ID, x as RunState, y as RunStatus, T as TimerState, U as UpdateState, W as WORKFLOW_COMMAND_SCHEMA, z as WORKFLOW_COMMAND_SCHEMA_ID, B as WORKFLOW_TASK_SCHEMA, D as WORKFLOW_TASK_SCHEMA_ID, F as applyEvent, G as codeFeaturesEnabledBy, I as commandFeatures, J as continueAsNewRetryShape, K as createHistoryFile, M as eventsForCommands, N as hasUnprocessedInput, O as initialRunState, Q as isActivityOpen, S as isChildOpen, V as isCommandEnabled, X as isReliefCommand, Y as isWorkflowCommandEnabled, Z as mergeSearchAttributes, _ as parseHistoryFile, $ as pendingCounts, a0 as projectRunState, a1 as serializeHistoryFile, a2 as taskCompletedEvents, a3 as unsupportedMessage, a4 as utf8Bytes } from '../file-BxYpwjRQ.cjs';
+import { J as JsonObject, a as Json } from '../types-V7jEEUaL.cjs';
+export { C as COMMAND_FAILURE_FIELDS, a as COMMAND_PAYLOAD_FIELDS, E as ENCODED_PAYLOAD_MARKER, b as ENCODED_PAYLOAD_VERSION, c as EncodedPayload, F as FAILURE_CAUSE_FIELD, d as FAILURE_FIELDS, e as FAILURE_PAYLOAD_FIELDS, K as KnownPayloadEncoding, P as PAYLOAD_ENCODINGS, f as PAYLOAD_FIELDS, g as PAYLOAD_FIELDS_DOCUMENT, h as PAYLOAD_FIELDS_FORMAT, i as isEncodedPayload, m as mapCommandPayloads, j as mapEventPayloads, k as mapPayloadFields, p as payloadEncodingOf } from '../payload-fields-BVRQn2yH.cjs';
+export { A as Activation, s as splitActivations, u as unseenInputs } from '../activation-DqUfpHzk.cjs';
+
+/**
+ * The worker bridge, protocol 2 (C-BRIDGE v2, PLAN-C §3.4): the frames a
+ * self-hosted worker and wspace-sandbox-svc exchange over `/runner-bridge`.
+ *
+ * sandbox-svc `src/modules/sandbox/workers/workerProtocol.ts` is the canonical
+ * copy; this one (and the Python SDK's `fluidgrids_workflows/worker/protocol.py`)
+ * mirrors it, and all three are tested against `schema/bridge-v2.schema.json`,
+ * generated from {@link BRIDGE_V2_SCHEMA}. Change the shapes only additively
+ * and in all three places.
+ *
+ * Transport (unchanged from v1): an outbound WebSocket to `/runner-bridge`
+ * with `Authorization: Bearer fgr_…`, JSON text frames, a ping every 20 s, a
+ * 65 s idle timeout and a 10 MiB frame cap. A `hello` with `protocol: 2` and
+ * `kind: 'worker'` selects v2 and needs a token of kind WORKER (otherwise the
+ * socket closes with {@link BridgeCloseCode.ProtocolError}).
+ */
+
+/** The protocol a `hello` names to select the worker bridge. */
+declare const BRIDGE_PROTOCOL_VERSION = 2;
+/** Path of the bridge WebSocket on sandbox-svc and on the public workspace gateway. */
+declare const BRIDGE_PATH = "/runner-bridge";
+/** How often a worker sends `ping`. */
+declare const BRIDGE_PING_SECONDS = 20;
+/** How often a worker sends `workerHeartbeat`. */
+declare const BRIDGE_WORKER_HEARTBEAT_SECONDS = 30;
+/** No frame for this long and the connection is treated as dead. */
+declare const BRIDGE_IDLE_TIMEOUT_MS = 65000;
+/** The largest frame. */
+declare const BRIDGE_MAX_FRAME_BYTES: number;
+/** The largest history tail a workflow `task` frame carries; the rest is paged with `history.page`. */
+declare const BRIDGE_MAX_HISTORY_TAIL_BYTES: number;
+/** WebSocket close codes (4000-4999 are application-defined); 4001-4009 are v1's. */
+declare const BridgeCloseCode: {
+    readonly Unauthorized: 4001;
+    readonly Revoked: 4002;
+    readonly Replaced: 4003;
+    /** Also a v2 hello on a RUNNER token, or a v1 hello on a WORKER token. */
+    readonly ProtocolError: 4004;
+    readonly IdleTimeout: 4008;
+    /** The service is shutting down, or `WORKER_BRIDGE_ENABLED` is off. */
+    readonly ShuttingDown: 4009;
+    /** The workspace has no free worker seat (`fluidgrids.workers.count`). */
+    readonly QuotaExceeded: 4010;
+    /** The token does not allow a task queue the hello names. */
+    readonly QueueNotAllowed: 4011;
+    /** `fluidgrids.self-hosted-workers` (or a prerequisite) is off for the workspace. */
+    readonly FeatureDisabled: 4012;
+};
+type BridgeCloseCodeValue = (typeof BridgeCloseCode)[keyof typeof BridgeCloseCode];
+/** Methods of a worker `req` frame. */
+declare const BRIDGE_REQUEST_METHODS: readonly ["history.page", "activity.connection"];
+type BridgeRequestMethod = (typeof BRIDGE_REQUEST_METHODS)[number];
+/** Slots of one kind: in use and in total. */
+interface BridgeSlotUsage {
+    used: number;
+    total: number;
+}
+/** A workflow task: one run's workflow task attempt. */
+interface WorkflowTaskRef {
+    kind: 'workflow';
+    runId: string;
+    taskId: string;
+    attempt: number;
+    expectedHistoryLength: number;
+}
+/** A query task of a `determinism: worker` run (CX8). */
+interface QueryTaskRef {
+    kind: 'query';
+    runId: string;
+    queryTaskId: string;
+}
+/** One attempt of an activity. */
+interface ActivityTaskRef {
+    kind: 'activity';
+    runId: string;
+    activityId: string;
+    attempt: number;
+}
+type BridgeTaskRef = WorkflowTaskRef | QueryTaskRef | ActivityTaskRef;
+/** A slice of a run's history, oldest first. */
+interface BridgeHistoryPage {
+    events: RunEventRecord[];
+    /** Seq of the first event in `events` (1 for a full history). */
+    from: number;
+    /** The seq to page after for the next slice, or null at the end. */
+    nextAfter: number | null;
+    hasMore: boolean;
+}
+interface WorkerHelloFrame {
+    type: 'hello';
+    protocol: 2;
+    kind: 'worker';
+    sdk: {
+        language: 'typescript' | 'python';
+        version: string;
+    };
+    /** Default `hostname@pid`. */
+    identity: string;
+    taskQueues: string[];
+    /** Build ids of the workflow bundles the worker can run. */
+    buildIds: string[];
+    /** Workflow function names it registered (`*` for a dynamic workflow). */
+    workflows: string[];
+    /** Activity names it implements (`*` for a dynamic activity). */
+    activities: string[];
+    slots: {
+        workflow: number;
+        activity: number;
+        localActivity: number;
+    };
+    host: {
+        os?: string;
+        arch?: string;
+        hostname?: string;
+        runtime?: string;
+    };
+    /** Payload encodings its codec and converters produce and read. */
+    encodings: string[];
+}
+interface WorkerPingFrame {
+    type: 'ping';
+    t?: number;
+}
+/** How many task requests the worker keeps open, per kind. */
+interface WorkerPollersFrame {
+    type: 'pollers';
+    workflow: number;
+    activity: number;
+}
+interface WorkflowTaskResultFrame {
+    type: 'taskResult';
+    taskRef: WorkflowTaskRef;
+    commands: WorkflowCommand[];
+    logs: TaskLogLine[];
+    /** The history length the worker's sticky cache holds for the run after this task. */
+    cachedUpTo: number;
+    queryResults?: QueryResult[];
+    unfinishedHandlers?: UnfinishedHandler[];
+}
+interface ActivityTaskResultFrame {
+    type: 'taskResult';
+    taskRef: ActivityTaskRef;
+    result: Json;
+}
+interface QueryTaskResultFrame {
+    type: 'taskResult';
+    taskRef: QueryTaskRef;
+    queryResults: QueryResult[];
+}
+type TaskResultFrame = WorkflowTaskResultFrame | ActivityTaskResultFrame | QueryTaskResultFrame;
+/** Why a workflow task failed (the task result's failure). */
+interface WorkflowTaskFailure {
+    cause: WorkflowTaskFailureCause;
+    message: string;
+    stackTrace?: string;
+    seq?: number;
+    errorType?: string;
+}
+type TaskFailedFrame = {
+    type: 'taskFailed';
+    taskRef: WorkflowTaskRef | QueryTaskRef;
+    failure: WorkflowTaskFailure;
+} | {
+    type: 'taskFailed';
+    taskRef: ActivityTaskRef;
+    failure: Failure;
+};
+interface WorkerActivityHeartbeatFrame {
+    type: 'heartbeat';
+    reqId: string;
+    taskRef: ActivityTaskRef;
+    details?: Json;
+}
+interface WorkerHeartbeatFrame {
+    type: 'workerHeartbeat';
+    slots: {
+        workflow: BridgeSlotUsage;
+        activity: BridgeSlotUsage;
+        localActivity: BridgeSlotUsage;
+    };
+    pollers: {
+        workflow: number;
+        activity: number;
+    };
+    tasksInFlight: number;
+    cachedRuns: number;
+}
+interface WorkerRequestFrame {
+    type: 'req';
+    id: string;
+    method: BridgeRequestMethod;
+    params: JsonObject;
+}
+interface WorkerByeFrame {
+    type: 'bye';
+    reason: string;
+}
+type WorkerFrame = WorkerHelloFrame | WorkerPingFrame | WorkerPollersFrame | TaskResultFrame | TaskFailedFrame | WorkerActivityHeartbeatFrame | WorkerHeartbeatFrame | WorkerRequestFrame | WorkerByeFrame;
+interface BridgeWelcomeFrame {
+    type: 'welcome';
+    protocol: 2;
+    sessionId: string;
+    /** `worker:<sessionId>`. */
+    workerId: string;
+    workspaceId: string;
+    heartbeatSeconds: number;
+    workerHeartbeatSeconds: number;
+    maxFrameBytes: number;
+}
+interface WorkflowTaskFrame {
+    type: 'task';
+    taskRef: WorkflowTaskRef;
+    /** The workflow task lease (`WorkflowTaskLease`), JSON. */
+    lease: JsonObject;
+    request: {
+        workflowFn: string;
+        info: WorkflowInfoSnapshot;
+        nowMs: number;
+        updates?: UpdateRequest[];
+        queries?: QueryRequest[];
+    };
+    history: BridgeHistoryPage;
+}
+interface QueryTaskFrame {
+    type: 'task';
+    taskRef: QueryTaskRef;
+    request: {
+        workflowFn: string;
+        info: WorkflowInfoSnapshot;
+        queries: QueryRequest[];
+    };
+    history: BridgeHistoryPage;
+}
+interface ActivityTaskFrame {
+    type: 'task';
+    taskRef: ActivityTaskRef;
+    /** The activity lease (`WorkflowActivityLease`), JSON. */
+    lease: JsonObject;
+}
+type BridgeTaskFrame = WorkflowTaskFrame | QueryTaskFrame | ActivityTaskFrame;
+interface BridgeHeartbeatAckFrame {
+    type: 'heartbeatAck';
+    reqId: string;
+    cancelRequested: boolean;
+    paused: boolean;
+    pauseReason?: string;
+}
+interface BridgeCancelFrame {
+    type: 'cancel';
+    taskRef: BridgeTaskRef;
+    reason: string;
+}
+interface BridgeResponseFrame {
+    type: 'res';
+    id: string;
+    ok: boolean;
+    result?: Json;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface BridgePongFrame {
+    type: 'pong';
+    t?: number;
+}
+type ServiceFrame = BridgeWelcomeFrame | BridgeTaskFrame | BridgeHeartbeatAckFrame | BridgeCancelFrame | BridgeResponseFrame | BridgePongFrame;
+type BridgeFrame = WorkerFrame | ServiceFrame;
+/**
+ * The JSON Schema of every bridge v2 frame (draft 2020-12). Commands, events,
+ * failures, the task info and query results are kept open here (`object`);
+ * their own schemas (`workflow-command`, `run-event`, `workflow-task`) check
+ * them.
+ */
+declare const BRIDGE_V2_SCHEMA_ID = "https://docs.fluidgrids.ai/schemas/bridge-v2.schema.json";
+declare const BRIDGE_V2_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://docs.fluidgrids.ai/schemas/bridge-v2.schema.json";
+    readonly title: "FluidGrids worker bridge, protocol 2";
+    readonly description: "Frames between a self-hosted worker and wspace-sandbox-svc over /runner-bridge (JSON text frames, Bearer fgr_ token of kind WORKER, ping every 20 s, 65 s idle timeout, 10 MiB frame cap). Close codes: 4001 Unauthorized, 4002 Revoked, 4003 Replaced, 4004 ProtocolError, 4008 IdleTimeout, 4009 ShuttingDown, 4010 QuotaExceeded, 4011 QueueNotAllowed, 4012 FeatureDisabled.";
+    readonly oneOf: readonly [{
+        readonly $ref: "#/$defs/workerFrame";
+    }, {
+        readonly $ref: "#/$defs/serviceFrame";
+    }];
+    readonly $defs: {
+        readonly workflowTaskRef: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "runId", "taskId", "attempt", "expectedHistoryLength"];
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "workflow";
+                };
+                readonly runId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly taskId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly attempt: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly expectedHistoryLength: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly queryTaskRef: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "runId", "queryTaskId"];
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "query";
+                };
+                readonly runId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly queryTaskId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly activityTaskRef: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "runId", "activityId", "attempt"];
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "activity";
+                };
+                readonly runId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly activityId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly attempt: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly taskRef: {
+            readonly oneOf: readonly [{
+                readonly $ref: "#/$defs/workflowTaskRef";
+            }, {
+                readonly $ref: "#/$defs/queryTaskRef";
+            }, {
+                readonly $ref: "#/$defs/activityTaskRef";
+            }];
+        };
+        readonly historyPage: {
+            readonly type: "object";
+            readonly required: readonly ["events", "from", "nextAfter", "hasMore"];
+            readonly properties: {
+                readonly events: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly from: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly nextAfter: {
+                    readonly oneOf: readonly [{
+                        readonly type: "null";
+                    }, {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    }];
+                };
+                readonly hasMore: {
+                    readonly type: "boolean";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly queryRequests: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["queryId", "name"];
+                readonly properties: {
+                    readonly queryId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
+                    readonly args: {};
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly queryResults: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["queryId"];
+                readonly properties: {
+                    readonly queryId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
+                    readonly value: {};
+                    readonly error: {
+                        readonly type: "string";
+                    };
+                    readonly rejected: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly hello: Record<string, unknown>;
+        readonly ping: Record<string, unknown>;
+        readonly pollers: Record<string, unknown>;
+        readonly taskResult: {
+            readonly oneOf: readonly [Record<string, unknown>, Record<string, unknown>, Record<string, unknown>];
+        };
+        readonly taskFailed: {
+            readonly oneOf: readonly [Record<string, unknown>, Record<string, unknown>];
+        };
+        readonly heartbeat: Record<string, unknown>;
+        readonly workerHeartbeat: Record<string, unknown>;
+        readonly req: Record<string, unknown>;
+        readonly bye: Record<string, unknown>;
+        readonly welcome: Record<string, unknown>;
+        readonly task: {
+            readonly oneOf: readonly [Record<string, unknown>, Record<string, unknown>, Record<string, unknown>];
+        };
+        readonly heartbeatAck: Record<string, unknown>;
+        readonly cancel: Record<string, unknown>;
+        readonly res: {
+            readonly if: {
+                readonly properties: {
+                    readonly ok: {
+                        readonly const: false;
+                    };
+                };
+                readonly required: readonly ["ok"];
+            };
+            readonly then: {
+                readonly required: readonly ["error"];
+            };
+        };
+        readonly pong: Record<string, unknown>;
+        readonly workerFrame: {
+            readonly oneOf: readonly [{
+                readonly $ref: "#/$defs/hello";
+            }, {
+                readonly $ref: "#/$defs/ping";
+            }, {
+                readonly $ref: "#/$defs/pollers";
+            }, {
+                readonly $ref: "#/$defs/taskResult";
+            }, {
+                readonly $ref: "#/$defs/taskFailed";
+            }, {
+                readonly $ref: "#/$defs/heartbeat";
+            }, {
+                readonly $ref: "#/$defs/workerHeartbeat";
+            }, {
+                readonly $ref: "#/$defs/req";
+            }, {
+                readonly $ref: "#/$defs/bye";
+            }];
+        };
+        readonly serviceFrame: {
+            readonly oneOf: readonly [{
+                readonly $ref: "#/$defs/welcome";
+            }, {
+                readonly $ref: "#/$defs/task";
+            }, {
+                readonly $ref: "#/$defs/heartbeatAck";
+            }, {
+                readonly $ref: "#/$defs/cancel";
+            }, {
+                readonly $ref: "#/$defs/res";
+            }, {
+                readonly $ref: "#/$defs/pong";
+            }];
+        };
+    };
+};
 
 type CommandValidation = {
     ok: true;
@@ -15,10 +526,17 @@ type CommandValidation = {
 };
 interface ValidateCommandsOptions {
     /**
-     * Which commands are enabled. `core` (default) is the Phase B core set,
-     * `parity` adds the parity commands. Phase C commands are always refused.
+     * Which commands are enabled: a feature set (C-GATE), or the R1 release
+     * levels `core` (default, the Phase B core set) and `parity` (adds the
+     * parity commands). With a release level Phase C commands are always
+     * refused; with a feature set the `c.*` features decide.
+     */
+    enabled?: CommandGate;
+    /**
+     * What the lease already granted. A relief command (see `isReliefCommand`)
+     * passes the gate even when its feature is not enabled.
      */
-    enabled?: 'core' | 'parity';
+    relief?: CommandRelief;
     /** Largest batch. Default 1000 (the workers' limit). */
     maxCommands?: number;
 }
@@ -46,6 +564,18 @@ declare function validateHistoryFile(value: unknown): {
     ok: boolean;
     issues: HistoryIssue[];
 };
+/**
+ * Validate one worker bridge frame (protocol 2) against
+ * `bridge-v2.schema.json`. The nested commands, events and failures are
+ * checked by their own schemas.
+ */
+declare function validateBridgeFrame(value: unknown): {
+    ok: true;
+    frame: BridgeFrame;
+} | {
+    ok: false;
+    issues: HistoryIssue[];
+};
 /** A compiled validator for a workflow's input, output, signal or update payload schema. */
 type PayloadValidator = (value: unknown) => {
     ok: true;
@@ -89,6 +619,39 @@ type RetryDecision = {
 declare function computeRetryDelay(policy: RetryPolicy, attempt: number, failure?: Failure): RetryDecision;
 /** A copy of `policy` with the defaults filled in, as the SDK writes it into a command. */
 declare function explicitRetryPolicy(policy: Partial<RetryPolicy> | undefined): RetryPolicy;
+/** Why a run is or is not started again under its run-level retry policy (11 §2.17). */
+type RunRetryDecision = {
+    retry: true;
+    delayMs: number;
+} | {
+    retry: false;
+    reason: 'noPolicy' | 'nonRetryable' | 'executionTimeout' | 'typeDenied' | 'errorTypeNotListed' | 'maxAttempts';
+};
+/**
+ * Whether a DURABLE_FN run whose attempt `attempt` (1-based) just failed, or
+ * timed out (`failure.timeoutType` `WORKFLOW_RUN`), is started again, and
+ * after how long. An execution timeout (`WORKFLOW_EXECUTION`) bounds the whole
+ * chain and is never retried; cancellation and termination never reach this
+ * function. The backoff is the activity backoff over the run policy.
+ */
+declare function computeRunRetryDelay(policy: RunRetryPolicy | undefined, attempt: number, failure: Failure): RunRetryDecision;
+/** The run retry policy with its defaults (Temporal's: 1 s, x2, at most 100 s, unlimited attempts). */
+declare function explicitRunRetryPolicy(policy: Partial<RunRetryPolicy>): RunRetryPolicy;
+
+/**
+ * The bucket of a gradual rollout (11 §2.27): automatic starts hash
+ * `workflowId ?? runId` into 0-99 and take the rollout's `toVersion` when the
+ * bucket is below `percent`. The service's version resolution and the tests
+ * share this function, so a fixed key set splits the same way everywhere.
+ *
+ * Pure JavaScript, no I/O: FNV-1a (32 bit) over the UTF-8 bytes of the key.
+ */
+/** FNV-1a, 32 bit, of the UTF-8 bytes of `key`, as an unsigned integer. */
+declare function fnv1a32(key: string): number;
+/** The rollout bucket of a key: `fnv1a32(key) % 100`, an integer in 0-99. */
+declare function rolloutBucket(key: string): number;
+/** True when a start with this key takes the rollout's target version. */
+declare function inRollout(key: string, percent: number): boolean;
 
 /**
  * The activity allow-list (C-ALLOW): which node types `ctx.run` may schedule.
@@ -114,8 +677,23 @@ declare const ACTIVITY_NODE_ALLOWLIST: {
     /** Non-built-in node types (store and registry nodes) are allowed. */
     readonly external: "allowed";
 };
+/**
+ * Built-in node types that may run as activities only with asynchronous
+ * activity completion (Phase C, H5, `fluidgrids.run-control`): the attempt
+ * parks and a person's answer completes it. `internal:wait` stays refused.
+ */
+declare const ACTIVITY_ASYNC_COMPLETION_ALLOWLIST: ReadonlySet<string>;
+/** Options of {@link isActivityNodeTypeAllowed} and {@link assertActivityNodeType}. */
+interface ActivityNodeTypeOptions {
+    /**
+     * True when the service enables asynchronous activity completion for the
+     * run (`fluidgrids.run-control`): admits `internal:send-and-wait` (H5).
+     * Default false, the Phase B allow-list.
+     */
+    asyncCompletion?: boolean;
+}
 /** True when `nodeType` may run as a durable activity. */
-declare function isActivityNodeTypeAllowed(nodeType: string): boolean;
+declare function isActivityNodeTypeAllowed(nodeType: string, options?: ActivityNodeTypeOptions): boolean;
 /** Raised by {@link assertActivityNodeType}. Non-retryable, error type `VALIDATION`. */
 declare class ActivityNodeTypeNotAllowedError extends Error {
     readonly nodeType: string;
@@ -125,7 +703,7 @@ declare class ActivityNodeTypeNotAllowedError extends Error {
     constructor(nodeType: string);
 }
 /** Throw {@link ActivityNodeTypeNotAllowedError} unless `nodeType` may run as an activity. */
-declare function assertActivityNodeType(nodeType: string): void;
+declare function assertActivityNodeType(nodeType: string, options?: ActivityNodeTypeOptions): void;
 
 /**
  * Defaults the service, the workers and the SDK must apply the same way.
@@ -154,4 +732,4 @@ declare const CHILD_DEFAULT_PARENT_CLOSE_POLICY: Readonly<{
  */
 declare const CHILD_DEFAULT_CANCELLATION_TYPE: ChildCancellationType;
 
-export { ACTIVITY_INTERNAL_ALLOWLIST, ACTIVITY_NODE_ALLOWLIST, ACTIVITY_NODE_DENYLIST, ActivityNodeTypeNotAllowedError, CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY, ChildCancellationType, type CommandValidation, DEFAULT_ACTIVITY_RETRY, Failure, HistoryIssue, ParentClosePolicy, type PayloadValidator, type RetryDecision, RetryPolicy, type ValidateCommandsOptions, WorkflowCommand, WorkflowTaskFailureCause, assertActivityNodeType, codeWorkflowParentClosePolicy, compilePayloadValidator, computeRetryDelay, explicitRetryPolicy, isActivityNodeTypeAllowed, validateCommand, validateCommands, validateHistory, validateHistoryFile };
+export { ACTIVITY_ASYNC_COMPLETION_ALLOWLIST, ACTIVITY_INTERNAL_ALLOWLIST, ACTIVITY_NODE_ALLOWLIST, ACTIVITY_NODE_DENYLIST, ActivityNodeTypeNotAllowedError, type ActivityNodeTypeOptions, type ActivityTaskFrame, type ActivityTaskRef, type ActivityTaskResultFrame, BRIDGE_IDLE_TIMEOUT_MS, BRIDGE_MAX_FRAME_BYTES, BRIDGE_MAX_HISTORY_TAIL_BYTES, BRIDGE_PATH, BRIDGE_PING_SECONDS, BRIDGE_PROTOCOL_VERSION, BRIDGE_REQUEST_METHODS, BRIDGE_V2_SCHEMA, BRIDGE_V2_SCHEMA_ID, BRIDGE_WORKER_HEARTBEAT_SECONDS, type BridgeCancelFrame, BridgeCloseCode, type BridgeCloseCodeValue, type BridgeFrame, type BridgeHeartbeatAckFrame, type BridgeHistoryPage, type BridgePongFrame, type BridgeRequestMethod, type BridgeResponseFrame, type BridgeSlotUsage, type BridgeTaskFrame, type BridgeTaskRef, type BridgeWelcomeFrame, CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY, ChildCancellationType, CommandGate, CommandRelief, type CommandValidation, DEFAULT_ACTIVITY_RETRY, Failure, HistoryIssue, ParentClosePolicy, type PayloadValidator, QueryRequest, QueryResult, type QueryTaskFrame, type QueryTaskRef, type QueryTaskResultFrame, type RetryDecision, RetryPolicy, RunEventRecord, type RunRetryDecision, RunRetryPolicy, type ServiceFrame, type TaskFailedFrame, TaskLogLine, type TaskResultFrame, UnfinishedHandler, UpdateRequest, type ValidateCommandsOptions, type WorkerActivityHeartbeatFrame, type WorkerByeFrame, type WorkerFrame, type WorkerHeartbeatFrame, type WorkerHelloFrame, type WorkerPingFrame, type WorkerPollersFrame, type WorkerRequestFrame, WorkflowCommand, WorkflowInfoSnapshot, type WorkflowTaskFailure, WorkflowTaskFailureCause, type WorkflowTaskFrame, type WorkflowTaskRef, type WorkflowTaskResultFrame, assertActivityNodeType, codeWorkflowParentClosePolicy, compilePayloadValidator, computeRetryDelay, computeRunRetryDelay, explicitRetryPolicy, explicitRunRetryPolicy, fnv1a32, inRollout, isActivityNodeTypeAllowed, rolloutBucket, validateBridgeFrame, validateCommand, validateCommands, validateHistory, validateHistoryFile };