@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/{file-yuPCFU5b.d.ts → file-CFdPQJI9.d.ts}

@@ -1,5 +1,5 @@
-import { E as ErrorType, a as Json, J as JsonObject } from './types-BGoPzgcl.js';
-import { d as BuiltInQueryName, m as CommandType, W as WorkflowCommand, F as Failure, P as ParentClosePolicy, T as RunEventDraft, a as WorkflowTaskFailureCause, U as RunEventRecord, v as HISTORY_PROTOCOL, a6 as WorkflowInfoSnapshot, a8 as WorkflowTaskResult } from './types-DV-HX_Gt.js';
+import { E as ErrorType, a as Json, J as JsonObject } from './types-V7jEEUaL.js';
+import { W as WorkflowCommand, s as CommandType, F as Failure, P as ParentClosePolicy, ab as RunEventDraft, a as WorkflowTaskFailureCause, R as RunEventRecord, L as HISTORY_PROTOCOL, b as WorkflowInfoSnapshot, aA as WorkflowTaskResult } from './types-DGx-b9eq.js';
 
 declare const RUN_EVENT_SCHEMA_ID = "https://docs.fluidgrids.ai/schemas/run-event.schema.json";
 declare const WORKFLOW_COMMAND_SCHEMA_ID = "https://docs.fluidgrids.ai/schemas/workflow-command.schema.json";
@@ -123,6 +123,7 @@ declare const RUN_EVENT_SCHEMA: {
             }, {
                 readonly type: "object";
                 readonly required: readonly ["workflowKey", "workflowId"];
+                readonly description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).";
                 readonly properties: {
                     readonly workflowKey: {
                         readonly type: "string";
@@ -134,10 +135,70 @@ declare const RUN_EVENT_SCHEMA: {
                         readonly minLength: 1;
                         readonly maxLength: 256;
                     };
+                    readonly firstRunId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
                 };
                 readonly additionalProperties: false;
             }];
         };
+        readonly runRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["initialDelayMs"];
+            readonly description: "Run-level retry (11 §2.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.";
+            readonly properties: {
+                readonly maxAttempts: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly initialDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly maxDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ErrorType[];
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly timeouts: {
+            readonly type: "object";
+            readonly description: "The three workflow timeouts (11 §2.20), in milliseconds.";
+            readonly properties: {
+                readonly executionTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly runTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly childOptions: {
             readonly type: "object";
             readonly required: readonly ["parentClosePolicy"];
@@ -189,13 +250,99 @@ declare const RUN_EVENT_SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly idReusePolicy: {
+                    readonly enum: readonly ["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY", "REJECT_DUPLICATE"];
+                };
+                readonly idConflictPolicy: {
+                    readonly enum: readonly ["FAIL", "USE_EXISTING", "TERMINATE_EXISTING"];
+                };
+                readonly fairnessKey: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 255;
+                    readonly description: "Phase C: the fairness key of the task (11 §2.11); default the workspace id.";
+                };
+                readonly fairnessWeight: {
+                    readonly type: "number";
+                    readonly minimum: 0.1;
+                    readonly maximum: 10;
+                    readonly description: "Phase C: the weight of the fairness key, 0.1 to 10 (default 1).";
+                };
+            };
+        };
+        readonly legacyCanRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["retryDelay"];
+            readonly description: "The R1 activity-shaped CONTINUE_AS_NEW retry: whatever explicitRetryPolicy wrote from a Partial<RetryPolicy>, so numbers carry no integer or minimum constraint. It never had a meaning, and the service ignores it.";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                };
+                readonly retryDelay: {
+                    readonly type: "number";
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly canOptions: {
+            readonly type: "object";
+            readonly description: "Options of a CONTINUE_AS_NEW command (C-SCHEMA, frozen in R2). retry is the R2 run-retry policy of the new run, or the R1 activity shape (retryDelay, maxRetries, maxDelay) that R1 bundles wrote and R2 bundles still write for that shape: it never had a meaning, and the service ignores it instead of reading it as a run-retry policy.";
+            readonly properties: {
+                readonly taskQueue: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/runRetryPolicy";
+                    }, {
+                        readonly $ref: "#/$defs/legacyCanRetryPolicy";
+                    }];
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly context: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
             };
+            readonly additionalProperties: false;
         };
         readonly headers: {
             readonly type: "object";
             readonly additionalProperties: {
                 readonly type: "string";
             };
+            readonly description: "Interceptor headers (11 §2.10): string values; a user activity carries at most 16 KiB of JSON (checked by validateCommands).";
         };
     };
     readonly type: "object";
@@ -360,6 +507,7 @@ declare const WORKFLOW_COMMAND_SCHEMA: {
             }, {
                 readonly type: "object";
                 readonly required: readonly ["workflowKey", "workflowId"];
+                readonly description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).";
                 readonly properties: {
                     readonly workflowKey: {
                         readonly type: "string";
@@ -371,10 +519,70 @@ declare const WORKFLOW_COMMAND_SCHEMA: {
                         readonly minLength: 1;
                         readonly maxLength: 256;
                     };
+                    readonly firstRunId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
                 };
                 readonly additionalProperties: false;
             }];
         };
