@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/chunk-VOKMAAJP.js

@@ -1,848 +0,0 @@
-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 };