@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/{chunk-A36CCOWS.js → chunk-YEHR4NNE.js}

@@ -1,8 +1,365 @@
+import { PAYLOAD_FIELDS_DOCUMENT } from './chunk-VU5S5A7V.js';
 import { isRecord } from './chunk-PMCM2OH4.js';
-import { isWorkflowCommandEnabled, isReliefCommand, unsupportedMessage } from './chunk-FWBRQWRX.js';
-import { VERSIONING_BEHAVIORS, WORKFLOW_ID_CONFLICT_POLICIES, WORKFLOW_ID_REUSE_POLICIES, CHILD_CANCELLATION_TYPES, PARENT_CLOSE_POLICIES, ERROR_TYPES, ACTIVITY_CANCELLATION_TYPES, WORKFLOW_TIMEOUT_TYPES, TASK_FAILURE_CAUSES, EVENT_TYPES, COMMAND_TYPES, BUILT_IN_QUERIES, HISTORY_PROTOCOL, LOCAL_ACTIVITY_MAX_TIMEOUT_MS, TERMINAL_COMMANDS, isActivityNodeTypeAllowed } from './chunk-2DDULZFM.js';
+import { isWorkflowCommandEnabled, isReliefCommand, unsupportedMessage, utf8Bytes } from './chunk-AE5Q6ZAJ.js';
+import { isActivityNodeTypeAllowed } from './chunk-AC6ZEXVR.js';
+import { TASK_FAILURE_CAUSES, VERSIONING_BEHAVIORS, WORKFLOW_ID_CONFLICT_POLICIES, WORKFLOW_ID_REUSE_POLICIES, CHILD_CANCELLATION_TYPES, PARENT_CLOSE_POLICIES, ERROR_TYPES, ACTIVITY_CANCELLATION_TYPES, WORKFLOW_TIMEOUT_TYPES, EVENT_TYPES, COMMAND_TYPES, BUILT_IN_QUERIES, FAIRNESS_WEIGHT_MAX, FAIRNESS_WEIGHT_MIN, FAIRNESS_KEY_MAX_LENGTH, MAX_ACTIVITY_CONNECTIONS, TASK_QUEUE_NAME_PATTERN, ACTIVITY_NAME_PATTERN, HISTORY_PROTOCOL, MAX_SINK_CALLS, LOCAL_ACTIVITY_MAX_TIMEOUT_MS, TERMINAL_COMMANDS, MAX_HEADERS_BYTES } from './chunk-5HIVIV53.js';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 
+// src/history/bridge.ts
+var BRIDGE_PROTOCOL_VERSION = 2;
+var BRIDGE_PATH = "/runner-bridge";
+var BRIDGE_PING_SECONDS = 20;
+var BRIDGE_WORKER_HEARTBEAT_SECONDS = 30;
+var BRIDGE_IDLE_TIMEOUT_MS = 65e3;
+var BRIDGE_MAX_FRAME_BYTES = 10 * 1024 * 1024;
+var BRIDGE_MAX_HISTORY_TAIL_BYTES = 4 * 1024 * 1024;
+var BridgeCloseCode = {
+  Unauthorized: 4001,
+  Revoked: 4002,
+  Replaced: 4003,
+  /** Also a v2 hello on a RUNNER token, or a v1 hello on a WORKER token. */
+  ProtocolError: 4004,
+  IdleTimeout: 4008,
+  /** The service is shutting down, or `WORKER_BRIDGE_ENABLED` is off. */
+  ShuttingDown: 4009,
+  /** The workspace has no free worker seat (`fluidgrids.workers.count`). */
+  QuotaExceeded: 4010,
+  /** The token does not allow a task queue the hello names. */
+  QueueNotAllowed: 4011,
+  /** `fluidgrids.self-hosted-workers` (or a prerequisite) is off for the workspace. */
+  FeatureDisabled: 4012
+};
+var BRIDGE_REQUEST_METHODS = ["history.page", "activity.connection"];
+var ID = { type: "string", minLength: 1, maxLength: 256 };
+var COUNT = { type: "integer", minimum: 0 };
+var POSITIVE = { type: "integer", minimum: 1 };
+var STRINGS = { type: "array", items: { type: "string", minLength: 1 } };
+function frame(type, required, properties) {
+  return {
+    type: "object",
+    required: ["type", ...required],
+    properties: { type: { const: type }, ...properties },
+    additionalProperties: false
+  };
+}
+var SLOT_USAGE = {
+  type: "object",
+  required: ["used", "total"],
+  properties: { used: COUNT, total: COUNT },
+  additionalProperties: false
+};
+var TASK_FAILURE = {
+  type: "object",
+  required: ["cause", "message"],
+  properties: {
+    cause: { enum: [...TASK_FAILURE_CAUSES] },
+    message: { type: "string" },
+    stackTrace: { type: "string" },
+    seq: { type: "integer" },
+    errorType: { type: "string" }
+  },
+  additionalProperties: false
+};
+var BRIDGE_V2_SCHEMA_ID = "https://docs.fluidgrids.ai/schemas/bridge-v2.schema.json";
+var BRIDGE_V2_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: BRIDGE_V2_SCHEMA_ID,
+  title: "FluidGrids worker bridge, protocol 2",
+  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.",
+  oneOf: [{ $ref: "#/$defs/workerFrame" }, { $ref: "#/$defs/serviceFrame" }],
+  $defs: {
+    workflowTaskRef: {
+      type: "object",
+      required: ["kind", "runId", "taskId", "attempt", "expectedHistoryLength"],
+      properties: {
+        kind: { const: "workflow" },
+        runId: ID,
+        taskId: ID,
+        attempt: POSITIVE,
+        expectedHistoryLength: POSITIVE
+      },
+      additionalProperties: false
+    },
+    queryTaskRef: {
+      type: "object",
+      required: ["kind", "runId", "queryTaskId"],
+      properties: { kind: { const: "query" }, runId: ID, queryTaskId: ID },
+      additionalProperties: false
+    },
+    activityTaskRef: {
+      type: "object",
+      required: ["kind", "runId", "activityId", "attempt"],
+      properties: { kind: { const: "activity" }, runId: ID, activityId: ID, attempt: POSITIVE },
+      additionalProperties: false
+    },
+    taskRef: {
+      oneOf: [
+        { $ref: "#/$defs/workflowTaskRef" },
+        { $ref: "#/$defs/queryTaskRef" },
+        { $ref: "#/$defs/activityTaskRef" }
+      ]
+    },
+    historyPage: {
+      type: "object",
+      required: ["events", "from", "nextAfter", "hasMore"],
+      properties: {
+        events: { type: "array", items: { type: "object" } },
+        from: POSITIVE,
+        nextAfter: { oneOf: [{ type: "null" }, POSITIVE] },
+        hasMore: { type: "boolean" }
+      },
+      additionalProperties: false
+    },
+    queryRequests: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["queryId", "name"],
+        properties: { queryId: ID, name: ID, args: {} },
+        additionalProperties: false
+      }
+    },
+    queryResults: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["queryId"],
+        properties: {
+          queryId: ID,
+          value: {},
+          error: { type: "string" },
+          rejected: { type: "boolean" }
+        },
+        additionalProperties: false
+      }
+    },
+    hello: frame(
+      "hello",
+      [
+        "protocol",
+        "kind",
+        "sdk",
+        "identity",
+        "taskQueues",
+        "buildIds",
+        "workflows",
+        "activities",
+        "slots",
+        "host",
+        "encodings"
+      ],
+      {
+        protocol: { const: BRIDGE_PROTOCOL_VERSION },
+        kind: { const: "worker" },
+        sdk: {
+          type: "object",
+          required: ["language", "version"],
+          properties: { language: { enum: ["typescript", "python"] }, version: ID },
+          additionalProperties: false
+        },
+        identity: ID,
+        taskQueues: { ...STRINGS, minItems: 1 },
+        buildIds: STRINGS,
+        workflows: STRINGS,
+        activities: STRINGS,
+        slots: {
+          type: "object",
+          required: ["workflow", "activity", "localActivity"],
+          properties: { workflow: COUNT, activity: COUNT, localActivity: COUNT },
+          additionalProperties: false
+        },
+        host: {
+          type: "object",
+          properties: {
+            os: { type: "string" },
+            arch: { type: "string" },
+            hostname: { type: "string" },
+            runtime: { type: "string" }
+          },
+          additionalProperties: false
+        },
+        encodings: STRINGS
+      }
+    ),
+    ping: frame("ping", [], { t: { type: "number" } }),
+    pollers: frame("pollers", ["workflow", "activity"], { workflow: COUNT, activity: COUNT }),
+    taskResult: {
+      oneOf: [
+        frame("taskResult", ["taskRef", "commands", "logs", "cachedUpTo"], {
+          taskRef: { $ref: "#/$defs/workflowTaskRef" },
+          commands: { type: "array", items: { type: "object" } },
+          logs: { type: "array", items: { type: "object" } },
+          cachedUpTo: COUNT,
+          queryResults: { $ref: "#/$defs/queryResults" },
+          unfinishedHandlers: { type: "array", items: { type: "object" } }
+        }),
+        frame("taskResult", ["taskRef", "result"], {
+          taskRef: { $ref: "#/$defs/activityTaskRef" },
+          result: {}
+        }),
+        frame("taskResult", ["taskRef", "queryResults"], {
+          taskRef: { $ref: "#/$defs/queryTaskRef" },
+          queryResults: { $ref: "#/$defs/queryResults" }
+        })
+      ]
+    },
+    taskFailed: {
+      oneOf: [
+        frame("taskFailed", ["taskRef", "failure"], {
+          taskRef: {
+            oneOf: [{ $ref: "#/$defs/workflowTaskRef" }, { $ref: "#/$defs/queryTaskRef" }]
+          },
+          failure: TASK_FAILURE
+        }),
+        frame("taskFailed", ["taskRef", "failure"], {
+          taskRef: { $ref: "#/$defs/activityTaskRef" },
+          failure: {
+            type: "object",
+            required: ["errorType", "message"],
+            description: "An activity failure (run-event failure shape)."
+          }
+        })
+      ]
+    },
+    heartbeat: frame("heartbeat", ["reqId", "taskRef"], {
+      reqId: ID,
+      taskRef: { $ref: "#/$defs/activityTaskRef" },
+      details: {}
+    }),
+    workerHeartbeat: frame("workerHeartbeat", ["slots", "pollers", "tasksInFlight", "cachedRuns"], {
+      slots: {
+        type: "object",
+        required: ["workflow", "activity", "localActivity"],
+        properties: { workflow: SLOT_USAGE, activity: SLOT_USAGE, localActivity: SLOT_USAGE },
+        additionalProperties: false
+      },
+      pollers: {
+        type: "object",
+        required: ["workflow", "activity"],
+        properties: { workflow: COUNT, activity: COUNT },
+        additionalProperties: false
+      },
+      tasksInFlight: COUNT,
+      cachedRuns: COUNT
+    }),
+    req: frame("req", ["id", "method", "params"], {
+      id: ID,
+      method: { enum: [...BRIDGE_REQUEST_METHODS] },
+      params: { type: "object" }
+    }),
+    bye: frame("bye", ["reason"], { reason: { type: "string" } }),
+    welcome: frame(
+      "welcome",
+      [
+        "protocol",
+        "sessionId",
+        "workerId",
+        "workspaceId",
+        "heartbeatSeconds",
+        "workerHeartbeatSeconds",
+        "maxFrameBytes"
+      ],
+      {
+        protocol: { const: BRIDGE_PROTOCOL_VERSION },
+        sessionId: ID,
+        workerId: { type: "string", pattern: "^worker:.+$" },
+        workspaceId: ID,
+        heartbeatSeconds: POSITIVE,
+        workerHeartbeatSeconds: POSITIVE,
+        maxFrameBytes: POSITIVE
+      }
+    ),
+    task: {
+      oneOf: [
+        frame("task", ["taskRef", "lease", "request", "history"], {
+          taskRef: { $ref: "#/$defs/workflowTaskRef" },
+          lease: { type: "object" },
+          request: {
+            type: "object",
+            required: ["workflowFn", "info", "nowMs"],
+            properties: {
+              workflowFn: ID,
+              info: { type: "object" },
+              nowMs: { type: "number" },
+              updates: { type: "array", items: { type: "object" } },
+              queries: { $ref: "#/$defs/queryRequests" }
+            },
+            additionalProperties: false
+          },
+          history: { $ref: "#/$defs/historyPage" }
+        }),
+        frame("task", ["taskRef", "request", "history"], {
+          taskRef: { $ref: "#/$defs/queryTaskRef" },
+          request: {
+            type: "object",
+            required: ["workflowFn", "info", "queries"],
+            properties: {
+              workflowFn: ID,
+              info: { type: "object" },
+              queries: { $ref: "#/$defs/queryRequests" }
+            },
+            additionalProperties: false
+          },
+          history: { $ref: "#/$defs/historyPage" }
+        }),
+        frame("task", ["taskRef", "lease"], {
+          taskRef: { $ref: "#/$defs/activityTaskRef" },
+          lease: { type: "object" }
+        })
+      ]
+    },
+    heartbeatAck: frame("heartbeatAck", ["reqId", "cancelRequested", "paused"], {
+      reqId: ID,
+      cancelRequested: { type: "boolean" },
+      paused: { type: "boolean" },
+      pauseReason: { type: "string" }
+    }),
+    cancel: frame("cancel", ["taskRef", "reason"], {
+      taskRef: { $ref: "#/$defs/taskRef" },
+      reason: { type: "string" }
+    }),
+    res: {
+      ...frame("res", ["id", "ok"], {
+        id: ID,
+        ok: { type: "boolean" },
+        result: {},
+        error: {
+          type: "object",
+          required: ["code", "message"],
+          properties: { code: { type: "string" }, message: { type: "string" } },
+          additionalProperties: false
+        }
+      }),
+      if: { properties: { ok: { const: false } }, required: ["ok"] },
+      then: { required: ["error"] }
+    },
+    pong: frame("pong", [], { t: { type: "number" } }),
+    workerFrame: {
+      oneOf: [
+        { $ref: "#/$defs/hello" },
+        { $ref: "#/$defs/ping" },
+        { $ref: "#/$defs/pollers" },
+        { $ref: "#/$defs/taskResult" },
+        { $ref: "#/$defs/taskFailed" },
+        { $ref: "#/$defs/heartbeat" },
+        { $ref: "#/$defs/workerHeartbeat" },
+        { $ref: "#/$defs/req" },
+        { $ref: "#/$defs/bye" }
+      ]
+    },
+    serviceFrame: {
+      oneOf: [
+        { $ref: "#/$defs/welcome" },
+        { $ref: "#/$defs/task" },
+        { $ref: "#/$defs/heartbeatAck" },
+        { $ref: "#/$defs/cancel" },
+        { $ref: "#/$defs/res" },
+        { $ref: "#/$defs/pong" }
+      ]
+    }
+  }
+};
+
 // src/history/schema.ts
 var BASE = "https://docs.fluidgrids.ai/schemas";
 var RUN_EVENT_SCHEMA_ID = `${BASE}/run-event.schema.json`;