+        readonly runRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["initialDelayMs"];
+            readonly description: "Run-level retry (11 §2.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.";
+            readonly properties: {
+                readonly maxAttempts: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly initialDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly maxDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ErrorType[];
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly timeouts: {
+            readonly type: "object";
+            readonly description: "The three workflow timeouts (11 §2.20), in milliseconds.";
+            readonly properties: {
+                readonly executionTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly runTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly childOptions: {
             readonly type: "object";
             readonly required: readonly ["parentClosePolicy"];
@@ -426,13 +634,99 @@ declare const WORKFLOW_COMMAND_SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly idReusePolicy: {
+                    readonly enum: readonly ["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY", "REJECT_DUPLICATE"];
+                };
+                readonly idConflictPolicy: {
+                    readonly enum: readonly ["FAIL", "USE_EXISTING", "TERMINATE_EXISTING"];
+                };
+                readonly fairnessKey: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 255;
+                    readonly description: "Phase C: the fairness key of the task (11 §2.11); default the workspace id.";
+                };
+                readonly fairnessWeight: {
+                    readonly type: "number";
+                    readonly minimum: 0.1;
+                    readonly maximum: 10;
+                    readonly description: "Phase C: the weight of the fairness key, 0.1 to 10 (default 1).";
+                };
+            };
+        };
+        readonly legacyCanRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["retryDelay"];
+            readonly description: "The R1 activity-shaped CONTINUE_AS_NEW retry: whatever explicitRetryPolicy wrote from a Partial<RetryPolicy>, so numbers carry no integer or minimum constraint. It never had a meaning, and the service ignores it.";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                };
+                readonly retryDelay: {
+                    readonly type: "number";
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly canOptions: {
+            readonly type: "object";
+            readonly description: "Options of a CONTINUE_AS_NEW command (C-SCHEMA, frozen in R2). retry is the R2 run-retry policy of the new run, or the R1 activity shape (retryDelay, maxRetries, maxDelay) that R1 bundles wrote and R2 bundles still write for that shape: it never had a meaning, and the service ignores it instead of reading it as a run-retry policy.";
+            readonly properties: {
+                readonly taskQueue: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/runRetryPolicy";
+                    }, {
+                        readonly $ref: "#/$defs/legacyCanRetryPolicy";
+                    }];
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly context: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
             };
+            readonly additionalProperties: false;
         };
         readonly headers: {
             readonly type: "object";
             readonly additionalProperties: {
                 readonly type: "string";
             };
+            readonly description: "Interceptor headers (11 §2.10): string values; a user activity carries at most 16 KiB of JSON (checked by validateCommands).";
         };
     };
     readonly type: "object";
@@ -458,7 +752,7 @@ declare const WORKFLOW_COMMAND_SCHEMA: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://docs.fluidgrids.ai/schemas/workflow-command.schema.json";
     readonly title: "FluidGrids workflow-task command";
