@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/chunk-YEHR4NNE.js

@@ -0,0 +1,1522 @@
+import { PAYLOAD_FIELDS_DOCUMENT } from './chunk-VU5S5A7V.js';
+import { isRecord } from './chunk-PMCM2OH4.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`;
+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 ID2 = { type: "string", minLength: 1, maxLength: 256 };
+var NON_NEGATIVE_MS = { type: "integer", minimum: 0 };
+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."
+  },
+  failure: {
+    type: "object",
+    required: ["errorType", "message"],
+    properties: {
+      errorType: { enum: [...ERROR_TYPES] },
+      message: { type: "string" },
+      type: { type: "string" },
+      details: {},
+      nonRetryable: { type: "boolean" },
+      nextRetryDelayMs: NON_NEGATIVE_MS,
+      category: { const: "BENIGN" },
+      timeoutType: { type: "string" },
+      cause: { $ref: "#/$defs/failure" },
+      stackTrace: { type: "string" },
+      source: { type: "string" }
+    },
+    additionalProperties: false
+  },
+  retryPolicy: {
+    type: "object",
+    required: ["retryDelay"],
+    description: "maxRetries absent means unlimited attempts, bounded by scheduleToCloseTimeout.",
+    properties: {
+      maxRetries: { type: "integer", minimum: 0 },
+      retryDelay: NON_NEGATIVE_MS,
+      backoffMultiplier: { type: "number", minimum: 1 },
+      maxDelay: NON_NEGATIVE_MS,
+      retryOnErrorTypes: { type: "array", items: { enum: [...ERROR_TYPES] } },
+      nonRetryableErrorTypes: { type: "array", items: { type: "string" } }
+    },
+    additionalProperties: false
+  },
+  runTarget: {
+    oneOf: [
+      {
+        type: "object",
+        required: ["runId"],
+        properties: { runId: ID2 },
+        additionalProperties: false
+      },
+      {
+        type: "object",
+        required: ["parent"],
+        properties: { parent: { const: true } },
+        additionalProperties: false
+      },
+      {
+        type: "object",
+        required: ["childId"],
+        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: ID2, workflowId: ID2, firstRunId: ID2 },
+        additionalProperties: false
+      }
+    ]
+  },
+  runRetryPolicy: {
+    type: "object",
+    required: ["initialDelayMs"],
+    description: "Run-level retry (11 \xA72.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.",
+    properties: {
+      maxAttempts: { type: "integer", minimum: 1 },
+      initialDelayMs: NON_NEGATIVE_MS,
+      backoffMultiplier: { type: "number", minimum: 1 },
+      maxDelayMs: NON_NEGATIVE_MS,
+      retryOnErrorTypes: { type: "array", items: { enum: [...ERROR_TYPES] } },
+      nonRetryableErrorTypes: { type: "array", items: { type: "string" } }
+    },
+    additionalProperties: false
+  },
+  timeouts: {
+    type: "object",
+    description: "The three workflow timeouts (11 \xA72.20), in milliseconds.",
+    properties: {
+      executionTimeout: NON_NEGATIVE_MS,
+      runTimeout: NON_NEGATIVE_MS,
+      workflowTaskTimeout: NON_NEGATIVE_MS
+    },
+    additionalProperties: false
+  },
+  childOptions: {
+    type: "object",
+    required: ["parentClosePolicy"],
+    properties: {
+      parentClosePolicy: { enum: [...PARENT_CLOSE_POLICIES] },
+      cancellationType: { enum: [...CHILD_CANCELLATION_TYPES] },
+      taskQueue: ID2,
+      workflowId: ID2,
+      priority: { type: "integer", minimum: 1, maximum: 5 },
+      summary: { type: "string", maxLength: 200 },
+      details: { type: "string" },
+      context: { type: "object" },
+      executionTimeout: NON_NEGATIVE_MS,
+      runTimeout: NON_NEGATIVE_MS,
+      workflowTaskTimeout: NON_NEGATIVE_MS,
+      startDelay: NON_NEGATIVE_MS,
+      retry: { $ref: "#/$defs/runRetryPolicy" },
+      versioningBehavior: { enum: [...VERSIONING_BEHAVIORS] },
+      idReusePolicy: { enum: [...WORKFLOW_ID_REUSE_POLICIES] },
+      idConflictPolicy: { enum: [...WORKFLOW_ID_CONFLICT_POLICIES] },
+      fairnessKey: FAIRNESS_KEY,
+      fairnessWeight: FAIRNESS_WEIGHT
+    }
+  },
+  legacyCanRetryPolicy: {
+    type: "object",
+    required: ["retryDelay"],
+    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.",
+    properties: {
+      maxRetries: { type: "number" },
+      retryDelay: { type: "number" },
+      backoffMultiplier: { type: "number" },
+      maxDelay: { type: "number" },
+      retryOnErrorTypes: { type: "array", items: { type: "string" } },
+      nonRetryableErrorTypes: { type: "array", items: { type: "string" } }
+    },
+    additionalProperties: false
+  },
+  canOptions: {
+    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: ID2,
+      retry: {
+        oneOf: [{ $ref: "#/$defs/runRetryPolicy" }, { $ref: "#/$defs/legacyCanRetryPolicy" }]
+      },
+      workflowTaskTimeout: NON_NEGATIVE_MS,
+      context: { type: "object" },
+      versioningBehavior: { enum: [...VERSIONING_BEHAVIORS] }
+    },
+    additionalProperties: false
+  },
+  headers: STRING_MAP
+};
+function command(type, required, properties) {
+  return {
+    type: "object",
+    required: ["type", ...required],
+    properties: { type: { const: type }, headers: { $ref: "#/$defs/headers" }, ...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: {
+    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: ID2,
+    durationMs: { type: "integer", minimum: 1 },
+    summary: { type: "string", maxLength: 200 }
+  }),
+  CANCEL_TIMER: command("CANCEL_TIMER", ["timerId"], { timerId: ID2 }),
+  START_CHILD_RUN: {
+    ...command("START_CHILD_RUN", ["childId", "input", "options"], {
+      childId: ID2,
+      workflowKey: ID2,
+      workflowFn: ID2,
+      version: { type: "string", minLength: 1 },
+      input: {},
+      options: { $ref: "#/$defs/childOptions" }
+    }),
+    oneOf: [{ required: ["workflowKey"] }, { required: ["workflowFn"] }]
+  },
+  SIGNAL_RUN: command("SIGNAL_RUN", ["externalId", "target", "name", "payload"], {
+    externalId: ID2,
+    target: { $ref: "#/$defs/runTarget" },
+    name: ID2,
+    payload: {}
+  }),
+  RECORD_SIDE_EFFECT: command("RECORD_SIDE_EFFECT", ["sideEffectId", "value"], {
+    sideEffectId: ID2,
+    value: {}
+  }),
+  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" }
+  }),
+  CANCEL_WORKFLOW: command("CANCEL_WORKFLOW", [], {}),
+  UPSERT_CONTEXT: command("UPSERT_CONTEXT", ["entries"], { entries: { type: "object" } }),
+  RECORD_LOCAL_ACTIVITY: {
+    ...command("RECORD_LOCAL_ACTIVITY", ["localActivityId", "attempts"], {
+      localActivityId: ID2,
+      result: {},
+      failure: { $ref: "#/$defs/failure" },
+      attempts: { type: "integer", minimum: 1 },
+      nodeType: ID2,
+      operation: ID2,
+      summary: { type: "string", maxLength: 200 }
+    }),
+    oneOf: [{ required: ["result"] }, { required: ["failure"] }]
+  },
+  CONTINUE_AS_NEW: command("CONTINUE_AS_NEW", ["input", "options"], {
+    input: {},
+    options: { $ref: "#/$defs/canOptions" }
+  }),
+  REQUEST_CANCEL_EXTERNAL_RUN: command("REQUEST_CANCEL_EXTERNAL_RUN", ["externalId", "target"], {
+    externalId: ID2,
+    target: { $ref: "#/$defs/runTarget" }
+  }),
+  UPSERT_SEARCH_ATTRIBUTES: command("UPSERT_SEARCH_ATTRIBUTES", ["attributes"], {
+    attributes: { type: "object" }
+  }),
+  ACCEPT_UPDATE: command("ACCEPT_UPDATE", ["updateId"], { updateId: ID2 }),
+  REJECT_UPDATE: command("REJECT_UPDATE", ["updateId", "failure"], {
+    updateId: ID2,
+    failure: { $ref: "#/$defs/failure" }
+  }),
+  COMPLETE_UPDATE: command("COMPLETE_UPDATE", ["updateId"], {
+    updateId: ID2,
+    result: {},
+    failure: { $ref: "#/$defs/failure" }
+  })
+};
+function payload(required, properties) {
+  return { type: "object", required, properties };
+}
+var FAILURE_REF = { $ref: "#/$defs/failure" };
+var EVENT_PAYLOADS = {
+  WORKFLOW_STARTED: payload(["workflowFn", "input"], {
+    workflowFn: ID2,
+    input: {},
+    workflowKey: { type: "string" },
+    version: {},
+    buildId: { type: "string" },
+    taskQueue: { type: "string" },
+    parentRunId: { type: ["string", "null"] },
+    rootRunId: { type: ["string", "null"] },
+    firstRunId: { type: ["string", "null"] },
+    continuedFromRunId: { type: ["string", "null"] },
+    parentClosePolicy: { enum: [...PARENT_CLOSE_POLICIES] },
+    startDelay: NON_NEGATIVE_MS,
+    lastCompletionResult: {},
+    lastFailure: { oneOf: [{ type: "null" }, FAILURE_REF] },
+    summary: { type: "string" },
+    details: { type: "string" },
+    context: { type: "object" },
+    executionTimeout: NON_NEGATIVE_MS,
+    runTimeout: NON_NEGATIVE_MS,
+    workflowTaskTimeout: NON_NEGATIVE_MS,
+    versioningBehavior: { enum: [...VERSIONING_BEHAVIORS] },
+    /** Seed of `ctx.random()`/`ctx.uuid()`; the service writes the run id. Absent: `info.runId`. */
+    randomnessSeed: ID2,
+    startDelayMs: {
+      ...NON_NEGATIVE_MS,
+      description: "R2: the start delay of a delayed run (11 \xA72.23); the first task waits for it."
+    },
+    runAttempt: {
+      type: "integer",
+      minimum: 1,
+      description: "R2: the run-level retry attempt (11 \xA72.17), 1-based."
+    },
+    businessId: {
+      type: "string",
+      description: "R2: the workflow id (11 \xA72.1), stored as WorkflowRun.businessId."
+    },
+    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 },
+    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: ID2,
+    attempt: { type: "integer", minimum: 1 }
+  }),
+  WORKFLOW_TASK_STARTED: payload(["taskId", "attempt"], {
+    taskId: ID2,
+    attempt: { type: "integer", minimum: 1 },
+    workerId: { type: "string" },
+    buildId: { type: "string" },
+    startedAt: {
+      type: "string",
+      description: "When the attempt started, if different from the event time (a transient attempt is recorded at completion). This is the clock the task saw: nowMs of its request."
+    },
+    historyLength: {
+      type: "integer",
+      minimum: 1,
+      description: "The history length the attempt was leased with (run.taskStartedSeq), when it is not this event's own seq. Required on the WORKFLOW_TASK_STARTED of a transient attempt: input events with a higher seq that precede this event arrived during the attempt and belong to the next activation."
+    },
+    version: {
+      description: "R2: the workflow version whose bundle served the task (it differs from WORKFLOW_STARTED.version after an AUTO_UPGRADE or a versioning override)."
+    }
+  }),
+  WORKFLOW_TASK_COMPLETED: payload(["taskId"], {
+    taskId: ID2,
+    buildId: { type: "string" },
+    workerId: { type: "string" }
+  }),
+  WORKFLOW_TASK_FAILED: payload(["taskId", "attempt", "cause"], {
+    taskId: ID2,
+    attempt: { type: "integer", minimum: 1 },
+    cause: { enum: [...TASK_FAILURE_CAUSES] },
+    message: { type: "string" },
+    stackTrace: { type: "string" },
+    buildId: { type: "string" }
+  }),
+  WORKFLOW_TASK_TIMED_OUT: payload(["taskId", "attempt"], {
+    taskId: ID2,
+    attempt: { type: "integer", minimum: 1 }
+  }),
+  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: ID2,
+    attempt: { type: "integer", minimum: 1 },
+    workerId: { type: "string" }
+  }),
+  ACTIVITY_HEARTBEAT: payload(["activityId"], { activityId: ID2, details: {} }),
+  ACTIVITY_COMPLETED: payload(["activityId", "attempt"], {
+    activityId: ID2,
+    attempt: { type: "integer", minimum: 1 },
+    result: {}
+  }),
+  ACTIVITY_FAILED: payload(["activityId", "attempt", "failure"], {
+    activityId: ID2,
+    attempt: { type: "integer", minimum: 1 },
+    failure: FAILURE_REF
+  }),
+  ACTIVITY_TIMED_OUT: payload(["activityId", "attempt", "timeoutType"], {
+    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: 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: ID2,
+    options: { type: "object" }
+  }),
+  TIMER_STARTED: payload(["timerId", "durationMs", "fireAt"], {
+    timerId: ID2,
+    durationMs: { type: "integer", minimum: 1 },
+    fireAt: { type: "string" },
+    summary: { type: "string" }
+  }),
+  TIMER_FIRED: payload(["timerId"], { timerId: ID2 }),
+  TIMER_CANCELLED: payload(["timerId"], { timerId: ID2 }),
+  SIGNAL_RECEIVED: payload(["name"], {
+    name: ID2,
+    payload: {},
+    receivedAt: { type: "string" },
+    actor: {},
+    idempotencyKey: { type: "string" },
+    headers: { $ref: "#/$defs/headers" }
+  }),
+  UPDATE_ADMITTED: payload(["updateId", "name"], {
+    updateId: ID2,
+    name: ID2,
+    args: {},
+    headers: { $ref: "#/$defs/headers" }
+  }),
+  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: ID2,
+    workflowKey: ID2,
+    workflowFn: ID2,
+    version: { type: "string" },
+    input: {},
+    options: { $ref: "#/$defs/childOptions" },
+    childRunId: { type: "string" },
+    executionKind: { enum: ["GRAPH", "DURABLE_FN"] },
+    headers: { $ref: "#/$defs/headers" }
+  }),
+  CHILD_RUN_STARTED: payload(["childId", "childRunId"], {
+    childId: ID2,
+    childRunId: ID2,
+    executionKind: { enum: ["GRAPH", "DURABLE_FN"] }
+  }),
+  CHILD_RUN_COMPLETED: payload(["childId"], { childId: ID2, childRunId: ID2, result: {} }),
+  CHILD_RUN_FAILED: payload(["childId", "failure"], {
+    childId: ID2,
+    childRunId: ID2,
+    failure: FAILURE_REF
+  }),
+  CHILD_RUN_CANCELLED: payload(["childId"], { childId: ID2, childRunId: ID2 }),
+  CHILD_RUN_TERMINATED: payload(["childId"], {
+    childId: ID2,
+    childRunId: ID2,
+    reason: { type: "string" }
+  }),
+  CHILD_RUN_TIMED_OUT: payload(["childId"], {
+    childId: ID2,
+    childRunId: ID2,
+    timeoutType: { enum: [...WORKFLOW_TIMEOUT_TYPES] }
+  }),
+  EXTERNAL_RUN_CANCEL_REQUESTED: payload(["externalId", "target"], {
+    externalId: ID2,
+    target: { $ref: "#/$defs/runTarget" }
+  }),
+  EXTERNAL_RUN_CANCEL_RESOLVED: payload(["externalId", "ok"], {
+    externalId: ID2,
+    ok: { type: "boolean" },
+    targetRunId: { type: "string" },
+    failure: FAILURE_REF
+  }),
+  EXTERNAL_RUN_SIGNALED: {
+    type: "object",
+    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: ID2,
+      target: { $ref: "#/$defs/runTarget" },
+      name: ID2,
+      payload: {},
+      resolved: { const: true },
+      ok: { type: "boolean" },
+      targetRunId: { type: "string" },
+      failure: FAILURE_REF
+    },
+    if: { required: ["resolved"] },
+    then: { required: ["ok"] },
+    else: { required: ["target", "name"] }
+  },
+  SIDE_EFFECT_RECORDED: payload(["sideEffectId", "value"], { sideEffectId: ID2, value: {} }),
+  LOCAL_ACTIVITY_COMPLETED: payload(["localActivityId", "attempts"], {
+    localActivityId: ID2,
+    result: {},
+    attempts: { type: "integer", minimum: 1 },
+    nodeType: ID2,
+    operation: ID2,
+    summary: { type: "string" }
+  }),
+  LOCAL_ACTIVITY_FAILED: payload(["localActivityId", "attempts", "failure"], {
+    localActivityId: ID2,
+    failure: FAILURE_REF,
+    attempts: { type: "integer", minimum: 1 },
+    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: ID2,
+    data: {}
+  }),
+  WORKFLOW_CANCEL_REQUESTED: payload([], { actor: {}, reason: { type: "string" } }),
+  WORKFLOW_RESET: payload(["fromRunId", "toSeq"], {
+    fromRunId: ID2,
+    toSeq: { type: "integer", minimum: 1 },
+    reason: { type: "string" },
+    actor: {},
+    reapplySignals: { type: "boolean" },
+    reapplyUpdates: { type: "boolean" }
+  }),
+  VERSIONING_OVERRIDE_SET: payload(["override"], {
+    override: {
+      description: "The per-run override (11 \xA72.27): { behavior: PINNED, version } pins the run, { behavior: AUTO_UPGRADE } upgrades it, null removes the override.",
+      oneOf: [
+        { type: "null" },
+        {
+          type: "object",
+          required: ["behavior", "version"],
+          properties: { behavior: { const: "PINNED" }, version: {} },
+          additionalProperties: false
+        },
+        {
+          type: "object",
+          required: ["behavior"],
+          properties: { behavior: { const: "AUTO_UPGRADE" } },
+          additionalProperties: false
+        }
+      ]
+    },
+    actor: {},
+    reason: { type: "string" }
+  }),
+  WORKFLOW_COMPLETED: payload(["output"], { output: {} }),
+  WORKFLOW_FAILED: payload(["failure"], { failure: FAILURE_REF }),
+  WORKFLOW_CANCELLED: payload([], { details: {} }),
+  WORKFLOW_TERMINATED: payload([], { reason: { type: "string" }, actor: {} }),
+  WORKFLOW_TIMED_OUT: payload(["timeoutType"], {
+    timeoutType: { enum: [...WORKFLOW_TIMEOUT_TYPES] },
+    failure: FAILURE_REF
+  }),
+  WORKFLOW_CONTINUED_AS_NEW: payload(["input", "options"], {
+    input: {},
+    // Not canOptions: the event keeps what the service accepted when the run
+    // continued, and Phase B (R1) runs stored options that the R2 command shape
+    // refuses (fractional delays, a backoff below 1, a long task queue).
+    options: {
+      type: "object",
+      description: "The CONTINUE_AS_NEW options as the service recorded them. New commands are checked against canOptions; histories recorded before R2 may hold any object the R1 contract accepted."
+    },
+    newRunId: { type: "string" }
+  })
+};
+function compact(value) {
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === void 0) continue;
+    out[key] = typeof entry === "object" && entry !== null && !Array.isArray(entry) ? compact(entry) : entry;
+  }
+  return out;
+}
+var RUN_EVENT_RECORD = {
+  type: "object",
+  required: ["seq", "type", "payload", "createdAt"],
+  properties: {
+    seq: { type: "integer", minimum: 1 },
+    type: { enum: [...EVENT_TYPES] },
+    taskId: { type: ["string", "null"] },
+    payload: { type: "object" },
+    createdAt: { type: "string", minLength: 1 },
+    dedupeKey: { type: ["string", "null"] }
+  },
+  allOf: EVENT_TYPES.map((type) => ({
+    if: { properties: { type: { const: type } }, required: ["type"] },
+    then: { properties: { payload: { $ref: `#/$defs/payload_${type}` } } }
+  }))
+};
+function payloadDefs() {
+  const defs = {};
+  for (const type of EVENT_TYPES) defs[`payload_${type}`] = compact(EVENT_PAYLOADS[type]);
+  return defs;
+}
+function commandDefs() {
+  const defs = {};
+  for (const type of COMMAND_TYPES) defs[`command_${type}`] = COMMAND_DEFS[type];
+  return defs;
+}
+var COMMAND_ONE_OF = {
+  type: "object",
+  required: ["type"],
+  properties: { type: { enum: [...COMMAND_TYPES] } },
+  allOf: COMMAND_TYPES.map((type) => ({
+    if: { properties: { type: { const: type } }, required: ["type"] },
+    then: { $ref: `#/$defs/command_${type}` }
+  }))
+};
+var RUN_EVENT_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: RUN_EVENT_SCHEMA_ID,
+  title: "FluidGrids durable-function history event",
+  description: "One row of workflow_run_events as the service returns it (offloaded payloads inlined). type is UPPER_SNAKE.",
+  ...RUN_EVENT_RECORD,
+  $defs: { ...SHARED_DEFS, ...payloadDefs() }
+};
+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, 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() }
+};
+var WORKFLOW_TASK_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: WORKFLOW_TASK_SCHEMA_ID,
+  title: "FluidGrids workflow task (runtime ABI protocol 1)",
+  description: 'globalThis.__fluidgridsRuntime: start(JSON of request); while (step() === "more") drain jobs; complete() returns JSON of result.',
+  oneOf: [{ $ref: "#/$defs/request" }, { $ref: "#/$defs/result" }],
+  $defs: {
+    ...SHARED_DEFS,
+    ...payloadDefs(),
+    ...commandDefs(),
+    event: RUN_EVENT_RECORD,
+    command: COMMAND_ONE_OF,
+    info: {
+      type: "object",
+      required: ["runId", "workspaceId"],
+      properties: {
+        runId: ID2,
+        workspaceId: ID2,
+        workflowKey: { type: "string" },
+        version: {},
+        buildId: { type: "string" },
+        businessId: { type: "string" },
+        workflowId: { type: "string" },
+        attempt: { type: "integer", minimum: 1 },
+        runAttempt: { type: "integer", minimum: 1 },
+        taskQueue: { type: "string" },
+        parentRunId: { type: ["string", "null"] },
+        rootRunId: { type: ["string", "null"] },
+        firstRunId: { type: ["string", "null"] },
+        continuedFromRunId: { type: ["string", "null"] },
+        lastResult: {},
+        lastFailure: { oneOf: [{ type: "null" }, FAILURE_REF] },
+        startedAt: { type: "string" },
+        runStartedAt: { type: "string" },
+        historyLimit: {
+          type: "object",
+          required: ["events", "bytes"],
+          properties: {
+            events: { type: "integer", minimum: 1 },
+            bytes: { type: "integer", minimum: 1 }
+          }
+        },
+        timeouts: { type: "object" },
+        headers: { $ref: "#/$defs/headers" },
+        priority: { type: "integer", minimum: 1, maximum: 5 },
+        summary: { type: "string" },
+        details: { type: "string" },
+        context: { type: "object" },
+        memo: { type: "object" },
+        versioningBehavior: { enum: [...VERSIONING_BEHAVIORS] },
+        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: [
+        "localActivityId",
+        "kind",
+        "nodeType",
+        "operation",
+        "args",
+        "retry",
+        "startToCloseTimeout",
+        "attempt",
+        "backoffMs"
+      ],
+      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: ID2,
+        kind: { const: "node" },
+        nodeType: ID2,
+        nodeVersion: { type: "string" },
+        operation: ID2,
+        args: {},
+        connection: ID2,
+        retry: { $ref: "#/$defs/retryPolicy" },
+        startToCloseTimeout: {
+          type: "integer",
+          minimum: 1,
+          maximum: LOCAL_ACTIVITY_MAX_TIMEOUT_MS
+        },
+        attempt: { type: "integer", minimum: 1 },
+        backoffMs: NON_NEGATIVE_MS,
+        summary: { type: "string", maxLength: 200 }
+      },
+      additionalProperties: false
+    },
+    request: {
+      type: "object",
+      required: ["protocol", "kind", "workflowFn", "info", "history", "nowMs"],
+      properties: {
+        protocol: { const: HISTORY_PROTOCOL },
+        kind: { enum: ["task", "query", "verify"] },
+        workflowFn: ID2,
+        info: { $ref: "#/$defs/info" },
+        history: { type: "array", items: { $ref: "#/$defs/event" } },
+        nowMs: { type: "number" },
+        localActivityResults: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["localActivityId", "attempts"],
+            properties: {
+              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: 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."
+        }
+      }
+    },
+    result: {
+      type: "object",
+      required: ["protocol", "outcome", "commands", "logs"],
+      properties: {
+        protocol: { const: HISTORY_PROTOCOL },
+        outcome: { enum: ["commands", "failed", "localActivityRequested"] },
+        commands: { type: "array", items: { $ref: "#/$defs/command" } },
+        localActivityRequests: {
+          type: "array",
+          items: { $ref: "#/$defs/localActivityRequest" }
+        },
+        unfinishedHandlers: {
+          type: "array",
+          description: "R2: handlers still running when the terminal command was issued (11 \xA72.18); never set on replay.",
+          items: {
+            type: "object",
+            required: ["kind", "name", "count"],
+            properties: {
+              kind: { enum: ["signal", "update"] },
+              name: { type: "string" },
+              count: { type: "integer", minimum: 1 }
+            },
+            additionalProperties: false
+          }
+        },
+        queryResults: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["queryId"],
+            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"],
+          properties: {
+            cause: { enum: [...TASK_FAILURE_CAUSES] },
+            message: { type: "string" },
+            stackTrace: { type: "string" },
+            seq: { type: "integer" },
+            errorType: { type: "string" }
+          }
+        },
+        logs: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["level", "message"],
+            properties: {
+              level: { enum: ["debug", "info", "warn", "error"] },
+              message: { type: "string" },
+              data: {}
+            }
+          }
+        },
+        stackTrace: { type: "string" }
+      }
+    }
+  }
+};
+var HISTORY_FILE_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: HISTORY_FILE_SCHEMA_ID,
+  title: "FluidGrids durable-function history file",
+  type: "object",
+  required: ["format", "formatVersion", "workflowFn", "events"],
+  properties: {
+    format: { const: HISTORY_FILE_FORMAT },
+    formatVersion: { const: HISTORY_PROTOCOL },
+    name: { type: "string" },
+    description: { type: "string" },
+    workflowFn: ID2,
+    source: { type: "string", description: "Fixture source module, relative to the file." },
+    replaySource: {
+      type: "string",
+      description: "Fixture module the replay check runs instead of source (a hotfix or a patched() version)."
+    },
+    replay: {
+      type: "boolean",
+      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: {
+      type: "number",
+      description: "nowMs of the replay request for the conformance check."
+    },
+    events: { type: "array", items: { $ref: "#/$defs/event" } },
+    expected: {
+      type: "object",
+      description: "The replay result the conformance check must reproduce."
+    }
+  },
+  $defs: {
+    ...SHARED_DEFS,
+    ...payloadDefs(),
+    event: RUN_EVENT_RECORD,
+    info: WORKFLOW_TASK_SCHEMA.$defs.info
+  }
+};
+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],
+  ["bridge-v2.schema.json", BRIDGE_V2_SCHEMA],
+  ["payload-fields.json", PAYLOAD_FIELDS_DOCUMENT]
+];
+var tools;
+function schemaTools() {
+  if (!tools) {
+    const ajv = new Ajv2020({ allErrors: true, strict: false });
+    tools = {
+      ajv,
+      command: ajv.compile(WORKFLOW_COMMAND_SCHEMA),
+      event: ajv.compile(RUN_EVENT_SCHEMA),
+      file: ajv.compile(HISTORY_FILE_SCHEMA),
+      bridge: ajv.compile(BRIDGE_V2_SCHEMA)
+    };
+  }
+  return tools;
+}
+function issuesOf(index, errors) {
+  const real = (errors ?? []).filter((error) => error.keyword !== "if");
+  return real.map((error) => ({
+    index,
+    code: `schema.${error.keyword}`,
+    message: `${error.instancePath || "/"} ${error.message ?? "is invalid"}`,
+    path: error.instancePath
+  }));
+}
+function validateCommand(command2, index = 0) {
+  const { command: validate } = schemaTools();
+  if (validate(command2)) {
+    return { ok: true, command: command2 };
+  }
+  return { ok: false, issues: issuesOf(index, validate.errors) };
+}
+function idOf(command2) {
+  switch (command2.type) {
+    case "SCHEDULE_ACTIVITY":
+      return `activity:${command2.activityId}`;
+    case "START_TIMER":
+      return `timer:${command2.timerId}`;
+    case "START_CHILD_RUN":
+      return `child:${command2.childId}`;
+    case "SIGNAL_RUN":
+    case "REQUEST_CANCEL_EXTERNAL_RUN":
+      return `external:${command2.externalId}`;
+    case "RECORD_SIDE_EFFECT":
+      return `sideEffect:${command2.sideEffectId}`;
+    case "RECORD_MARKER":
+      return `marker:${command2.markerId}`;
+    case "RECORD_LOCAL_ACTIVITY":
+      return `local:${command2.localActivityId}`;
+    default:
+      return void 0;
+  }
+}
+function validateCommands(commands, options = {}) {
+  const max = options.maxCommands ?? 1e3;
+  if (!Array.isArray(commands))
+    return {
+      ok: false,
+      cause: "INVALID_REQUEST",
+      issues: [{ index: 0, code: "commands.notArray", message: "commands must be an array" }]
+    };
+  if (commands.length > max)
+    return {
+      ok: false,
+      cause: "INVALID_REQUEST",
+      issues: [
+        {
+          index: max,
+          code: "commands.tooMany",
+          message: `A task may return at most ${max} commands; it returned ${commands.length}`
+        }
+      ]
+    };
+  const issues = [];
+  const valid = [];
+  const ids = /* @__PURE__ */ new Set();
+  let unsupported = false;
+  commands.forEach((raw, index) => {
+    const checked = validateCommand(raw, index);
+    if (!checked.ok) {
+      issues.push(...checked.issues);
+      return;
+    }
+    const command2 = checked.command;
+    if (!isWorkflowCommandEnabled(command2, options.enabled) && !(options.relief !== void 0 && isReliefCommand(command2, options.relief))) {
+      unsupported = true;
+      issues.push({
+        index,
+        code: "commands.unsupported",
+        message: unsupportedMessage(command2, options.enabled)
+      });
+    }
+    const id = idOf(command2);
+    if (id !== void 0) {
+      if (ids.has(id))
+        issues.push({ index, code: "commands.duplicateId", message: `${id} is used twice` });
+      ids.add(id);
+    }
+    if (TERMINAL_COMMANDS.has(command2.type) && index !== commands.length - 1)
+      issues.push({
+        index,
+        code: "commands.terminalNotLast",
+        message: `${command2.type} must be the last command of the batch`
+      });
+    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)
+    return { ok: false, cause: unsupported ? "UNSUPPORTED_COMMAND" : "INVALID_REQUEST", issues };
+  return { ok: true, commands: valid };
+}
+function validateHistory(events) {
+  const { event: validate } = schemaTools();
+  if (!Array.isArray(events))
+    return {
+      ok: false,
+      issues: [{ index: 0, code: "history.notArray", message: "history must be an array" }]
+    };
+  const issues = [];
+  events.forEach((event, index) => {
+    if (!validate(event)) {
+      issues.push(...issuesOf(index, validate.errors));
+      return;
+    }
+    if (isRecord(event) && event["seq"] !== index + 1)
+      issues.push({
+        index,
+        code: "history.seqGap",
+        message: `event ${index + 1} has seq ${String(event["seq"])}`
+      });
+  });
+  return { ok: issues.length === 0, issues };
+}
+function validateHistoryFile(value) {
+  const { file: validate } = schemaTools();
+  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);
+  return (value) => {
+    if (validate(value)) return { ok: true };
+    return {
+      ok: false,
+      errors: (validate.errors ?? []).map(
+        (error) => `${error.instancePath || "/"} ${error.message ?? "is invalid"}`
+      )
+    };
+  };
+}
+
+// src/history/file.ts
+var HistoryFileError = class extends Error {
+  constructor(message, issues = []) {
+    super(message);
+    this.issues = issues;
+    this.name = "HistoryFileError";
+  }
+  issues;
+};
+function parseHistoryFile(input) {
+  let value = input;
+  if (typeof input === "string") {
+    try {
+      value = JSON.parse(input);
+    } catch (error) {
+      throw new HistoryFileError(
+        `Not JSON: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (!isRecord(value) || value["format"] !== HISTORY_FILE_FORMAT)
+    throw new HistoryFileError(`Not a ${HISTORY_FILE_FORMAT} document`);
+  const checked = validateHistoryFile(value);
+  if (!checked.ok)
+    throw new HistoryFileError(
+      "The history file does not match history-file.schema.json",
+      checked.issues.map((issue) => `#${issue.index}: ${issue.message}`)
+    );
+  return value;
+}
+function createHistoryFile(workflowFn, events, extra = {}) {
+  return {
+    format: HISTORY_FILE_FORMAT,
+    formatVersion: HISTORY_PROTOCOL,
+    ...extra,
+    workflowFn,
+    events
+  };
+}
+function serializeHistoryFile(file) {
+  return `${JSON.stringify(file, null, 2)}
+`;
+}
+
+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 };