@fluidgrids/workflows 2026.1027.1 → 2026.1028.1

package/dist/chunk-VOKMAAJP.js

@@ -0,0 +1,848 @@
+import { isRecord } from './chunk-PMCM2OH4.js';
+import { isWorkflowCommandEnabled } from './chunk-ABFZWYHT.js';
+import { CHILD_CANCELLATION_TYPES, PARENT_CLOSE_POLICIES, ERROR_TYPES, ACTIVITY_CANCELLATION_TYPES, TASK_FAILURE_CAUSES, EVENT_TYPES, COMMAND_TYPES, BUILT_IN_QUERIES, HISTORY_PROTOCOL, TERMINAL_COMMANDS } from './chunk-DJYMDLV5.js';
+import { isActivityNodeTypeAllowed } from './chunk-BO6OVILK.js';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+
+// 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 ID = { type: "string", minLength: 1, maxLength: 256 };
+var NON_NEGATIVE_MS = { type: "integer", minimum: 0 };
+var STRING_MAP = { type: "object", additionalProperties: { type: "string" } };
+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: ID },
+        additionalProperties: false
+      },
+      {
+        type: "object",
+        required: ["parent"],
+        properties: { parent: { const: true } },
+        additionalProperties: false
+      },
+      {
+        type: "object",
+        required: ["childId"],
+        properties: { childId: ID },
+        additionalProperties: false
+      },
+      {
+        type: "object",
+        required: ["workflowKey", "workflowId"],
+        properties: { workflowKey: ID, workflowId: ID },
+        additionalProperties: false
+      }
+    ]
+  },
+  childOptions: {
+    type: "object",
+    required: ["parentClosePolicy"],
+    properties: {
+      parentClosePolicy: { enum: [...PARENT_CLOSE_POLICIES] },
+      cancellationType: { enum: [...CHILD_CANCELLATION_TYPES] },
+      taskQueue: ID,
+      workflowId: ID,
+      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
+    }
+  },
+  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 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 }),
+  START_TIMER: command("START_TIMER", ["timerId", "durationMs"], {
+    timerId: ID,
+    durationMs: { type: "integer", minimum: 1 },
+    summary: { type: "string", maxLength: 200 }
+  }),
+  CANCEL_TIMER: command("CANCEL_TIMER", ["timerId"], { timerId: ID }),
+  START_CHILD_RUN: {
+    ...command("START_CHILD_RUN", ["childId", "input", "options"], {
+      childId: ID,
+      workflowKey: ID,
+      workflowFn: ID,
+      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: ID,
+    target: { $ref: "#/$defs/runTarget" },
+    name: ID,
+    payload: {}
+  }),
+  RECORD_SIDE_EFFECT: command("RECORD_SIDE_EFFECT", ["sideEffectId", "value"], {
+    sideEffectId: ID,
+    value: {}
+  }),
+  RECORD_MARKER: command("RECORD_MARKER", ["markerId", "data"], { markerId: ID, 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: ID,
+      result: {},
+      failure: { $ref: "#/$defs/failure" },
+      attempts: { type: "integer", minimum: 1 }
+    }),
+    oneOf: [{ required: ["result"] }, { required: ["failure"] }]
+  },
+  CONTINUE_AS_NEW: command("CONTINUE_AS_NEW", ["input", "options"], {
+    input: {},
+    options: { type: "object" }
+  }),
+  REQUEST_CANCEL_EXTERNAL_RUN: command("REQUEST_CANCEL_EXTERNAL_RUN", ["externalId", "target"], {
+    externalId: ID,
+    target: { $ref: "#/$defs/runTarget" }
+  }),
+  UPSERT_SEARCH_ATTRIBUTES: command("UPSERT_SEARCH_ATTRIBUTES", ["attributes"], {
+    attributes: { type: "object" }
+  }),
+  ACCEPT_UPDATE: command("ACCEPT_UPDATE", ["updateId"], { updateId: ID }),
+  REJECT_UPDATE: command("REJECT_UPDATE", ["updateId", "failure"], {
+    updateId: ID,
+    failure: { $ref: "#/$defs/failure" }
+  }),
+  COMPLETE_UPDATE: command("COMPLETE_UPDATE", ["updateId"], {
+    updateId: ID,
+    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: ID,
+    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: ["PINNED", "AUTO_UPGRADE"] },
+    /** Seed of `ctx.random()`/`ctx.uuid()`; the service writes the run id. Absent: `info.runId`. */
+    randomnessSeed: ID
+  }),
+  WORKFLOW_TASK_SCHEDULED: payload(["taskId"], {
+    taskId: ID,
+    attempt: { type: "integer", minimum: 1 }
+  }),
+  WORKFLOW_TASK_STARTED: payload(["taskId", "attempt"], {
+    taskId: ID,
+    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."
+    }
+  }),
+  WORKFLOW_TASK_COMPLETED: payload(["taskId"], {
+    taskId: ID,
+    buildId: { type: "string" },
+    workerId: { type: "string" }
+  }),
+  WORKFLOW_TASK_FAILED: payload(["taskId", "attempt", "cause"], {
+    taskId: ID,
+    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: ID,
+    attempt: { type: "integer", minimum: 1 }
+  }),
+  ACTIVITY_SCHEDULED: payload(["activityId", "kind", "nodeType", "operation", "args", "retry"], {
+    ...COMMAND_DEFS.SCHEDULE_ACTIVITY.properties,
+    type: void 0
+  }),
+  ACTIVITY_STARTED: payload(["activityId", "attempt"], {
+    activityId: ID,
+    attempt: { type: "integer", minimum: 1 },
+    workerId: { type: "string" }
+  }),
+  ACTIVITY_HEARTBEAT: payload(["activityId"], { activityId: ID, details: {} }),
+  ACTIVITY_COMPLETED: payload(["activityId", "attempt"], {
+    activityId: ID,
+    attempt: { type: "integer", minimum: 1 },
+    result: {}
+  }),
+  ACTIVITY_FAILED: payload(["activityId", "attempt", "failure"], {
+    activityId: ID,
+    attempt: { type: "integer", minimum: 1 },
+    failure: FAILURE_REF
+  }),
+  ACTIVITY_TIMED_OUT: payload(["activityId", "attempt", "timeoutType"], {
+    activityId: ID,
+    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_OPTIONS_UPDATED: payload(["activityId"], {
+    activityId: ID,
+    options: { type: "object" }
+  }),
+  TIMER_STARTED: payload(["timerId", "durationMs", "fireAt"], {
+    timerId: ID,
+    durationMs: { type: "integer", minimum: 1 },
+    fireAt: { type: "string" },
+    summary: { type: "string" }
+  }),
+  TIMER_FIRED: payload(["timerId"], { timerId: ID }),
+  TIMER_CANCELLED: payload(["timerId"], { timerId: ID }),
+  SIGNAL_RECEIVED: payload(["name"], {
+    name: ID,
+    payload: {},
+    receivedAt: { type: "string" },
+    actor: {},
+    idempotencyKey: { type: "string" }
+  }),
+  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 }),
+  CHILD_RUN_INITIATED: payload(["childId", "input", "options"], {
+    childId: ID,
+    workflowKey: ID,
+    workflowFn: ID,
+    version: { type: "string" },
+    input: {},
+    options: { $ref: "#/$defs/childOptions" },
+    childRunId: { type: "string" },
+    executionKind: { enum: ["GRAPH", "DURABLE_FN"] }
+  }),
+  CHILD_RUN_STARTED: payload(["childId", "childRunId"], {
+    childId: ID,
+    childRunId: ID,
+    executionKind: { enum: ["GRAPH", "DURABLE_FN"] }
+  }),
+  CHILD_RUN_COMPLETED: payload(["childId"], { childId: ID, childRunId: ID, result: {} }),
+  CHILD_RUN_FAILED: payload(["childId", "failure"], {
+    childId: ID,
+    childRunId: ID,
+    failure: FAILURE_REF
+  }),
+  CHILD_RUN_CANCELLED: payload(["childId"], { childId: ID, childRunId: ID }),
+  CHILD_RUN_TERMINATED: payload(["childId"], {
+    childId: ID,
+    childRunId: ID,
+    reason: { type: "string" }
+  }),
+  CHILD_RUN_TIMED_OUT: payload(["childId"], {
+    childId: ID,
+    childRunId: ID,
+    timeoutType: { enum: ["WORKFLOW_RUN", "WORKFLOW_EXECUTION"] }
+  }),
+  EXTERNAL_RUN_CANCEL_REQUESTED: payload(["externalId", "target"], {
+    externalId: ID,
+    target: { $ref: "#/$defs/runTarget" }
+  }),
+  EXTERNAL_RUN_CANCEL_RESOLVED: payload(["externalId", "ok"], {
+    externalId: ID,
+    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: ID,
+      target: { $ref: "#/$defs/runTarget" },
+      name: ID,
+      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: ID, value: {} }),
+  LOCAL_ACTIVITY_COMPLETED: payload(["localActivityId", "attempts"], {
+    localActivityId: ID,
+    result: {},
+    attempts: { type: "integer", minimum: 1 }
+  }),
+  LOCAL_ACTIVITY_FAILED: payload(["localActivityId", "attempts", "failure"], {
+    localActivityId: ID,
+    failure: FAILURE_REF,
+    attempts: { type: "integer", minimum: 1 }
+  }),
+  SEARCH_ATTRIBUTES_UPSERTED: payload(["attributes"], { attributes: { type: "object" } }),
+  CONTEXT_UPSERTED: payload(["entries"], { entries: { type: "object" } }),
+  MARKER_RECORDED: payload(["markerId", "data"], {
+    markerId: ID,
+    data: {}
+  }),
+  WORKFLOW_CANCEL_REQUESTED: payload([], { actor: {}, reason: { type: "string" } }),
+  WORKFLOW_RESET: payload(["fromRunId", "toSeq"], {
+    fromRunId: ID,
+    toSeq: { type: "integer", minimum: 1 },
+    reason: { type: "string" }
+  }),
+  VERSIONING_OVERRIDE_SET: payload(["override"], { override: {} }),
+  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_RUN", "WORKFLOW_EXECUTION"] }
+  }),
+  WORKFLOW_CONTINUED_AS_NEW: payload(["input", "options"], {
+    input: {},
+    options: { type: "object" },
+    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 and COMPLETE_UPDATE are defined but refused in Phase B.",
+  ...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: ID,
+        workspaceId: ID,
+        workflowKey: { type: "string" },
+        version: {},
+        buildId: { type: "string" },
+        businessId: { type: "string" },
+        attempt: { 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" }
+      }
+    },
+    request: {
+      type: "object",
+      required: ["protocol", "kind", "workflowFn", "info", "history", "nowMs"],
+      properties: {
+        protocol: { const: HISTORY_PROTOCOL },
+        kind: { enum: ["task", "query", "verify"] },
+        workflowFn: ID,
+        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: ID,
+              result: {},
+              failure: FAILURE_REF,
+              attempts: { type: "integer", minimum: 1 }
+            }
+          }
+        },
+        queries: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["queryId", "name"],
+            properties: {
+              queryId: ID,
+              name: { enum: [...BUILT_IN_QUERIES] },
+              args: {}
+            }
+          }
+        }
+      }
+    },
+    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: { type: "object" } },
+        queryResults: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["queryId"],
+            properties: { queryId: ID, value: {}, error: { type: "string" } }
+          }
+        },
+        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: ID,
+    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 use Phase C features (updates); they are parsed and projected but not replayed."
+    },
+    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]
+];
+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)
+    };
+  }
+  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)) {
+      unsupported = true;
+      issues.push({
+        index,
+        code: "commands.unsupported",
+        message: `${command2.type} is not supported in this release`
+      });
+    }
+    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" && !isActivityNodeTypeAllowed(command2.nodeType))
+      issues.push({
+        index,
+        code: "durable.activityTypeNotAllowed",
+        message: `${command2.nodeType} cannot run as a durable activity`,
+        path: "/nodeType"
+      });
+    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 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 { 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 };