-    readonly description: "A flat object discriminated by an UPPER_SNAKE type. Commands travel as [JSON!]! (DB4). UPSERT_SEARCH_ATTRIBUTES, ACCEPT_UPDATE, REJECT_UPDATE and COMPLETE_UPDATE are defined but refused in Phase B.";
+    readonly description: "A flat object discriminated by an UPPER_SNAKE type. Commands travel as [JSON!]! (DB4). UPSERT_SEARCH_ATTRIBUTES, ACCEPT_UPDATE, REJECT_UPDATE, COMPLETE_UPDATE and SCHEDULE_ACTIVITY of kind user are Phase C: the service accepts them only for the C-GATE features its flags enable (c.searchAttributes, c.updates, c.userActivity).";
 };
 /** The workflow-task request and result of the runtime ABI. */
 declare const WORKFLOW_TASK_SCHEMA: {
@@ -561,10 +855,17 @@ declare const WORKFLOW_TASK_SCHEMA: {
                 readonly businessId: {
                     readonly type: "string";
                 };
+                readonly workflowId: {
+                    readonly type: "string";
+                };
                 readonly attempt: {
                     readonly type: "integer";
                     readonly minimum: 1;
                 };
+                readonly runAttempt: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
                 readonly taskQueue: {
                     readonly type: "string";
                 };
@@ -628,7 +929,132 @@ declare const WORKFLOW_TASK_SCHEMA: {
                 readonly context: {
                     readonly type: "object";
                 };
+                readonly memo: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly searchAttributes: {
+                    readonly type: "object";
+                };
+                readonly fairnessKey: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 255;
+                    readonly description: "Phase C: the fairness key of the task (11 §2.11); default the workspace id.";
+                };
+                readonly fairnessWeight: {
+                    readonly type: "number";
+                    readonly minimum: 0.1;
+                    readonly maximum: 10;
+                    readonly description: "Phase C: the weight of the fairness key, 0.1 to 10 (default 1).";
+                };
+            };
+        };
+        readonly updateRequest: {
+            readonly type: "object";
+            readonly required: readonly ["updateId", "name"];
+            readonly description: "Phase C (C-ABI-H): a pending update the lease delivers. admitted marks one history already holds as UPDATE_ADMITTED; the runtime delivers that one from the event.";
+            readonly properties: {
+                readonly updateId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly args: {};
+                readonly admitted: {
+                    readonly type: "boolean";
+                };
+                readonly headers: {
+                    readonly $ref: "#/$defs/headers";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly sinkCall: {
+            readonly type: "object";
+            readonly required: readonly ["sink", "fn", "args"];
+            readonly description: "Phase C: a call of ctx.sinks.<sink>.<fn>(...args), never made on replay.";
+            readonly properties: {
+                readonly sink: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly fn: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly args: {
+                    readonly type: "array";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly localActivityRequest: {
+            readonly type: "object";
+            readonly required: readonly ["localActivityId", "kind", "nodeType", "operation", "args", "retry", "startToCloseTimeout", "attempt", "backoffMs"];
+            readonly description: "R2: a local activity the task needs (11 §2.12). Run attempt `attempt` after waiting backoffMs, then run the same task again with the outcome in localActivityResults.";
+            readonly properties: {
+                readonly localActivityId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly kind: {
+                    readonly const: "node";
+                };
+                readonly nodeType: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly nodeVersion: {
+                    readonly type: "string";
+                };
+                readonly operation: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly args: {};
+                readonly connection: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly $ref: "#/$defs/retryPolicy";
+                };
+                readonly startToCloseTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly maximum: 30000;
+                };
+                readonly attempt: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly backoffMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly summary: {
+                    readonly type: "string";
+                    readonly maxLength: 200;
+                };
             };
+            readonly additionalProperties: false;
         };
         readonly request: {
             readonly type: "object";
@@ -679,6 +1105,12 @@ declare const WORKFLOW_TASK_SCHEMA: {
                         };
                     };
                 };
+                readonly updates: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/updateRequest";
+                    };
+                };
                 readonly queries: {
                     readonly type: "array";
                     readonly items: {
@@ -691,12 +1123,24 @@ declare const WORKFLOW_TASK_SCHEMA: {
                                 readonly maxLength: 256;
                             };
                             readonly name: {
-                                readonly enum: readonly BuiltInQueryName[];
+                                readonly description: `A built-in query (${string}) or, from C-R1, the name of a custom query.`;
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 256;
                             };
                             readonly args: {};
                         };
                     };
                 };
+                readonly features: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly uniqueItems: true;
+                    readonly description: "The bundle features (code.features names) the workspace enables for this task. From C-R1 the runtime reads `interceptors`: a task of a bundle that exports interceptors fails with UNSUPPORTED_COMMAND unless it is listed.";
+                };
             };
         };
         readonly result: {
@@ -717,8 +1161,29 @@ declare const WORKFLOW_TASK_SCHEMA: {
                 };
                 readonly localActivityRequests: {
                     readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/localActivityRequest";
+                    };
+                };
+                readonly unfinishedHandlers: {
+                    readonly type: "array";
+                    readonly description: "R2: handlers still running when the terminal command was issued (11 §2.18); never set on replay.";
                     readonly items: {
                         readonly type: "object";
+                        readonly required: readonly ["kind", "name", "count"];
+                        readonly properties: {
+                            readonly kind: {
+                                readonly enum: readonly ["signal", "update"];
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                            };
+                            readonly count: {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                            };
+                        };
+                        readonly additionalProperties: false;
                     };
                 };
                 readonly queryResults: {
@@ -736,9 +1201,20 @@ declare const WORKFLOW_TASK_SCHEMA: {
                             readonly error: {
                                 readonly type: "string";
                             };
+                            readonly rejected: {
+                                readonly type: "boolean";
+                                readonly description: "Phase C: no handler took the query name (the service answers VALIDATION).";
+                            };
                         };
                     };
                 };
+                readonly sinkCalls: {
+                    readonly type: "array";
+                    readonly maxItems: 256;
+                    readonly items: {
+                        readonly $ref: "#/$defs/sinkCall";
+                    };
+                };
                 readonly failure: {
                     readonly type: "object";
                     readonly required: readonly ["cause", "message"];
@@ -894,20 +1370,81 @@ declare const WORKFLOW_TASK_SCHEMA: {
             }, {
                 readonly type: "object";
                 readonly required: readonly ["workflowKey", "workflowId"];
+                readonly description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).";
                 readonly properties: {
                     readonly workflowKey: {
                         readonly type: "string";
                         readonly minLength: 1;
                         readonly maxLength: 256;
                     };
-                    readonly workflowId: {
+                    readonly workflowId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
+                    readonly firstRunId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
+                };
+                readonly additionalProperties: false;
+            }];
+        };
+        readonly runRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["initialDelayMs"];
+            readonly description: "Run-level retry (11 §2.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.";
+            readonly properties: {
+                readonly maxAttempts: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly initialDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly maxDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ErrorType[];
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
                         readonly type: "string";
-                        readonly minLength: 1;
-                        readonly maxLength: 256;
                     };
                 };
