@logixjs/core 0.0.1 → 1.0.0

package/dist/chunk-3L6QGFMM.js

@@ -0,0 +1,701 @@
+import {
+  isJsonValue,
+  projectJsonValue
+} from "./chunk-LPPZDFTD.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-4MZ7BT3R.js";
+
+// src/internal/workflow/errors.ts
+var toJsonValue = (detail) => {
+  if (isJsonValue(detail)) return detail;
+  return projectJsonValue(detail).value;
+};
+var makeWorkflowError = (args) => {
+  const detailJson = args.detail !== void 0 ? toJsonValue(args.detail) : void 0;
+  const msg = args.detail !== void 0 ? `${args.message}
+(detail=${stableStringify(detailJson)})` : args.message;
+  return Object.assign(new Error(msg), {
+    _tag: "WorkflowError",
+    code: args.code,
+    programId: args.programId,
+    source: args.source,
+    detail: detailJson
+  });
+};
+
+// src/internal/workflow/inputExpr.ts
+var decodePointerToken = (raw) => raw.replace(/~1/g, "/").replace(/~0/g, "~");
+var isIndexToken = (token) => token === "0" || !token.startsWith("0") && /^\d+$/.test(token);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseJsonPointer = (pointer) => {
+  if (pointer === "") return [];
+  if (!pointer.startsWith("/")) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_JSON_POINTER",
+      message: 'Invalid JSON Pointer (must be "" or start with "/").',
+      detail: { pointer }
+    });
+  }
+  const raw = pointer.split("/").slice(1);
+  const out = [];
+  for (const part of raw) {
+    const decoded = decodePointerToken(part);
+    out.push(isIndexToken(decoded) ? Number(decoded) : decoded);
+  }
+  return out;
+};
+var compileInputExpr = (expr, pathForError) => {
+  switch (expr.kind) {
+    case "payload":
+      return { kind: "payload" };
+    case "payload.path": {
+      const pointer = expr.pointer;
+      if (typeof pointer !== "string") {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "InputExpr.payload.path.pointer must be a string.",
+          source: { stepKey: pathForError?.stepKey },
+          detail: { pointer }
+        });
+      }
+      return { kind: "payload.path", pointer, tokens: parseJsonPointer(pointer) };
+    }
+    case "const": {
+      const value = expr.value;
+      if (!isJsonValue(value)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "InputExpr.const.value must be JSON-serializable.",
+          source: { stepKey: pathForError?.stepKey },
+          detail: { value }
+        });
+      }
+      return { kind: "const", value };
+    }
+    case "object": {
+      const fields = expr.fields;
+      if (!fields || typeof fields !== "object" || Array.isArray(fields)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "InputExpr.object.fields must be a record.",
+          source: { stepKey: pathForError?.stepKey }
+        });
+      }
+      const entries = Object.entries(fields).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+      return {
+        kind: "object",
+        fields: entries.map(([k, v]) => [k, compileInputExpr(v, pathForError)])
+      };
+    }
+    case "merge": {
+      const items = expr.items;
+      if (!Array.isArray(items)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "InputExpr.merge.items must be an array.",
+          source: { stepKey: pathForError?.stepKey }
+        });
+      }
+      for (const item of items) {
+        const kind = isRecord(item) ? item.kind : void 0;
+        if (kind !== "object") {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_MERGE_ITEMS",
+            message: "InputExpr.merge.items must all be InputExpr.object.",
+            source: { stepKey: pathForError?.stepKey },
+            detail: { kind }
+          });
+        }
+      }
+      return {
+        kind: "merge",
+        items: items.map((i) => compileInputExpr(i, pathForError))
+      };
+    }
+  }
+};
+var isPlainRecord = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var evalPointer = (root, tokens) => {
+  let current = root;
+  for (const token of tokens) {
+    if (current == null) return void 0;
+    if (Array.isArray(current) && typeof token === "number") {
+      current = current[token];
+      continue;
+    }
+    if (typeof current !== "object") return void 0;
+    const key = typeof token === "number" ? String(token) : token;
+    current = current[key];
+  }
+  return current;
+};
+var evalInputExpr = (expr, payload) => {
+  switch (expr.kind) {
+    case "payload":
+      return payload;
+    case "payload.path":
+      return evalPointer(payload, expr.tokens);
+    case "const":
+      return expr.value;
+    case "object": {
+      const out = {};
+      for (const [k, v] of expr.fields) {
+        out[k] = evalInputExpr(v, payload);
+      }
+      return out;
+    }
+    case "merge": {
+      const out = {};
+      for (const item of expr.items) {
+        const value = evalInputExpr(item, payload);
+        if (isPlainRecord(value)) {
+          for (const [k, v] of Object.entries(value)) {
+            out[k] = v;
+          }
+        }
+      }
+      return out;
+    }
+  }
+};
+
+// src/internal/workflow/compiler.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var asNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+var asNonNegInt = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  const n = Math.floor(value);
+  return n >= 0 ? n : void 0;
+};
+var asPosInt = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  const n = Math.floor(value);
+  return n > 0 ? n : void 0;
+};
+var normalizeWorkflowDefV1 = (input) => {
+  const normalizeStep = (step) => {
+    if (!isRecord2(step)) return step;
+    if (step.kind !== "call") return step;
+    const raw = step;
+    const onSuccessRaw = Array.isArray(raw.onSuccess) ? raw.onSuccess : [];
+    const onFailureRaw = Array.isArray(raw.onFailure) ? raw.onFailure : [];
+    return {
+      ...step,
+      onSuccess: onSuccessRaw.map(normalizeStep),
+      onFailure: onFailureRaw.map(normalizeStep)
+    };
+  };
+  const normalizeSteps = (steps) => steps.map(normalizeStep);
+  return {
+    ...input,
+    steps: normalizeSteps(input.steps)
+  };
+};
+function validateWorkflowDefV1(def, options) {
+  if (!isRecord2(def)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "WorkflowDef must be an object.",
+      detail: { def }
+    });
+  }
+  if (def.astVersion !== 1) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_UNSUPPORTED_VERSION",
+      message: "Unsupported workflow astVersion.",
+      detail: { astVersion: def.astVersion }
+    });
+  }
+  if (!asNonEmptyString(def.localId)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "WorkflowDef.localId must be a non-empty string.",
+      detail: { localId: def.localId }
+    });
+  }
+  const trigger = def.trigger;
+  if (!isRecord2(trigger)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_TRIGGER",
+      message: "Workflow trigger must be an object.",
+      detail: { trigger }
+    });
+  }
+  if (trigger.kind === "action") {
+    if (!asNonEmptyString(trigger.actionTag)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_TRIGGER",
+        message: "Workflow trigger.actionTag must be a non-empty string.",
+        detail: { trigger }
+      });
+    }
+  } else if (trigger.kind === "lifecycle") {
+    const phase = trigger.phase;
+    if (phase !== "onStart" && phase !== "onInit") {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_TRIGGER",
+        message: 'Workflow trigger.phase must be "onStart" or "onInit".',
+        detail: { trigger }
+      });
+    }
+  } else {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_TRIGGER",
+      message: 'Workflow trigger.kind must be "action" or "lifecycle".',
+      detail: { trigger }
+    });
+  }
+  if (!Array.isArray(def.steps)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "WorkflowDef.steps must be an array.",
+      detail: { steps: def.steps }
+    });
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  const visit = (step, fragmentId) => {
+    if (!isRecord2(step)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_STEP",
+        message: "Workflow step must be an object.",
+        detail: { step },
+        source: fragmentId ? { fragmentId } : void 0
+      });
+    }
+    const key = asNonEmptyString(step.key);
+    if (!key) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_STEP",
+        message: "Workflow step.key must be a non-empty string.",
+        detail: { stepKey: step.key, kind: step.kind },
+        source: fragmentId ? { fragmentId } : void 0
+      });
+    }
+    if (seenKeys.has(key)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_DUPLICATE_STEP_KEY",
+        message: `Duplicate stepKey "${key}" detected.`,
+        detail: { duplicateKey: key },
+        source: { stepKey: key, ...fragmentId ? { fragmentId } : null }
+      });
+    }
+    seenKeys.add(key);
+    if (step.kind === "dispatch") {
+      if (!asNonEmptyString(step.actionTag)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_STEP",
+          message: "dispatch.actionTag must be a non-empty string.",
+          source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+          detail: { actionTag: step.actionTag }
+        });
+      }
+      const payload = step.payload;
+      if (payload !== void 0) {
+        validateInputExpr(payload, { stepKey: key });
+      }
+      return;
+    }
+    if (step.kind === "delay") {
+      const ms = asNonNegInt(step.ms);
+      if (ms === void 0) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_STEP",
+          message: "delay.ms must be a non-negative integer.",
+          source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+          detail: { ms: step.ms }
+        });
+      }
+      return;
+    }
+    if (step.kind === "call") {
+      if (!asNonEmptyString(step.serviceId)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_SERVICE_ID",
+          message: "call.serviceId must be a non-empty string.",
+          source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+          detail: { serviceId: step.serviceId }
+        });
+      }
+      const inputExpr = step.input;
+      if (inputExpr !== void 0) {
+        validateInputExpr(inputExpr, { stepKey: key });
+      }
+      const timeoutMsRaw = step.timeoutMs;
+      if (timeoutMsRaw !== void 0 && asPosInt(timeoutMsRaw) === void 0) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_STEP",
+          message: "call.timeoutMs must be a positive integer (milliseconds).",
+          source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+          detail: { timeoutMs: timeoutMsRaw }
+        });
+      }
+      const retryRaw = step.retry;
+      if (retryRaw !== void 0) {
+        const times = isRecord2(retryRaw) ? asPosInt(retryRaw.times) : void 0;
+        if (times === void 0) {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_STEP",
+            message: "call.retry.times must be a positive integer.",
+            source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+            detail: { retry: retryRaw }
+          });
+        }
+      }
+      const onSuccess = Array.isArray(step.onSuccess) ? step.onSuccess : [];
+      const onFailure = Array.isArray(step.onFailure) ? step.onFailure : [];
+      for (const inner of onSuccess) visit(inner, fragmentId);
+      for (const inner of onFailure) visit(inner, fragmentId);
+      return;
+    }
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_STEP",
+      message: "Unknown step kind.",
+      source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+      detail: { kind: step.kind }
+    });
+  };
+  const sources = def.sources;
+  const fragmentByStepKey = /* @__PURE__ */ new Map();
+  if (sources && typeof sources === "object") {
+    for (const [k, v] of Object.entries(sources)) {
+      fragmentByStepKey.set(k, isRecord2(v) ? asNonEmptyString(v.fragmentId) : void 0);
+    }
+  }
+  for (const step of def.steps) {
+    const key = isRecord2(step) ? asNonEmptyString(step.key) : void 0;
+    const fragmentId = key ? fragmentByStepKey.get(key) : void 0;
+    visit(step, fragmentId);
+  }
+  const generator = isRecord2(def.meta) ? def.meta.generator : void 0;
+  if (generator !== void 0 && !isJsonValue(generator)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "WorkflowDef.meta.generator must be JSON-serializable.",
+      detail: { generator }
+    });
+  }
+  const policy = isRecord2(def.policy) ? def.policy : void 0;
+  if (policy) {
+    const concurrency = policy.concurrency;
+    if (concurrency !== void 0 && concurrency !== "latest" && concurrency !== "exhaust" && concurrency !== "parallel") {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_DEF",
+        message: "policy.concurrency must be latest|exhaust|parallel.",
+        detail: { concurrency }
+      });
+    }
+    const priority = policy.priority;
+    if (priority !== void 0 && priority !== "urgent" && priority !== "nonUrgent") {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_DEF",
+        message: "policy.priority must be urgent|nonUrgent.",
+        detail: { priority }
+      });
+    }
+  }
+  void options?.moduleId;
+}
+var validateInputExpr = (expr, options) => {
+  const visit = (e) => {
+    if (!isRecord2(e)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_INPUT_EXPR",
+        message: "InputExpr must be an object.",
+        source: { stepKey: options?.stepKey },
+        detail: { expr: e }
+      });
+    }
+    const kind = e.kind;
+    switch (kind) {
+      case "payload":
+        return;
+      case "payload.path": {
+        const pointer = e.pointer;
+        if (typeof pointer !== "string") {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_INPUT_EXPR",
+            message: "InputExpr.payload.path.pointer must be a string.",
+            source: { stepKey: options?.stepKey },
+            detail: { pointer }
+          });
+        }
+        return;
+      }
+      case "const": {
+        const value = e.value;
+        if (!isJsonValue(value)) {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_INPUT_EXPR",
+            message: "InputExpr.const.value must be JSON-serializable.",
+            source: { stepKey: options?.stepKey }
+          });
+        }
+        return;
+      }
+      case "object": {
+        const fields = e.fields;
+        if (!isRecord2(fields)) {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_INPUT_EXPR",
+            message: "InputExpr.object.fields must be a record.",
+            source: { stepKey: options?.stepKey }
+          });
+        }
+        for (const v of Object.values(fields)) {
+          visit(v);
+        }
+        return;
+      }
+      case "merge": {
+        const items = e.items;
+        if (!Array.isArray(items)) {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_INPUT_EXPR",
+            message: "InputExpr.merge.items must be an array.",
+            source: { stepKey: options?.stepKey }
+          });
+        }
+        for (const item of items) {
+          visit(item);
+        }
+        return;
+      }
+      default:
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "Unknown InputExpr kind.",
+          source: { stepKey: options?.stepKey },
+          detail: { kind }
+        });
+    }
+  };
+  visit(expr);
+};
+var makeDigest = (prefix, value) => `${prefix}:${fnv1a32(stableStringify(value))}`;
+var makeTriggerNodeId = (programId) => `wf_trigger_v1:${fnv1a32(programId)}`;
+var makeStepNodeId = (programId, stepKey, kind) => `wf_node_v1:${fnv1a32(`${programId}\0${stepKey}\0${kind}`)}`;
+var budgetJsonValue = (value) => projectJsonValue(value).value;
+var budgetInputExpr = (expr) => {
+  switch (expr.kind) {
+    case "payload":
+    case "payload.path":
+      return expr;
+    case "const": {
+      const value = expr.value;
+      if (!isJsonValue(value)) return expr;
+      return { ...expr, value: budgetJsonValue(expr.value) };
+    }
+    case "object": {
+      const out = {};
+      for (const k of Object.keys(expr.fields).sort()) {
+        out[k] = budgetInputExpr(expr.fields[k]);
+      }
+      return { ...expr, fields: out };
+    }
+    case "merge":
+      return { ...expr, items: expr.items.map(budgetInputExpr) };
+  }
+};
+var toStaticStep = (step) => {
+  switch (step.kind) {
+    case "dispatch":
+      return {
+        kind: "dispatch",
+        actionTag: step.actionTag,
+        ...step.payload ? { payload: budgetInputExpr(step.payload) } : null
+      };
+    case "delay":
+      return { kind: "delay", ms: step.ms };
+    case "call": {
+      const policy = step.timeoutMs !== void 0 || step.retry !== void 0 ? {
+        ...step.timeoutMs !== void 0 ? { timeoutMs: step.timeoutMs } : null,
+        ...step.retry !== void 0 ? { retry: { times: step.retry.times } } : null
+      } : void 0;
+      return {
+        kind: "call",
+        serviceId: step.serviceId,
+        ...step.input ? { input: budgetInputExpr(step.input) } : null,
+        ...policy ? { policy } : null
+      };
+    }
+  }
+};
+var compileWorkflowStaticIrV1 = (args) => {
+  const normalized = normalizeWorkflowDefV1(args.def);
+  validateWorkflowDefV1(normalized, { moduleId: args.moduleId });
+  const programId = `${args.moduleId}.${normalized.localId}`;
+  const triggerNodeId = makeTriggerNodeId(programId);
+  const fragmentByStepKey = /* @__PURE__ */ new Map();
+  if (normalized.sources && typeof normalized.sources === "object") {
+    for (const [k, v] of Object.entries(normalized.sources)) {
+      fragmentByStepKey.set(k, isRecord2(v) ? asNonEmptyString(v.fragmentId) : void 0);
+    }
+  }
+  const nodesByKey = /* @__PURE__ */ new Map();
+  const collectNodes = (steps) => {
+    for (const step of steps) {
+      const id = makeStepNodeId(programId, step.key, step.kind);
+      nodesByKey.set(step.key, id);
+      if (step.kind === "call") {
+        collectNodes(step.onSuccess);
+        collectNodes(step.onFailure);
+      }
+    }
+  };
+  collectNodes(normalized.steps);
+  const nodes = [
+    {
+      id: triggerNodeId,
+      kind: "trigger",
+      trigger: normalized.trigger
+    }
+  ];
+  const addStepNodes = (steps) => {
+    for (const step of steps) {
+      const id = nodesByKey.get(step.key);
+      if (!id) continue;
+      const fragmentId = fragmentByStepKey.get(step.key);
+      nodes.push({
+        id,
+        kind: "step",
+        step: toStaticStep(step),
+        source: {
+          stepKey: step.key,
+          ...fragmentId ? { fragmentId } : null
+        }
+      });
+      if (step.kind === "call") {
+        addStepNodes(step.onSuccess);
+        addStepNodes(step.onFailure);
+      }
+    }
+  };
+  addStepNodes(normalized.steps);
+  const edges = [];
+  const pushEdge = (from, to, kind) => {
+    edges.push({ from, to, kind });
+  };
+  const compileBlock = (args2) => {
+    if (args2.steps.length === 0) {
+      if (args2.continuation) {
+        for (const from of args2.entryFrom) {
+          pushEdge(from, args2.continuation, args2.entryKind);
+        }
+      }
+      return;
+    }
+    const first = args2.steps[0];
+    const firstId = nodesByKey.get(first.key);
+    if (!firstId) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_STEP",
+        message: "Internal error: missing node id for stepKey.",
+        programId,
+        source: { stepKey: first.key }
+      });
+    }
+    for (const from of args2.entryFrom) {
+      pushEdge(from, firstId, args2.entryKind);
+    }
+    const compileStepAndTail = (step, tail, continuation) => {
+      const stepId = nodesByKey.get(step.key);
+      if (!stepId) return;
+      if (step.kind !== "call") {
+        compileBlock({ steps: tail, entryFrom: [stepId], entryKind: "next", continuation });
+        return;
+      }
+      const cont = tail.length > 0 ? nodesByKey.get(tail[0].key) : continuation;
+      compileBlock({
+        steps: step.onSuccess,
+        entryFrom: [stepId],
+        entryKind: "success",
+        continuation: cont
+      });
+      compileBlock({
+        steps: step.onFailure,
+        entryFrom: [stepId],
+        entryKind: "failure",
+        continuation: cont
+      });
+      compileBlock({ steps: tail, entryFrom: [], entryKind: "next", continuation });
+    };
+    compileStepAndTail(first, args2.steps.slice(1), args2.continuation);
+  };
+  compileBlock({ steps: normalized.steps, entryFrom: [triggerNodeId], entryKind: "next", continuation: void 0 });
+  nodes.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  edges.sort((a, b) => {
+    if (a.from !== b.from) return a.from < b.from ? -1 : 1;
+    if (a.to !== b.to) return a.to < b.to ? -1 : 1;
+    const ak = String(a.kind ?? "");
+    const bk = String(b.kind ?? "");
+    if (ak !== bk) return ak < bk ? -1 : 1;
+    return 0;
+  });
+  const meta = (() => {
+    const generator = normalized.meta?.generator;
+    if (generator === void 0) return void 0;
+    return { generator: budgetJsonValue(generator) };
+  })();
+  const irNoDigest = {
+    version: 1,
+    programId,
+    nodes,
+    edges,
+    policy: normalized.policy,
+    meta
+  };
+  const digest = makeDigest("workflow_ir_v1", irNoDigest);
+  return {
+    ...irNoDigest,
+    digest
+  };
+};
+var compileWorkflowRuntimeStepsV1 = (args) => {
+  const normalized = normalizeWorkflowDefV1(args.def);
+  validateWorkflowDefV1(normalized);
+  const compileStep = (step) => {
+    const stepKey = step.key;
+    switch (step.kind) {
+      case "dispatch":
+        return {
+          kind: "dispatch",
+          key: step.key,
+          actionTag: step.actionTag,
+          ...step.payload ? { payload: compileInputExpr(step.payload, { stepKey }) } : null
+        };
+      case "delay":
+        return { kind: "delay", key: step.key, ms: step.ms };
+      case "call": {
+        const retryTimes = step.retry?.times;
+        return {
+          kind: "call",
+          key: step.key,
+          serviceId: step.serviceId,
+          ...step.input ? { input: compileInputExpr(step.input, { stepKey }) } : null,
+          ...step.timeoutMs !== void 0 ? { timeoutMs: step.timeoutMs } : null,
+          ...retryTimes !== void 0 ? { retryTimes } : null,
+          onSuccess: step.onSuccess.map(compileStep),
+          onFailure: step.onFailure.map(compileStep)
+        };
+      }
+    }
+  };
+  return normalized.steps.map(compileStep);
+};
+
+export {
+  makeWorkflowError,
+  evalInputExpr,
+  normalizeWorkflowDefV1,
+  validateWorkflowDefV1,
+  compileWorkflowStaticIrV1,
+  compileWorkflowRuntimeStepsV1
+};
+//# sourceMappingURL=chunk-3L6QGFMM.js.map