@@ -10,9 +367,27 @@ var WORKFLOW_COMMAND_SCHEMA_ID = `${BASE}/workflow-command.schema.json`;
 var WORKFLOW_TASK_SCHEMA_ID = `${BASE}/workflow-task.schema.json`;
 var HISTORY_FILE_SCHEMA_ID = `${BASE}/history-file.schema.json`;
 var HISTORY_FILE_FORMAT = "fluidgrids.history";
-var ID = { type: "string", minLength: 1, maxLength: 256 };
+var ID2 = { type: "string", minLength: 1, maxLength: 256 };
 var NON_NEGATIVE_MS = { type: "integer", minimum: 0 };
-var STRING_MAP = { type: "object", additionalProperties: { type: "string" } };
+var STRING_MAP = {
+  type: "object",
+  additionalProperties: { type: "string" },
+  description: "Interceptor headers (11 \xA72.10): string values; a user activity carries at most 16 KiB of JSON (checked by validateCommands)."
+};
+var FAIRNESS_KEY = {
+  type: "string",
+  minLength: 1,
+  maxLength: FAIRNESS_KEY_MAX_LENGTH,
+  description: "Phase C: the fairness key of the task (11 \xA72.11); default the workspace id."
+};
+var FAIRNESS_WEIGHT = {
+  type: "number",
+  minimum: FAIRNESS_WEIGHT_MIN,
+  maximum: FAIRNESS_WEIGHT_MAX,
+  description: "Phase C: the weight of the fairness key, 0.1 to 10 (default 1)."
+};
+var ACTIVITY_NAME = { type: "string", pattern: ACTIVITY_NAME_PATTERN };
+var TASK_QUEUE_NAME = { type: "string", pattern: TASK_QUEUE_NAME_PATTERN };
 var SHARED_DEFS = {
   json: {
     description: "Any JSON value."
@@ -54,7 +429,7 @@ var SHARED_DEFS = {
       {
         type: "object",
         required: ["runId"],
-        properties: { runId: ID },
+        properties: { runId: ID2 },
         additionalProperties: false
       },
       {
@@ -66,14 +441,14 @@ var SHARED_DEFS = {
       {
         type: "object",
         required: ["childId"],
-        properties: { childId: ID },
+        properties: { childId: ID2 },
         additionalProperties: false
       },
       {
         type: "object",
         required: ["workflowKey", "workflowId"],
         description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).",
-        properties: { workflowKey: ID, workflowId: ID, firstRunId: ID },
+        properties: { workflowKey: ID2, workflowId: ID2, firstRunId: ID2 },
         additionalProperties: false
       }
     ]
@@ -108,8 +483,8 @@ var SHARED_DEFS = {
     properties: {
       parentClosePolicy: { enum: [...PARENT_CLOSE_POLICIES] },
       cancellationType: { enum: [...CHILD_CANCELLATION_TYPES] },
-      taskQueue: ID,
-      workflowId: ID,
+      taskQueue: ID2,
+      workflowId: ID2,
       priority: { type: "integer", minimum: 1, maximum: 5 },
       summary: { type: "string", maxLength: 200 },
       details: { type: "string" },
@@ -121,7 +496,9 @@ var SHARED_DEFS = {
       retry: { $ref: "#/$defs/runRetryPolicy" },
       versioningBehavior: { enum: [...VERSIONING_BEHAVIORS] },
       idReusePolicy: { enum: [...WORKFLOW_ID_REUSE_POLICIES] },
-      idConflictPolicy: { enum: [...WORKFLOW_ID_CONFLICT_POLICIES] }
+      idConflictPolicy: { enum: [...WORKFLOW_ID_CONFLICT_POLICIES] },
+      fairnessKey: FAIRNESS_KEY,
+      fairnessWeight: FAIRNESS_WEIGHT
     }
   },
   legacyCanRetryPolicy: {
@@ -142,7 +519,7 @@ var SHARED_DEFS = {
     type: "object",
     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.",
     properties: {
-      taskQueue: ID,
+      taskQueue: ID2,
       retry: {
         oneOf: [{ $ref: "#/$defs/runRetryPolicy" }, { $ref: "#/$defs/legacyCanRetryPolicy" }]
       },
@@ -162,41 +539,68 @@ function command(type, required, properties) {
     additionalProperties: false
   };
 }
+var ACTIVITY_COMMON = {
+  activityId: ID2,
+  args: {},
+  retry: { $ref: "#/$defs/retryPolicy" },
+  startToCloseTimeout: NON_NEGATIVE_MS,
+  scheduleToCloseTimeout: NON_NEGATIVE_MS,
+  scheduleToStartTimeout: NON_NEGATIVE_MS,
+  heartbeatTimeout: NON_NEGATIVE_MS,
+  cancellationType: { enum: [...ACTIVITY_CANCELLATION_TYPES] },
+  priority: { type: "integer", minimum: 1, maximum: 5 },
+  summary: { type: "string", maxLength: 200 },
+  fairnessKey: FAIRNESS_KEY,
+  fairnessWeight: FAIRNESS_WEIGHT
+};
+var NODE_ACTIVITY = {
+  kind: { const: "node" },
+  nodeType: ID2,
+  nodeVersion: { type: "string" },
+  operation: ID2,
+  connection: ID2,
+  runOn: { type: "string" }
+};
+var USER_ACTIVITY = {
+  kind: { const: "user" },
+  activityName: ACTIVITY_NAME,
+  taskQueue: TASK_QUEUE_NAME,
+  connections: {
+    type: "array",
+    maxItems: MAX_ACTIVITY_CONNECTIONS,
+    uniqueItems: true,
+    items: ID2,
+    description: "Connection names the worker may resolve for each started attempt (H2: declared by the definition and on the worker token allow-list)."
+  }
+};
+var NODE_ACTIVITY_REQUIRED = ["activityId", "kind", "nodeType", "operation", "args", "retry"];
+var USER_ACTIVITY_REQUIRED = ["activityId", "kind", "activityName", "taskQueue", "args", "retry"];
 var COMMAND_DEFS = {
-  SCHEDULE_ACTIVITY: command(
-    "SCHEDULE_ACTIVITY",
-    ["activityId", "kind", "nodeType", "operation", "args", "retry"],
-    {
-      activityId: ID,
-      kind: { const: "node" },
-      nodeType: ID,
-      nodeVersion: { type: "string" },
-      operation: ID,
-      args: {},
-      connection: ID,
-      retry: { $ref: "#/$defs/retryPolicy" },
-      startToCloseTimeout: NON_NEGATIVE_MS,
-      scheduleToCloseTimeout: NON_NEGATIVE_MS,
-      scheduleToStartTimeout: NON_NEGATIVE_MS,
-      heartbeatTimeout: NON_NEGATIVE_MS,
-      cancellationType: { enum: [...ACTIVITY_CANCELLATION_TYPES] },
-      priority: { type: "integer", minimum: 1, maximum: 5 },
-      summary: { type: "string", maxLength: 200 },
-      runOn: { type: "string" }
-    }
-  ),
-  REQUEST_CANCEL_ACTIVITY: command("REQUEST_CANCEL_ACTIVITY", ["activityId"], { activityId: ID }),
+  SCHEDULE_ACTIVITY: {
+    description: "A oneOf on kind (C-CMD-C): node runs a canvas node operation; user (Phase C) runs a user activity on a self-hosted task queue.",
+    oneOf: [
+      command("SCHEDULE_ACTIVITY", NODE_ACTIVITY_REQUIRED.slice(), {
+        ...ACTIVITY_COMMON,
+        ...NODE_ACTIVITY
+      }),
+      command("SCHEDULE_ACTIVITY", USER_ACTIVITY_REQUIRED.slice(), {
+        ...ACTIVITY_COMMON,
+        ...USER_ACTIVITY
+      })
+    ]
+  },
+  REQUEST_CANCEL_ACTIVITY: command("REQUEST_CANCEL_ACTIVITY", ["activityId"], { activityId: ID2 }),
   START_TIMER: command("START_TIMER", ["timerId", "durationMs"], {
-    timerId: ID,
+    timerId: ID2,
     durationMs: { type: "integer", minimum: 1 },
     summary: { type: "string", maxLength: 200 }
   }),
-  CANCEL_TIMER: command("CANCEL_TIMER", ["timerId"], { timerId: ID }),
+  CANCEL_TIMER: command("CANCEL_TIMER", ["timerId"], { timerId: ID2 }),
   START_CHILD_RUN: {
     ...command("START_CHILD_RUN", ["childId", "input", "options"], {
-      childId: ID,
-      workflowKey: ID,
-      workflowFn: ID,
+      childId: ID2,
+      workflowKey: ID2,
+      workflowFn: ID2,
       version: { type: "string", minLength: 1 },
       input: {},
       options: { $ref: "#/$defs/childOptions" }
@@ -204,16 +608,16 @@ var COMMAND_DEFS = {
     oneOf: [{ required: ["workflowKey"] }, { required: ["workflowFn"] }]
   },
   SIGNAL_RUN: command("SIGNAL_RUN", ["externalId", "target", "name", "payload"], {
-    externalId: ID,
+    externalId: ID2,
     target: { $ref: "#/$defs/runTarget" },
-    name: ID,
+    name: ID2,
     payload: {}
   }),
   RECORD_SIDE_EFFECT: command("RECORD_SIDE_EFFECT", ["sideEffectId", "value"], {
-    sideEffectId: ID,
+    sideEffectId: ID2,
     value: {}
   }),
-  RECORD_MARKER: command("RECORD_MARKER", ["markerId", "data"], { markerId: ID, data: {} }),
+  RECORD_MARKER: command("RECORD_MARKER", ["markerId", "data"], { markerId: ID2, data: {} }),
   COMPLETE_WORKFLOW: command("COMPLETE_WORKFLOW", ["output"], { output: {} }),
   FAIL_WORKFLOW: command("FAIL_WORKFLOW", ["failure"], {
     failure: { $ref: "#/$defs/failure" }
@@ -222,12 +626,12 @@ var COMMAND_DEFS = {
   UPSERT_CONTEXT: command("UPSERT_CONTEXT", ["entries"], { entries: { type: "object" } }),
   RECORD_LOCAL_ACTIVITY: {
     ...command("RECORD_LOCAL_ACTIVITY", ["localActivityId", "attempts"], {
-      localActivityId: ID,
+      localActivityId: ID2,
       result: {},
       failure: { $ref: "#/$defs/failure" },
       attempts: { type: "integer", minimum: 1 },
-      nodeType: ID,
-      operation: ID,
+      nodeType: ID2,
+      operation: ID2,
       summary: { type: "string", maxLength: 200 }
     }),
     oneOf: [{ required: ["result"] }, { required: ["failure"] }]
@@ -237,19 +641,19 @@ var COMMAND_DEFS = {
     options: { $ref: "#/$defs/canOptions" }
   }),
   REQUEST_CANCEL_EXTERNAL_RUN: command("REQUEST_CANCEL_EXTERNAL_RUN", ["externalId", "target"], {
-    externalId: ID,
+    externalId: ID2,
     target: { $ref: "#/$defs/runTarget" }
   }),
   UPSERT_SEARCH_ATTRIBUTES: command("UPSERT_SEARCH_ATTRIBUTES", ["attributes"], {
     attributes: { type: "object" }
   }),
-  ACCEPT_UPDATE: command("ACCEPT_UPDATE", ["updateId"], { updateId: ID }),
+  ACCEPT_UPDATE: command("ACCEPT_UPDATE", ["updateId"], { updateId: ID2 }),
   REJECT_UPDATE: command("REJECT_UPDATE", ["updateId", "failure"], {
-    updateId: ID,
+    updateId: ID2,
     failure: { $ref: "#/$defs/failure" }
   }),
   COMPLETE_UPDATE: command("COMPLETE_UPDATE", ["updateId"], {
-    updateId: ID,
+    updateId: ID2,
     result: {},
     failure: { $ref: "#/$defs/failure" }
   })
@@ -260,7 +664,7 @@ function payload(required, properties) {
 var FAILURE_REF = { $ref: "#/$defs/failure" };
 var EVENT_PAYLOADS = {
   WORKFLOW_STARTED: payload(["workflowFn", "input"], {
-    workflowFn: ID,
+    workflowFn: ID2,
     input: {},
     workflowKey: { type: "string" },
     version: {},
@@ -282,7 +686,7 @@ var EVENT_PAYLOADS = {
     workflowTaskTimeout: NON_NEGATIVE_MS,
     versioningBehavior: { enum: [...VERSIONING_BEHAVIORS] },
     /** Seed of `ctx.random()`/`ctx.uuid()`; the service writes the run id. Absent: `info.runId`. */
-    randomnessSeed: ID,
+    randomnessSeed: ID2,
     startDelayMs: {
       ...NON_NEGATIVE_MS,
       description: "R2: the start delay of a delayed run (11 \xA72.23); the first task waits for it."
@@ -299,14 +703,21 @@ var EVENT_PAYLOADS = {
     workflowId: { type: "string", description: "R2: the same value as businessId." },
     timeouts: { $ref: "#/$defs/timeouts" },
     retry: { $ref: "#/$defs/runRetryPolicy" },
-    priority: { type: "integer", minimum: 1, maximum: 5 }
+    priority: { type: "integer", minimum: 1, maximum: 5 },
+    headers: { $ref: "#/$defs/headers" },
+    searchAttributes: {
+      type: "object",
+      description: "Phase C: the search attributes the start set (11 \xA72.8)."
+    },
+    fairnessKey: FAIRNESS_KEY,
+    fairnessWeight: FAIRNESS_WEIGHT
   }),
   WORKFLOW_TASK_SCHEDULED: payload(["taskId"], {
-    taskId: ID,
+    taskId: ID2,
     attempt: { type: "integer", minimum: 1 }
   }),
   WORKFLOW_TASK_STARTED: payload(["taskId", "attempt"], {
-    taskId: ID,
+    taskId: ID2,
     attempt: { type: "integer", minimum: 1 },
     workerId: { type: "string" },
     buildId: { type: "string" },
@@ -324,12 +735,12 @@ var EVENT_PAYLOADS = {
     }
   }),
   WORKFLOW_TASK_COMPLETED: payload(["taskId"], {
-    taskId: ID,
+    taskId: ID2,
     buildId: { type: "string" },
     workerId: { type: "string" }
   }),
   WORKFLOW_TASK_FAILED: payload(["taskId", "attempt", "cause"], {
-    taskId: ID,
+    taskId: ID2,
     attempt: { type: "integer", minimum: 1 },
     cause: { enum: [...TASK_FAILURE_CAUSES] },
     message: { type: "string" },
@@ -337,102 +748,125 @@ var EVENT_PAYLOADS = {
     buildId: { type: "string" }
   }),
   WORKFLOW_TASK_TIMED_OUT: payload(["taskId", "attempt"], {
-    taskId: ID,
+    taskId: ID2,
     attempt: { type: "integer", minimum: 1 }
   }),
-  ACTIVITY_SCHEDULED: payload(["activityId", "kind", "nodeType", "operation", "args", "retry"], {
-    ...COMMAND_DEFS.SCHEDULE_ACTIVITY.properties,
-    type: void 0
-  }),
+  ACTIVITY_SCHEDULED: {
+    description: "The SCHEDULE_ACTIVITY command as the service accepted it: kind node, or kind user (Phase C) with activityName, taskQueue, fairness, connections and headers.",
+    oneOf: [
+      payload(NODE_ACTIVITY_REQUIRED.slice(), {
+        ...ACTIVITY_COMMON,
+        ...NODE_ACTIVITY,
+        headers: { $ref: "#/$defs/headers" }
+      }),
+      payload(USER_ACTIVITY_REQUIRED.slice(), {
+        ...ACTIVITY_COMMON,
+        ...USER_ACTIVITY,
+        headers: { $ref: "#/$defs/headers" }
+      })
+    ]
+  },
   ACTIVITY_STARTED: payload(["activityId", "attempt"], {
-    activityId: ID,
+    activityId: ID2,
     attempt: { type: "integer", minimum: 1 },
     workerId: { type: "string" }
   }),
-  ACTIVITY_HEARTBEAT: payload(["activityId"], { activityId: ID, details: {} }),
+  ACTIVITY_HEARTBEAT: payload(["activityId"], { activityId: ID2, details: {} }),
   ACTIVITY_COMPLETED: payload(["activityId", "attempt"], {
-    activityId: ID,
+    activityId: ID2,
     attempt: { type: "integer", minimum: 1 },
     result: {}
   }),
   ACTIVITY_FAILED: payload(["activityId", "attempt", "failure"], {
-    activityId: ID,
+    activityId: ID2,
     attempt: { type: "integer", minimum: 1 },
     failure: FAILURE_REF
   }),
   ACTIVITY_TIMED_OUT: payload(["activityId", "attempt", "timeoutType"], {
-    activityId: ID,
+    activityId: ID2,
     attempt: { type: "integer", minimum: 1 },
     timeoutType: {
       enum: ["START_TO_CLOSE", "SCHEDULE_TO_START", "SCHEDULE_TO_CLOSE", "HEARTBEAT"]
     },
     failure: FAILURE_REF
   }),
-  ACTIVITY_CANCEL_REQUESTED: payload(["activityId"], { activityId: ID }),
-  ACTIVITY_CANCELLED: payload(["activityId"], { activityId: ID, details: {} }),
-  ACTIVITY_PAUSED: payload(["activityId"], { activityId: ID, reason: { type: "string" } }),
-  ACTIVITY_UNPAUSED: payload(["activityId"], { activityId: ID }),
-  ACTIVITY_RESET: payload(["activityId"], { activityId: ID }),
+  ACTIVITY_CANCEL_REQUESTED: payload(["activityId"], { activityId: ID2 }),
+  ACTIVITY_CANCELLED: payload(["activityId"], { activityId: ID2, details: {} }),
+  ACTIVITY_PAUSED: payload(["activityId"], { activityId: ID2, reason: { type: "string" } }),
+  ACTIVITY_UNPAUSED: payload(["activityId"], { activityId: ID2 }),
+  ACTIVITY_RESET: payload(["activityId"], { activityId: ID2 }),
   ACTIVITY_OPTIONS_UPDATED: payload(["activityId"], {
-    activityId: ID,
+    activityId: ID2,
     options: { type: "object" }
   }),
   TIMER_STARTED: payload(["timerId", "durationMs", "fireAt"], {
-    timerId: ID,
+    timerId: ID2,
     durationMs: { type: "integer", minimum: 1 },
     fireAt: { type: "string" },
     summary: { type: "string" }
   }),
-  TIMER_FIRED: payload(["timerId"], { timerId: ID }),
-  TIMER_CANCELLED: payload(["timerId"], { timerId: ID }),
+  TIMER_FIRED: payload(["timerId"], { timerId: ID2 }),
+  TIMER_CANCELLED: payload(["timerId"], { timerId: ID2 }),
   SIGNAL_RECEIVED: payload(["name"], {
-    name: ID,
+    name: ID2,
     payload: {},
     receivedAt: { type: "string" },
     actor: {},
-    idempotencyKey: { type: "string" }
+    idempotencyKey: { type: "string" },
+    headers: { $ref: "#/$defs/headers" }
+  }),
+  UPDATE_ADMITTED: payload(["updateId", "name"], {
+    updateId: ID2,
+    name: ID2,
+    args: {},
+    headers: { $ref: "#/$defs/headers" }
   }),
-  UPDATE_ADMITTED: payload(["updateId", "name"], { updateId: ID, name: ID, args: {} }),
-  UPDATE_ACCEPTED: payload(["updateId", "name"], { updateId: ID, name: ID, args: {} }),
-  UPDATE_COMPLETED: payload(["updateId"], { updateId: ID, result: {}, failure: FAILURE_REF }),
+  UPDATE_ACCEPTED: payload(["updateId", "name"], {
+    updateId: ID2,
+    name: ID2,
+    args: {},
+    headers: { $ref: "#/$defs/headers" }
+  }),
+  UPDATE_COMPLETED: payload(["updateId"], { updateId: ID2, result: {}, failure: FAILURE_REF }),
   CHILD_RUN_INITIATED: payload(["childId", "input", "options"], {
-    childId: ID,
-    workflowKey: ID,
-    workflowFn: ID,
+    childId: ID2,
+    workflowKey: ID2,
+    workflowFn: ID2,
     version: { type: "string" },
     input: {},
     options: { $ref: "#/$defs/childOptions" },
     childRunId: { type: "string" },
-    executionKind: { enum: ["GRAPH", "DURABLE_FN"] }
+    executionKind: { enum: ["GRAPH", "DURABLE_FN"] },
+    headers: { $ref: "#/$defs/headers" }
   }),
   CHILD_RUN_STARTED: payload(["childId", "childRunId"], {
-    childId: ID,
-    childRunId: ID,
+    childId: ID2,
+    childRunId: ID2,
     executionKind: { enum: ["GRAPH", "DURABLE_FN"] }
   }),
-  CHILD_RUN_COMPLETED: payload(["childId"], { childId: ID, childRunId: ID, result: {} }),
+  CHILD_RUN_COMPLETED: payload(["childId"], { childId: ID2, childRunId: ID2, result: {} }),
   CHILD_RUN_FAILED: payload(["childId", "failure"], {
-    childId: ID,
-    childRunId: ID,
+    childId: ID2,
+    childRunId: ID2,
     failure: FAILURE_REF
   }),
-  CHILD_RUN_CANCELLED: payload(["childId"], { childId: ID, childRunId: ID }),
+  CHILD_RUN_CANCELLED: payload(["childId"], { childId: ID2, childRunId: ID2 }),
   CHILD_RUN_TERMINATED: payload(["childId"], {
-    childId: ID,
-    childRunId: ID,
+    childId: ID2,
+    childRunId: ID2,
     reason: { type: "string" }
   }),
   CHILD_RUN_TIMED_OUT: payload(["childId"], {
-    childId: ID,
-    childRunId: ID,
+    childId: ID2,
+    childRunId: ID2,
     timeoutType: { enum: [...WORKFLOW_TIMEOUT_TYPES] }
   }),
   EXTERNAL_RUN_CANCEL_REQUESTED: payload(["externalId", "target"], {
-    externalId: ID,
+    externalId: ID2,
     target: { $ref: "#/$defs/runTarget" }
   }),
   EXTERNAL_RUN_CANCEL_RESOLVED: payload(["externalId", "ok"], {
-    externalId: ID,
+    externalId: ID2,
     ok: { type: "boolean" },
     targetRunId: { type: "string" },
     failure: FAILURE_REF
@@ -442,9 +876,9 @@ var EVENT_PAYLOADS = {
     required: ["externalId"],
     description: "Two forms. Initiated (appended for the SIGNAL_RUN command): {externalId, target, name, payload}. Resolved (appended by the service after delivery, dedupeKey signal-out:<runId>:<externalId>): {externalId, resolved: true, ok, failure?, targetRunId?}.",
     properties: {
-      externalId: ID,
+      externalId: ID2,
       target: { $ref: "#/$defs/runTarget" },
-      name: ID,
+      name: ID2,
       payload: {},
       resolved: { const: true },
       ok: { type: "boolean" },
@@ -455,34 +889,37 @@ var EVENT_PAYLOADS = {
     then: { required: ["ok"] },
     else: { required: ["target", "name"] }
   },
-  SIDE_EFFECT_RECORDED: payload(["sideEffectId", "value"], { sideEffectId: ID, value: {} }),
+  SIDE_EFFECT_RECORDED: payload(["sideEffectId", "value"], { sideEffectId: ID2, value: {} }),
   LOCAL_ACTIVITY_COMPLETED: payload(["localActivityId", "attempts"], {
-    localActivityId: ID,
+    localActivityId: ID2,
     result: {},
     attempts: { type: "integer", minimum: 1 },
-    nodeType: ID,
-    operation: ID,
+    nodeType: ID2,
+    operation: ID2,
     summary: { type: "string" }
   }),
   LOCAL_ACTIVITY_FAILED: payload(["localActivityId", "attempts", "failure"], {
-    localActivityId: ID,
+    localActivityId: ID2,
     failure: FAILURE_REF,
     attempts: { type: "integer", minimum: 1 },
-    nodeType: ID,
-    operation: ID,
+    nodeType: ID2,
+    operation: ID2,
     summary: { type: "string" }
   }),
   SEARCH_ATTRIBUTES_UPSERTED: payload(["attributes"], { attributes: { type: "object" } }),
   CONTEXT_UPSERTED: payload(["entries"], { entries: { type: "object" } }),
   MARKER_RECORDED: payload(["markerId", "data"], {
-    markerId: ID,
+    markerId: ID2,
     data: {}
   }),
   WORKFLOW_CANCEL_REQUESTED: payload([], { actor: {}, reason: { type: "string" } }),
   WORKFLOW_RESET: payload(["fromRunId", "toSeq"], {
-    fromRunId: ID,
+    fromRunId: ID2,
     toSeq: { type: "integer", minimum: 1 },
-    reason: { type: "string" }
+    reason: { type: "string" },
+    actor: {},
+    reapplySignals: { type: "boolean" },
+    reapplyUpdates: { type: "boolean" }
   }),
   VERSIONING_OVERRIDE_SET: payload(["override"], {
     override: {
@@ -581,7 +1018,7 @@ var WORKFLOW_COMMAND_SCHEMA = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
   $id: WORKFLOW_COMMAND_SCHEMA_ID,
   title: "FluidGrids workflow-task command",
-  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.",
+  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).",
   ...COMMAND_ONE_OF,
   $defs: { ...SHARED_DEFS, ...commandDefs() }
 };
@@ -601,8 +1038,8 @@ var WORKFLOW_TASK_SCHEMA = {
       type: "object",
       required: ["runId", "workspaceId"],
       properties: {
-        runId: ID,
-        workspaceId: ID,
+        runId: ID2,
+        workspaceId: ID2,
         workflowKey: { type: "string" },
         version: {},
         buildId: { type: "string" },
@@ -635,9 +1072,36 @@ var WORKFLOW_TASK_SCHEMA = {
         context: { type: "object" },
         memo: { type: "object" },
         versioningBehavior: { enum: [...VERSIONING_BEHAVIORS] },
-        retry: { $ref: "#/$defs/runRetryPolicy" }
+        retry: { $ref: "#/$defs/runRetryPolicy" },
+        searchAttributes: { type: "object" },
+        fairnessKey: FAIRNESS_KEY,
+        fairnessWeight: FAIRNESS_WEIGHT
       }
     },
+    updateRequest: {
+      type: "object",
+      required: ["updateId", "name"],
+      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.",
+      properties: {
+        updateId: ID2,
+        name: ID2,
+        args: {},
+        admitted: { type: "boolean" },
+        headers: { $ref: "#/$defs/headers" }
+      },
+      additionalProperties: false
+    },
+    sinkCall: {
+      type: "object",
+      required: ["sink", "fn", "args"],
+      description: "Phase C: a call of ctx.sinks.<sink>.<fn>(...args), never made on replay.",
+      properties: {
+        sink: ID2,
+        fn: ID2,
+        args: { type: "array" }
+      },
+      additionalProperties: false
+    },
     localActivityRequest: {
       type: "object",
       required: [
@@ -653,13 +1117,13 @@ var WORKFLOW_TASK_SCHEMA = {
       ],
       description: "R2: a local activity the task needs (11 \xA72.12). Run attempt `attempt` after waiting backoffMs, then run the same task again with the outcome in localActivityResults.",
       properties: {
-        localActivityId: ID,
+        localActivityId: ID2,
         kind: { const: "node" },
-        nodeType: ID,
+        nodeType: ID2,
         nodeVersion: { type: "string" },
-        operation: ID,
+        operation: ID2,
         args: {},
-        connection: ID,
+        connection: ID2,
         retry: { $ref: "#/$defs/retryPolicy" },
         startToCloseTimeout: {
           type: "integer",
@@ -678,7 +1142,7 @@ var WORKFLOW_TASK_SCHEMA = {
       properties: {
         protocol: { const: HISTORY_PROTOCOL },
         kind: { enum: ["task", "query", "verify"] },
-        workflowFn: ID,
+        workflowFn: ID2,
         info: { $ref: "#/$defs/info" },
         history: { type: "array", items: { $ref: "#/$defs/event" } },
         nowMs: { type: "number" },
@@ -688,24 +1152,37 @@ var WORKFLOW_TASK_SCHEMA = {
             type: "object",
             required: ["localActivityId", "attempts"],
             properties: {
-              localActivityId: ID,
+              localActivityId: ID2,
               result: {},
               failure: FAILURE_REF,
               attempts: { type: "integer", minimum: 1 }
             }
           }
         },
+        updates: {
+          type: "array",
+          items: { $ref: "#/$defs/updateRequest" }
+        },
         queries: {
           type: "array",
           items: {
             type: "object",
             required: ["queryId", "name"],
             properties: {
-              queryId: ID,
-              name: { enum: [...BUILT_IN_QUERIES] },
+              queryId: ID2,
+              name: {
+                ...ID2,
+                description: `A built-in query (${BUILT_IN_QUERIES.join(", ")}) or, from C-R1, the name of a custom query.`
+              },
               args: {}
             }
           }
+        },
+        features: {
+          type: "array",
+          items: { type: "string", minLength: 1 },
+          uniqueItems: true,
+          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."
         }
       }
     },
@@ -739,9 +1216,22 @@ var WORKFLOW_TASK_SCHEMA = {
           items: {
             type: "object",
             required: ["queryId"],
-            properties: { queryId: ID, value: {}, error: { type: "string" } }
+            properties: {
+              queryId: ID2,
+              value: {},
+              error: { type: "string" },
+              rejected: {
+                type: "boolean",
+                description: "Phase C: no handler took the query name (the service answers VALIDATION)."
+              }
+            }
           }
         },
+        sinkCalls: {
+          type: "array",
+          maxItems: MAX_SINK_CALLS,
+          items: { $ref: "#/$defs/sinkCall" }
+        },
         failure: {
           type: "object",
           required: ["cause", "message"],
@@ -781,7 +1271,7 @@ var HISTORY_FILE_SCHEMA = {
     formatVersion: { const: HISTORY_PROTOCOL },
     name: { type: "string" },
     description: { type: "string" },
-    workflowFn: ID,
+    workflowFn: ID2,
     source: { type: "string", description: "Fixture source module, relative to the file." },
     replaySource: {
       type: "string",
@@ -789,7 +1279,7 @@ var HISTORY_FILE_SCHEMA = {
     },
     replay: {
       type: "boolean",
-      description: "False for histories that use Phase C features (updates); they are parsed and projected but not replayed."
+      description: "False for histories that are parsed and projected but not replayed (written by hand for a feature the recording runtime did not have)."
     },
     info: { $ref: "#/$defs/info" },
     nowMs: {
@@ -813,7 +1303,9 @@ var HISTORY_SCHEMA_FILES = [
   ["run-event.schema.json", RUN_EVENT_SCHEMA],
   ["workflow-command.schema.json", WORKFLOW_COMMAND_SCHEMA],
   ["workflow-task.schema.json", WORKFLOW_TASK_SCHEMA],
-  ["history-file.schema.json", HISTORY_FILE_SCHEMA]
+  ["history-file.schema.json", HISTORY_FILE_SCHEMA],
+  ["bridge-v2.schema.json", BRIDGE_V2_SCHEMA],
+  ["payload-fields.json", PAYLOAD_FIELDS_DOCUMENT]
 ];
 var tools;
 function schemaTools() {
@@ -823,7 +1315,8 @@ function schemaTools() {
       ajv,
       command: ajv.compile(WORKFLOW_COMMAND_SCHEMA),
       event: ajv.compile(RUN_EVENT_SCHEMA),
-      file: ajv.compile(HISTORY_FILE_SCHEMA)
+      file: ajv.compile(HISTORY_FILE_SCHEMA),
+      bridge: ajv.compile(BRIDGE_V2_SCHEMA)
     };
   }
   return tools;
@@ -916,13 +1409,20 @@ function validateCommands(commands, options = {}) {
         code: "commands.terminalNotLast",
         message: `${command2.type} must be the last command of the batch`
       });
-    if (command2.type === "SCHEDULE_ACTIVITY" && !isActivityNodeTypeAllowed(command2.nodeType))
+    if (command2.type === "SCHEDULE_ACTIVITY" && command2.kind === "node" && !isActivityNodeTypeAllowed(command2.nodeType))
       issues.push({
         index,
         code: "durable.activityTypeNotAllowed",
         message: `${command2.nodeType} cannot run as a durable activity`,
         path: "/nodeType"
       });
+    if (command2.type === "SCHEDULE_ACTIVITY" && command2.kind === "user" && command2.headers !== void 0 && utf8Bytes(JSON.stringify(command2.headers)) > MAX_HEADERS_BYTES)
+      issues.push({
+        index,
+        code: "commands.headersTooLarge",
+        message: `The headers of ${command2.type} exceed ${MAX_HEADERS_BYTES} bytes`,
+        path: "/headers"
+      });
     valid.push(command2);
   });
   if (issues.length > 0)
@@ -956,6 +1456,11 @@ function validateHistoryFile(value) {
   if (validate(value)) return validateHistory(isRecord(value) ? value["events"] : void 0);
   return { ok: false, issues: issuesOf(0, validate.errors) };
 }
+function validateBridgeFrame(value) {
+  const { bridge: validate } = schemaTools();
+  if (validate(value)) return { ok: true, frame: value };
+  return { ok: false, issues: issuesOf(0, validate.errors) };
+}
 function compilePayloadValidator(schema) {
   const { ajv } = schemaTools();
   const validate = ajv.compile(schema);
@@ -1014,4 +1519,4 @@ function serializeHistoryFile(file) {
 `;
 }
 
-export { HISTORY_FILE_FORMAT, HISTORY_FILE_SCHEMA, HISTORY_FILE_SCHEMA_ID, HISTORY_SCHEMA_FILES, HistoryFileError, RUN_EVENT_SCHEMA, RUN_EVENT_SCHEMA_ID, WORKFLOW_COMMAND_SCHEMA, WORKFLOW_COMMAND_SCHEMA_ID, WORKFLOW_TASK_SCHEMA, WORKFLOW_TASK_SCHEMA_ID, compilePayloadValidator, createHistoryFile, parseHistoryFile, serializeHistoryFile, validateCommand, validateCommands, validateHistory, validateHistoryFile };
+export { 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, BridgeCloseCode, HISTORY_FILE_FORMAT, HISTORY_FILE_SCHEMA, HISTORY_FILE_SCHEMA_ID, HISTORY_SCHEMA_FILES, HistoryFileError, RUN_EVENT_SCHEMA, RUN_EVENT_SCHEMA_ID, WORKFLOW_COMMAND_SCHEMA, WORKFLOW_COMMAND_SCHEMA_ID, WORKFLOW_TASK_SCHEMA, WORKFLOW_TASK_SCHEMA_ID, compilePayloadValidator, createHistoryFile, parseHistoryFile, serializeHistoryFile, validateBridgeFrame, validateCommand, validateCommands, validateHistory, validateHistoryFile };