-                readonly additionalProperties: false;
-            }];
+            };
+            readonly additionalProperties: false;
+        };
+        readonly timeouts: {
+            readonly type: "object";
+            readonly description: "The three workflow timeouts (11 §2.20), in milliseconds.";
+            readonly properties: {
+                readonly executionTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly runTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+            readonly additionalProperties: false;
         };
         readonly childOptions: {
             readonly type: "object";
@@ -960,13 +1497,99 @@ declare const WORKFLOW_TASK_SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly idReusePolicy: {
+                    readonly enum: readonly ["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY", "REJECT_DUPLICATE"];
+                };
+                readonly idConflictPolicy: {
+                    readonly enum: readonly ["FAIL", "USE_EXISTING", "TERMINATE_EXISTING"];
+                };
+                readonly fairnessKey: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 255;
+                    readonly description: "Phase C: the fairness key of the task (11 §2.11); default the workspace id.";
+                };
+                readonly fairnessWeight: {
+                    readonly type: "number";
+                    readonly minimum: 0.1;
+                    readonly maximum: 10;
+                    readonly description: "Phase C: the weight of the fairness key, 0.1 to 10 (default 1).";
+                };
+            };
+        };
+        readonly legacyCanRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["retryDelay"];
+            readonly description: "The R1 activity-shaped CONTINUE_AS_NEW retry: whatever explicitRetryPolicy wrote from a Partial<RetryPolicy>, so numbers carry no integer or minimum constraint. It never had a meaning, and the service ignores it.";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                };
+                readonly retryDelay: {
+                    readonly type: "number";
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly canOptions: {
+            readonly type: "object";
+            readonly description: "Options of a CONTINUE_AS_NEW command (C-SCHEMA, frozen in R2). retry is the R2 run-retry policy of the new run, or the R1 activity shape (retryDelay, maxRetries, maxDelay) that R1 bundles wrote and R2 bundles still write for that shape: it never had a meaning, and the service ignores it instead of reading it as a run-retry policy.";
+            readonly properties: {
+                readonly taskQueue: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/runRetryPolicy";
+                    }, {
+                        readonly $ref: "#/$defs/legacyCanRetryPolicy";
+                    }];
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly context: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
             };
+            readonly additionalProperties: false;
         };
         readonly headers: {
             readonly type: "object";
             readonly additionalProperties: {
                 readonly type: "string";
             };
+            readonly description: "Interceptor headers (11 §2.10): string values; a user activity carries at most 16 KiB of JSON (checked by validateCommands).";
         };
     };
 };
@@ -1005,7 +1628,7 @@ declare const HISTORY_FILE_SCHEMA: {
         };
         readonly replay: {
             readonly type: "boolean";
-            readonly description: "False for histories that use Phase C features (updates); they are parsed and projected but not replayed.";
+            readonly description: "False for histories that are parsed and projected but not replayed (written by hand for a feature the recording runtime did not have).";
         };
         readonly info: {
             readonly $ref: "#/$defs/info";
@@ -1093,10 +1716,17 @@ declare const HISTORY_FILE_SCHEMA: {
                 readonly businessId: {
                     readonly type: "string";
                 };
+                readonly workflowId: {
+                    readonly type: "string";
+                };
                 readonly attempt: {
                     readonly type: "integer";
                     readonly minimum: 1;
                 };
+                readonly runAttempt: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
                 readonly taskQueue: {
                     readonly type: "string";
                 };
@@ -1160,6 +1790,30 @@ declare const HISTORY_FILE_SCHEMA: {
                 readonly context: {
                     readonly type: "object";
                 };
+                readonly memo: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly searchAttributes: {
+                    readonly type: "object";
+                };
+                readonly fairnessKey: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 255;
+                    readonly description: "Phase C: the fairness key of the task (11 §2.11); default the workspace id.";
+                };
+                readonly fairnessWeight: {
+                    readonly type: "number";
+                    readonly minimum: 0.1;
+                    readonly maximum: 10;
+                    readonly description: "Phase C: the weight of the fairness key, 0.1 to 10 (default 1).";
+                };
             };
         };
         readonly json: {
@@ -1275,6 +1929,7 @@ declare const HISTORY_FILE_SCHEMA: {
             }, {
                 readonly type: "object";
                 readonly required: readonly ["workflowKey", "workflowId"];
+                readonly description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).";
                 readonly properties: {
                     readonly workflowKey: {
                         readonly type: "string";
@@ -1286,10 +1941,70 @@ declare const HISTORY_FILE_SCHEMA: {
                         readonly minLength: 1;
                         readonly maxLength: 256;
                     };
+                    readonly firstRunId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
                 };
                 readonly additionalProperties: false;
             }];
         };
+        readonly runRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["initialDelayMs"];
+            readonly description: "Run-level retry (11 §2.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.";
+            readonly properties: {
+                readonly maxAttempts: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly initialDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly maxDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ErrorType[];
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly timeouts: {
+            readonly type: "object";
+            readonly description: "The three workflow timeouts (11 §2.20), in milliseconds.";
+            readonly properties: {
+                readonly executionTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly runTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly childOptions: {
             readonly type: "object";
             readonly required: readonly ["parentClosePolicy"];
@@ -1341,20 +2056,118 @@ declare const HISTORY_FILE_SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly idReusePolicy: {
+                    readonly enum: readonly ["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY", "REJECT_DUPLICATE"];
+                };
+                readonly idConflictPolicy: {
+                    readonly enum: readonly ["FAIL", "USE_EXISTING", "TERMINATE_EXISTING"];
+                };
+                readonly fairnessKey: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 255;
+                    readonly description: "Phase C: the fairness key of the task (11 §2.11); default the workspace id.";
+                };
+                readonly fairnessWeight: {
+                    readonly type: "number";
+                    readonly minimum: 0.1;
+                    readonly maximum: 10;
+                    readonly description: "Phase C: the weight of the fairness key, 0.1 to 10 (default 1).";
+                };
+            };
+        };
+        readonly legacyCanRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["retryDelay"];
+            readonly description: "The R1 activity-shaped CONTINUE_AS_NEW retry: whatever explicitRetryPolicy wrote from a Partial<RetryPolicy>, so numbers carry no integer or minimum constraint. It never had a meaning, and the service ignores it.";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                };
+                readonly retryDelay: {
+                    readonly type: "number";
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly canOptions: {
+            readonly type: "object";
+            readonly description: "Options of a CONTINUE_AS_NEW command (C-SCHEMA, frozen in R2). retry is the R2 run-retry policy of the new run, or the R1 activity shape (retryDelay, maxRetries, maxDelay) that R1 bundles wrote and R2 bundles still write for that shape: it never had a meaning, and the service ignores it instead of reading it as a run-retry policy.";
+            readonly properties: {
+                readonly taskQueue: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/runRetryPolicy";
+                    }, {
+                        readonly $ref: "#/$defs/legacyCanRetryPolicy";
+                    }];
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly context: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
             };
+            readonly additionalProperties: false;
         };
         readonly headers: {
             readonly type: "object";
             readonly additionalProperties: {
                 readonly type: "string";
             };
+            readonly description: "Interceptor headers (11 §2.10): string values; a user activity carries at most 16 KiB of JSON (checked by validateCommands).";
         };
     };
 };
 /** File name and schema of every generated history schema. */
 declare const HISTORY_SCHEMA_FILES: ReadonlyArray<readonly [string, unknown]>;
 
-/** Command helpers shared by validation and the state machine; no schema code. */
+/**
+ * The command feature gate (C-GATE, frozen in SDK R2) and command helpers
+ * shared by validation and the state machine; no schema code.
+ *
+ * Every command needs one or more features. The service builds the set of
+ * features a workspace may use once per command batch, before it locks the
+ * run (in Phase B: {@link PHASE_B_CORE_FEATURES}, plus
+ * {@link PHASE_B_PARITY_FEATURES} when `fluidgrids.durable-parity` is on),
+ * and refuses a batch with a command whose features are not all enabled
+ * (`UNSUPPORTED_COMMAND`; the run stays RUNNING and heals when the flag is
+ * turned back on). Relief commands ({@link isReliefCommand}) answer work the
+ * service already granted and are never refused for a missing flag.
+ */
 
 /** One problem found in a command batch or a history. */
 interface HistoryIssue {
@@ -1365,18 +2178,142 @@ interface HistoryIssue {
     path?: string;
 }
 /**
- * True when the command is enabled: the Phase B core set always, the parity
- * set when `enabled` is `parity`, Phase C commands never.
+ * A feature a command may need (C-GATE).
+ *
+ * - `core`: the Phase B core command set.
+ * - `parity.can`: `CONTINUE_AS_NEW` (enabled in Phase B core).
+ * - `parity.context`: `UPSERT_CONTEXT` (enabled in Phase B core).
+ * - `parity.localActivity`: `RECORD_LOCAL_ACTIVITY`.
+ * - `parity.externalCancel`: `REQUEST_CANCEL_EXTERNAL_RUN` aimed at a run
+ *   that is not one of the run's own children.
+ * - `parity.childOptions`: the `START_CHILD_RUN` options new in R2
+ *   (anything outside {@link CORE_CHILD_OPTIONS}: `retry`,
+ *   `versioningBehavior`, `idReusePolicy`, `idConflictPolicy`).
+ * - `parity.canOptions`: the `CONTINUE_AS_NEW` options new in R2: a run-retry
+ *   `retry` and anything outside {@link CORE_CAN_OPTIONS}.
+ * - `parity.workflowIdTarget`: a `SIGNAL_RUN` or `REQUEST_CANCEL_EXTERNAL_RUN`
+ *   target given as `{ workflowKey, workflowId }`.
+ * - `c.updates` (Phase C, `fluidgrids.run-control`): `ACCEPT_UPDATE`,
+ *   `REJECT_UPDATE` and `COMPLETE_UPDATE`.
+ * - `c.searchAttributes` (Phase C, `fluidgrids.search-attributes`):
+ *   `UPSERT_SEARCH_ATTRIBUTES`.
+ * - `c.userActivity` (Phase C, `fluidgrids.self-hosted-workers`): a
+ *   `SCHEDULE_ACTIVITY` of `kind: 'user'`.
+ *
+ * Phase B never enables a `c.*` feature, so a workspace without the Phase C
+ * flags gets exactly the B19 command set (CX1).
+ */
+type CommandFeature = 'core' | 'parity.can' | 'parity.context' | 'parity.localActivity' | 'parity.externalCancel' | 'parity.childOptions' | 'parity.canOptions' | 'parity.workflowIdTarget' | 'c.updates' | 'c.searchAttributes' | 'c.userActivity';
+/** Every feature, in a stable order. */
+declare const COMMAND_FEATURES: readonly CommandFeature[];
+/** The features of the Phase B core release (what the service enables without the parity flag). */
+declare const PHASE_B_CORE_FEATURES: ReadonlySet<CommandFeature>;
+/** Every Phase B feature: the core set plus what `fluidgrids.durable-parity` enables. */
+declare const PHASE_B_PARITY_FEATURES: ReadonlySet<CommandFeature>;
+/** The Phase C features (C-GATE extension, C-R1). */
+declare const PHASE_C_FEATURES: readonly CommandFeature[];
+/**
+ * The platform flag that enables each Phase C feature (PLAN-C §2.1). Each one
+ * also needs `fluidgrids.code-first` and `fluidgrids.durable-functions`.
+ */
+declare const PHASE_C_FEATURE_FLAGS: Readonly<Record<string, string>>;
+/**
+ * The platform flag that each bundle feature (C-FEATURES, `code.features`)
+ * needs. The service refuses a push that declares a feature whose flag is off
+ * (`durableRuntimeIssues`). Features without an entry need no flag beyond
+ * `fluidgrids.durable-functions`. `interceptors` is gated with run control so
+ * that a Phase C bundle fails closed until its owner turns the flag on.
+ */
+declare const CODE_FEATURE_FLAGS: Readonly<Record<string, string>>;
+/** The bundle features added in Phase C (C-FEATURES, C-R1), in a stable order. */
+declare const PHASE_C_CODE_FEATURES: readonly string[];
+/**
+ * Child options a Phase B core child may carry: every option the R1 runtime
+ * already wrote into `START_CHILD_RUN` and the Phase B service accepted (it
+ * stored or ignored them). Only the options new in R2 (`retry`,
+ * `versioningBehavior`, `idReusePolicy`, `idConflictPolicy`) need
+ * `parity.childOptions`, so a Phase B workflow behaves the same with the
+ * parity flag off. The fairness options (C-R1) need only
+ * `fluidgrids.durable-functions` (CWD2): a service without the dispatcher
+ * stores and ignores them.
+ */
+declare const CORE_CHILD_OPTIONS: ReadonlySet<string>;
+/**
+ * Continue-as-new options a Phase B core command may carry: every option the
+ * R1 runtime wrote. `retry` is core only in its R1 (activity) shape, which the
+ * Phase B service ignores ({@link continueAsNewRetryShape}); the R2 run-retry
+ * shape needs `parity.canOptions`.
+ */
+declare const CORE_CAN_OPTIONS: ReadonlySet<string>;
+/**
+ * The shape of `CONTINUE_AS_NEW` `options.retry` (C-SCHEMA `canOptions`):
+ *
+ * - `run`: the R2 run-retry policy (`initialDelayMs`, `maxAttempts`, ...),
+ *   which the service applies to the new run (11 §2.17);
+ * - `legacy`: the R1 activity shape (`retryDelay`, `maxRetries`, `maxDelay`)
+ *   that R1 bundles and histories carry. It never had a meaning: the Phase B
+ *   service ignored it, and the service must keep ignoring it rather than
+ *   read it as a run-retry policy;
+ * - `none`: no retry option.
+ *
+ * A value with keys of both shapes, or of neither, is `invalid`; the command
+ * schema refuses it.
+ */
+declare function continueAsNewRetryShape(options: Readonly<Record<string, unknown>>): 'run' | 'legacy' | 'none' | 'invalid';
+/** The features `command` needs, without duplicates, in {@link COMMAND_FEATURES} order. */
+declare function commandFeatures(command: WorkflowCommand): CommandFeature[];
+/**
+ * Which commands are enabled: a feature set (C-GATE), or the deprecated
+ * release levels `core` and `parity`, which keep their R1 meaning (the type
+ * lists of `isCommandEnabled`, with a child-targeted cancel always enabled).
+ */
+type CommandGate = 'core' | 'parity' | ReadonlySet<CommandFeature>;
+/**
+ * True when the command type is enabled: the Phase B core set always, the
+ * parity set when `enabled` is `parity`, Phase C commands never.
+ *
+ * @deprecated Since R2; use {@link isWorkflowCommandEnabled} with a feature
+ * set. Kept for one release.
  */
 declare function isCommandEnabled(type: CommandType, enabled?: 'core' | 'parity'): boolean;
 /**
- * True when this command is enabled. Like {@link isCommandEnabled}, except
- * that `REQUEST_CANCEL_EXTERNAL_RUN` aimed at one of the run's own children
- * (`target.childId`) is core: it is how a cancelled scope cancels a child
- * (the default child cancellation type, spec 11 §2.5). Other targets stay
- * parity.
+ * True when every feature `command` needs is enabled. With a release level
+ * (`core`, `parity`) it answers as R1 did: the command type decides, and
+ * `REQUEST_CANCEL_EXTERNAL_RUN` aimed at one of the run's own children is
+ * core. A command that needs a Phase C feature (`c.*`, for example a
+ * `SCHEDULE_ACTIVITY` of kind `user`, whose type is core) is refused by every
+ * release level, so the default gate fails closed.
+ */
+declare function isWorkflowCommandEnabled(command: WorkflowCommand, enabled?: CommandGate): boolean;
+/**
+ * The bundle features (C-FEATURES, `code.features` names) a command gate's
+ * flags enable, sorted: a feature is enabled when its flag
+ * ({@link CODE_FEATURE_FLAGS}) is on, and a flag is on when the gate holds a
+ * command feature it enables (`fluidgrids.run-control` for `c.updates`,
+ * `fluidgrids.durable-parity` for a parity feature outside the Phase B core
+ * set). Release levels enable none.
+ * It is what a lease sends as `WorkflowTaskRequest.features`.
  */
-declare function isWorkflowCommandEnabled(command: WorkflowCommand, enabled?: 'core' | 'parity'): boolean;
+declare function codeFeaturesEnabledBy(enabled: CommandGate): string[];
+/** Why a command is refused by the gate, naming the missing features. */
+declare function unsupportedMessage(command: WorkflowCommand, enabled?: CommandGate): string;
+/** What the lease of the current workflow task already granted (C-LEASE). */
+interface CommandRelief {
+    /** Local activities the lease asked the worker to run (`localActivityRequested`). */
+    grantedLocalActivityIds: readonly string[];
+    /** Updates the lease delivered to the task (stamped with its `deliveredTaskId`, Phase C). */
+    deliveredUpdateIds: readonly string[];
+}
+/**
+ * True for a command that answers work the service already granted (BP7,
+ * CX2): a `RECORD_LOCAL_ACTIVITY` of a granted local activity,
+ * `ACCEPT_UPDATE` or `REJECT_UPDATE` of an update the lease delivered, and
+ * every `COMPLETE_UPDATE` (it can only finish an update the run accepted,
+ * which `eventsForCommands` checks against the history). Such commands are
+ * accepted even when the flag that enables new requests of their kind is off,
+ * so turning a flag off never strands work that was already started.
+ */
+declare function isReliefCommand(command: WorkflowCommand, lease: CommandRelief): boolean;
 
 /**
  * The pure state machine of a durable-function run (DB3): what a command batch
@@ -1394,8 +2331,16 @@ type ActivityStatus = 'SCHEDULED' | 'STARTED' | 'COMPLETED' | 'FAILED' | 'TIMED_
 interface ActivityState {
     status: ActivityStatus;
     attempt: number;
+    /** `node` (a canvas node operation) or `user` (a user activity, Phase C). */
+    kind: 'node' | 'user';
+    /** The node type; empty for a user activity. */
     nodeType: string;
+    /** The node operation; empty for a user activity. */
     operation: string;
+    /** The user activity's name (Phase C). */
+    activityName?: string;
+    /** The user activity's task queue (Phase C). */
+    taskQueue?: string;
     scheduledSeq: number;
     cancellationType?: string;
     summary?: string;
@@ -1417,11 +2362,32 @@ interface ChildState {
     parentClosePolicy: ParentClosePolicy;
     initiatedSeq: number;
 }
+/** A local activity recorded in history (`LOCAL_ACTIVITY_COMPLETED` or `_FAILED`). */
+interface LocalActivityState {
+    status: 'COMPLETED' | 'FAILED';
+    attempts: number;
+    recordedSeq: number;
+    nodeType?: string;
+    operation?: string;
+    summary?: string;
+}
 interface ExternalState {
     kind: 'signal' | 'cancel';
     status: 'PENDING' | 'RESOLVED';
     ok?: boolean;
 }
+/**
+ * An update as history knows it (Phase C, 11 §2.39): `ADMITTED` (update-with-
+ * start or a reset re-application, before the task accepted it), `ACCEPTED`
+ * and `COMPLETED`. A rejected update leaves no event and is not here.
+ */
+interface UpdateState {
+    status: 'ADMITTED' | 'ACCEPTED' | 'COMPLETED';
+    name: string;
+    /** Seq of `UPDATE_ADMITTED` or `UPDATE_ACCEPTED`, whichever came first. */
+    seq: number;
+    failed?: boolean;
+}
 /** A run as its history describes it. */
 interface RunState {
     status: RunStatus;
@@ -1447,10 +2413,15 @@ interface RunState {
     timers: Record<string, TimerState>;
     children: Record<string, ChildState>;
     externals: Record<string, ExternalState>;
+    localActivities: Record<string, LocalActivityState>;
     sideEffects: Record<string, Json>;
     markers: Record<string, Json>;
     signalsReceived: number;
     context: JsonObject;
+    /** Updates by id (Phase C). */
+    updates: Record<string, UpdateState>;
+    /** Search attributes: the start's, merged with every upsert; null removes a key (Phase C). */
+    searchAttributes: JsonObject;
     lastEventAt?: string;
 }
 /** A history that breaks the state machine (an event that cannot follow the ones before it). */
@@ -1460,6 +2431,8 @@ declare class HistoryStateError extends Error {
 }
 /** The state before any event. */
 declare function initialRunState(): RunState;
+/** Merge search attributes: a null value removes the attribute (11 §2.8). */
+declare function mergeSearchAttributes(current: JsonObject, entries: JsonObject): JsonObject;
 /** UTF-8 length of a string (the history byte caps count UTF-8). */
 declare function utf8Bytes(text: string): number;
 /** True while an activity may still produce a result. */
@@ -1485,7 +2458,20 @@ interface EventsForCommandsContext {
     /** Task start time (the request's `nowMs`); timers fire at `nowMs + durationMs`. */
     nowMs: number;
     /** Which commands are enabled (see `validateCommands`). Default `core`. */
-    enabled?: 'core' | 'parity';
+    enabled?: CommandGate;
+    /** What the lease already granted; relief commands pass the gate (see `isReliefCommand`). */
+    relief?: CommandRelief;
+    /**
+     * The pending updates the lease delivered, by id (C-ABI-H): `UPDATE_ACCEPTED`
+     * carries the request from here. An update history already admitted
+     * (`UPDATE_ADMITTED`) is found in the run state instead. An update reply
+     * for an id in neither is `INVALID_REQUEST`.
+     */
+    updates?: Readonly<Record<string, {
+        name: string;
+        args?: Json;
+        headers?: Record<string, string>;
+    }>>;
 }
 type EventsForCommandsResult = {
     ok: true;
@@ -1554,4 +2540,4 @@ declare function createHistoryFile(workflowFn: string, events: RunEventRecord[],
 /** Serialise a history file the way the CLI and the fixtures write it. */
 declare function serializeHistoryFile(file: HistoryFile): string;
 
-export { type ActivityState as A, parseHistoryFile as B, type ChildState as C, pendingCounts as D, type EventsForCommandsContext as E, projectRunState as F, serializeHistoryFile as G, type HistoryIssue as H, taskCompletedEvents as I, utf8Bytes as J, RUN_EVENT_SCHEMA as R, type TimerState as T, WORKFLOW_COMMAND_SCHEMA as W, type ActivityStatus as a, type ChildStatus as b, type EventsForCommandsResult as c, type ExternalState as d, HISTORY_FILE_FORMAT as e, HISTORY_FILE_SCHEMA as f, HISTORY_FILE_SCHEMA_ID as g, HISTORY_SCHEMA_FILES as h, type HistoryFile as i, HistoryFileError as j, HistoryStateError as k, RUN_EVENT_SCHEMA_ID as l, type RunState as m, type RunStatus as n, WORKFLOW_COMMAND_SCHEMA_ID as o, WORKFLOW_TASK_SCHEMA as p, WORKFLOW_TASK_SCHEMA_ID as q, applyEvent as r, createHistoryFile as s, eventsForCommands as t, hasUnprocessedInput as u, initialRunState as v, isActivityOpen as w, isChildOpen as x, isCommandEnabled as y, isWorkflowCommandEnabled as z };
+export { pendingCounts as $, type ActivityState as A, WORKFLOW_TASK_SCHEMA as B, type CommandGate as C, WORKFLOW_TASK_SCHEMA_ID as D, type EventsForCommandsContext as E, applyEvent as F, codeFeaturesEnabledBy as G, type HistoryIssue as H, commandFeatures as I, continueAsNewRetryShape as J, createHistoryFile as K, type LocalActivityState as L, eventsForCommands as M, hasUnprocessedInput as N, initialRunState as O, PHASE_B_CORE_FEATURES as P, isActivityOpen as Q, RUN_EVENT_SCHEMA as R, isChildOpen as S, type TimerState as T, type UpdateState as U, isCommandEnabled as V, WORKFLOW_COMMAND_SCHEMA as W, isReliefCommand as X, isWorkflowCommandEnabled as Y, mergeSearchAttributes as Z, parseHistoryFile as _, type CommandRelief as a, projectRunState as a0, serializeHistoryFile as a1, taskCompletedEvents as a2, unsupportedMessage as a3, utf8Bytes as a4, type ActivityStatus as b, CODE_FEATURE_FLAGS as c, COMMAND_FEATURES as d, CORE_CAN_OPTIONS as e, CORE_CHILD_OPTIONS as f, type ChildState as g, type ChildStatus as h, type CommandFeature as i, type EventsForCommandsResult as j, type ExternalState as k, HISTORY_FILE_FORMAT as l, HISTORY_FILE_SCHEMA as m, HISTORY_FILE_SCHEMA_ID as n, HISTORY_SCHEMA_FILES as o, type HistoryFile as p, HistoryFileError as q, HistoryStateError as r, PHASE_B_PARITY_FEATURES as s, PHASE_C_CODE_FEATURES as t, PHASE_C_FEATURES as u, PHASE_C_FEATURE_FLAGS as v, RUN_EVENT_SCHEMA_ID as w, type RunState as x, type RunStatus as y, WORKFLOW_COMMAND_SCHEMA_ID as z };