@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-UZZBHWIO.js

@@ -0,0 +1,703 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  isJsonValue,
+  projectJsonValue
+} from "./chunk-SI5OKFFY.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-DT7YIIWE.js";
+
+// ../logix-core/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
+  });
+};
+
+// ../logix-core/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;
+    }
+  }
+};
+
+// ../logix-core/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=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/workflow/errors.ts", "../../../../logix-core/src/internal/workflow/inputExpr.ts", "../../../../logix-core/src/internal/workflow/compiler.ts"],
  "sourcesContent": ["import { stableStringify } from '../digest.js'\nimport { isJsonValue, type JsonValue, projectJsonValue } from '../observability/jsonValue.js'\n\nexport type WorkflowErrorCode =\n  | 'WORKFLOW_UNSUPPORTED_VERSION'\n  | 'WORKFLOW_INVALID_DEF'\n  | 'WORKFLOW_INVALID_TRIGGER'\n  | 'WORKFLOW_INVALID_STEP'\n  | 'WORKFLOW_DUPLICATE_STEP_KEY'\n  | 'WORKFLOW_INVALID_INPUT_EXPR'\n  | 'WORKFLOW_INVALID_JSON_POINTER'\n  | 'WORKFLOW_INVALID_MERGE_ITEMS'\n  | 'WORKFLOW_INVALID_SERVICE_ID'\n  | 'WORKFLOW_MISSING_SERVICE'\n  | 'WORKFLOW_INVALID_SERVICE_PORT'\n  | 'WORKFLOW_CALL_TIMEOUT'\n\nexport interface WorkflowError extends Error {\n  readonly _tag: 'WorkflowError'\n  readonly code: WorkflowErrorCode\n  readonly programId?: string\n  readonly source?: {\n    readonly stepKey?: string\n    readonly fragmentId?: string\n  }\n  readonly detail?: JsonValue\n}\n\nconst toJsonValue = (detail: unknown): JsonValue => {\n  if (isJsonValue(detail)) return detail\n  return projectJsonValue(detail).value\n}\n\nexport const makeWorkflowError = (args: {\n  readonly code: WorkflowErrorCode\n  readonly message: string\n  readonly programId?: string\n  readonly source?: WorkflowError['source']\n  readonly detail?: unknown\n}): WorkflowError => {\n  const detailJson = args.detail !== undefined ? toJsonValue(args.detail) : undefined\n  const msg = args.detail !== undefined ? `${args.message}\\n(detail=${stableStringify(detailJson)})` : args.message\n\n  return Object.assign(new Error(msg), {\n    _tag: 'WorkflowError' as const,\n    code: args.code,\n    programId: args.programId,\n    source: args.source,\n    detail: detailJson,\n  }) as WorkflowError\n}\n", "import { isJsonValue } from '../observability/jsonValue.js'\nimport { makeWorkflowError } from './errors.js'\nimport type { InputExprV1 } from './model.js'\n\nexport type JsonPointerToken = string | number\n\nconst decodePointerToken = (raw: string): string => raw.replace(/~1/g, '/').replace(/~0/g, '~')\n\nconst isIndexToken = (token: string): boolean => token === '0' || (!token.startsWith('0') && /^\\d+$/.test(token))\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\nexport const parseJsonPointer = (pointer: string): ReadonlyArray<JsonPointerToken> => {\n  if (pointer === '') return []\n  if (!pointer.startsWith('/')) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_JSON_POINTER',\n      message: 'Invalid JSON Pointer (must be \"\" or start with \"/\").',\n      detail: { pointer },\n    })\n  }\n\n  const raw = pointer.split('/').slice(1)\n  const out: JsonPointerToken[] = []\n  for (const part of raw) {\n    const decoded = decodePointerToken(part)\n    out.push(isIndexToken(decoded) ? Number(decoded) : decoded)\n  }\n  return out\n}\n\nexport type CompiledInputExpr =\n  | { readonly kind: 'payload' }\n  | { readonly kind: 'payload.path'; readonly pointer: string; readonly tokens: ReadonlyArray<JsonPointerToken> }\n  | { readonly kind: 'const'; readonly value: unknown }\n  | { readonly kind: 'object'; readonly fields: ReadonlyArray<readonly [string, CompiledInputExpr]> }\n  | { readonly kind: 'merge'; readonly items: ReadonlyArray<CompiledInputExpr> }\n\nexport const compileInputExpr = (expr: InputExprV1, pathForError?: { readonly stepKey?: string }): CompiledInputExpr => {\n  switch (expr.kind) {\n    case 'payload':\n      return { kind: 'payload' }\n    case 'payload.path': {\n      const pointer = expr.pointer\n      if (typeof pointer !== 'string') {\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_INPUT_EXPR',\n          message: 'InputExpr.payload.path.pointer must be a string.',\n          source: { stepKey: pathForError?.stepKey },\n          detail: { pointer },\n        })\n      }\n      return { kind: 'payload.path', pointer, tokens: parseJsonPointer(pointer) }\n    }\n    case 'const': {\n      const value: unknown = expr.value\n      if (!isJsonValue(value)) {\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_INPUT_EXPR',\n          message: 'InputExpr.const.value must be JSON-serializable.',\n          source: { stepKey: pathForError?.stepKey },\n          detail: { value },\n        })\n      }\n      return { kind: 'const', value }\n    }\n    case 'object': {\n      const fields: unknown = expr.fields\n      if (!fields || typeof fields !== 'object' || Array.isArray(fields)) {\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_INPUT_EXPR',\n          message: 'InputExpr.object.fields must be a record.',\n          source: { stepKey: pathForError?.stepKey },\n        })\n      }\n      const entries = Object.entries(fields as Record<string, InputExprV1>).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n      return {\n        kind: 'object',\n        fields: entries.map(([k, v]) => [k, compileInputExpr(v, pathForError)] as const),\n      }\n    }\n    case 'merge': {\n      const items: unknown = expr.items\n      if (!Array.isArray(items)) {\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_INPUT_EXPR',\n          message: 'InputExpr.merge.items must be an array.',\n          source: { stepKey: pathForError?.stepKey },\n        })\n      }\n\n      // Hard gate: merge.items must all be object (enforced at compile-time; runtime should not branch).\n      for (const item of items) {\n        const kind = isRecord(item) ? item.kind : undefined\n        if (kind !== 'object') {\n          throw makeWorkflowError({\n            code: 'WORKFLOW_INVALID_MERGE_ITEMS',\n            message: 'InputExpr.merge.items must all be InputExpr.object.',\n            source: { stepKey: pathForError?.stepKey },\n            detail: { kind },\n          })\n        }\n      }\n\n      return {\n        kind: 'merge',\n        items: (items as ReadonlyArray<InputExprV1>).map((i) => compileInputExpr(i, pathForError)),\n      }\n    }\n  }\n}\n\nconst isPlainRecord = (value: unknown): value is Record<string, unknown> => {\n  if (typeof value !== 'object' || value === null) return false\n  if (Array.isArray(value)) return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\nconst evalPointer = (root: unknown, tokens: ReadonlyArray<JsonPointerToken>): unknown => {\n  let current: unknown = root\n  for (const token of tokens) {\n    if (current == null) return undefined\n    if (Array.isArray(current) && typeof token === 'number') {\n      current = current[token]\n      continue\n    }\n    if (typeof current !== 'object') return undefined\n    const key = typeof token === 'number' ? String(token) : token\n    current = (current as Record<string, unknown>)[key]\n  }\n  return current\n}\n\nexport const evalInputExpr = (expr: CompiledInputExpr, payload: unknown): unknown => {\n  switch (expr.kind) {\n    case 'payload':\n      return payload\n    case 'payload.path':\n      return evalPointer(payload, expr.tokens)\n    case 'const':\n      return expr.value\n    case 'object': {\n      const out: Record<string, unknown> = {}\n      for (const [k, v] of expr.fields) {\n        out[k] = evalInputExpr(v, payload)\n      }\n      return out\n    }\n    case 'merge': {\n      const out: Record<string, unknown> = {}\n      for (const item of expr.items) {\n        const value = evalInputExpr(item, payload)\n        if (isPlainRecord(value)) {\n          for (const [k, v] of Object.entries(value)) {\n            out[k] = v\n          }\n        }\n      }\n      return out\n    }\n  }\n}\n", "import { fnv1a32, stableStringify } from '../digest.js'\nimport { isJsonValue, projectJsonValue, type JsonValue } from '../observability/jsonValue.js'\nimport { makeWorkflowError } from './errors.js'\nimport type {\n  InputExprV1,\n  StepKey,\n  WorkflowDefV1,\n  WorkflowStepV1,\n  WorkflowStaticIrV1,\n  WorkflowStaticNode,\n  WorkflowStaticStep,\n  WorkflowTriggerV1,\n  WorkflowStableId,\n  WorkflowNodeId,\n  WorkflowEdge,\n  WorkflowEdgeKind,\n} from './model.js'\nimport { compileInputExpr, type CompiledInputExpr } from './inputExpr.js'\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\nconst asNonEmptyString = (value: unknown): string | undefined =>\n  typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined\n\nconst asNonNegInt = (value: unknown): number | undefined => {\n  if (typeof value !== 'number' || !Number.isFinite(value)) return undefined\n  const n = Math.floor(value)\n  return n >= 0 ? n : undefined\n}\n\nconst asPosInt = (value: unknown): number | undefined => {\n  if (typeof value !== 'number' || !Number.isFinite(value)) return undefined\n  const n = Math.floor(value)\n  return n > 0 ? n : undefined\n}\n\nexport const normalizeWorkflowDefV1 = (input: WorkflowDefV1): WorkflowDefV1 => {\n  // Fill trivial defaults (canonical shape):\n  // - call.onSuccess/onFailure must be explicit arrays.\n  // - The normalization must be deep: nested call steps may come from def-like inputs and miss the arrays.\n  const normalizeStep = (step: WorkflowStepV1): WorkflowStepV1 => {\n    if (!isRecord(step)) return step\n    if (step.kind !== 'call') return step\n\n    const raw = step as unknown as { readonly onSuccess?: unknown; readonly onFailure?: unknown }\n    const onSuccessRaw = Array.isArray(raw.onSuccess) ? (raw.onSuccess as ReadonlyArray<WorkflowStepV1>) : []\n    const onFailureRaw = Array.isArray(raw.onFailure) ? (raw.onFailure as ReadonlyArray<WorkflowStepV1>) : []\n\n    return {\n      ...step,\n      onSuccess: onSuccessRaw.map(normalizeStep),\n      onFailure: onFailureRaw.map(normalizeStep),\n    }\n  }\n\n  const normalizeSteps = (steps: ReadonlyArray<WorkflowStepV1>): ReadonlyArray<WorkflowStepV1> => steps.map(normalizeStep)\n\n  return {\n    ...input,\n    steps: normalizeSteps(input.steps),\n  }\n}\n\nexport function validateWorkflowDefV1(def: unknown, options?: { readonly moduleId?: string }): asserts def is WorkflowDefV1 {\n  if (!isRecord(def)) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_DEF',\n      message: 'WorkflowDef must be an object.',\n      detail: { def },\n    })\n  }\n\n  if (def.astVersion !== 1) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_UNSUPPORTED_VERSION',\n      message: 'Unsupported workflow astVersion.',\n      detail: { astVersion: def.astVersion },\n    })\n  }\n\n  if (!asNonEmptyString(def.localId)) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_DEF',\n      message: 'WorkflowDef.localId must be a non-empty string.',\n      detail: { localId: def.localId },\n    })\n  }\n\n  const trigger = def.trigger\n  if (!isRecord(trigger)) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_TRIGGER',\n      message: 'Workflow trigger must be an object.',\n      detail: { trigger },\n    })\n  }\n  if (trigger.kind === 'action') {\n    if (!asNonEmptyString(trigger.actionTag)) {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_INVALID_TRIGGER',\n        message: 'Workflow trigger.actionTag must be a non-empty string.',\n        detail: { trigger },\n      })\n    }\n  } else if (trigger.kind === 'lifecycle') {\n    const phase = trigger.phase\n    if (phase !== 'onStart' && phase !== 'onInit') {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_INVALID_TRIGGER',\n        message: 'Workflow trigger.phase must be \"onStart\" or \"onInit\".',\n        detail: { trigger },\n      })\n    }\n  } else {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_TRIGGER',\n      message: 'Workflow trigger.kind must be \"action\" or \"lifecycle\".',\n      detail: { trigger },\n    })\n  }\n\n  if (!Array.isArray(def.steps)) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_DEF',\n      message: 'WorkflowDef.steps must be an array.',\n      detail: { steps: def.steps },\n    })\n  }\n\n  const seenKeys = new Set<string>()\n  const visit = (step: unknown, fragmentId?: string): void => {\n    if (!isRecord(step)) {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_INVALID_STEP',\n        message: 'Workflow step must be an object.',\n        detail: { step },\n        source: fragmentId ? { fragmentId } : undefined,\n      })\n    }\n\n    const key = asNonEmptyString(step.key)\n    if (!key) {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_INVALID_STEP',\n        message: 'Workflow step.key must be a non-empty string.',\n        detail: { stepKey: step.key, kind: step.kind },\n        source: fragmentId ? { fragmentId } : undefined,\n      })\n    }\n\n    if (seenKeys.has(key)) {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_DUPLICATE_STEP_KEY',\n        message: `Duplicate stepKey \"${key}\" detected.`,\n        detail: { duplicateKey: key },\n        source: { stepKey: key, ...(fragmentId ? { fragmentId } : null) },\n      })\n    }\n    seenKeys.add(key)\n\n    if (step.kind === 'dispatch') {\n      if (!asNonEmptyString(step.actionTag)) {\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_STEP',\n          message: 'dispatch.actionTag must be a non-empty string.',\n          source: { stepKey: key, ...(fragmentId ? { fragmentId } : null) },\n          detail: { actionTag: step.actionTag },\n        })\n      }\n      const payload = step.payload\n      if (payload !== undefined) {\n        validateInputExpr(payload, { stepKey: key })\n      }\n      return\n    }\n\n    if (step.kind === 'delay') {\n      const ms = asNonNegInt(step.ms)\n      if (ms === undefined) {\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_STEP',\n          message: 'delay.ms must be a non-negative integer.',\n          source: { stepKey: key, ...(fragmentId ? { fragmentId } : null) },\n          detail: { ms: step.ms },\n        })\n      }\n      return\n    }\n\n    if (step.kind === 'call') {\n      if (!asNonEmptyString(step.serviceId)) {\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_SERVICE_ID',\n          message: 'call.serviceId must be a non-empty string.',\n          source: { stepKey: key, ...(fragmentId ? { fragmentId } : null) },\n          detail: { serviceId: step.serviceId },\n        })\n      }\n      const inputExpr = step.input\n      if (inputExpr !== undefined) {\n        validateInputExpr(inputExpr, { stepKey: key })\n      }\n      const timeoutMsRaw = step.timeoutMs\n      if (timeoutMsRaw !== undefined && asPosInt(timeoutMsRaw) === undefined) {\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_STEP',\n          message: 'call.timeoutMs must be a positive integer (milliseconds).',\n          source: { stepKey: key, ...(fragmentId ? { fragmentId } : null) },\n          detail: { timeoutMs: timeoutMsRaw },\n        })\n      }\n      const retryRaw = step.retry\n      if (retryRaw !== undefined) {\n        const times = isRecord(retryRaw) ? asPosInt(retryRaw.times) : undefined\n        if (times === undefined) {\n          throw makeWorkflowError({\n            code: 'WORKFLOW_INVALID_STEP',\n            message: 'call.retry.times must be a positive integer.',\n            source: { stepKey: key, ...(fragmentId ? { fragmentId } : null) },\n            detail: { retry: retryRaw },\n          })\n        }\n      }\n\n      const onSuccess = Array.isArray(step.onSuccess) ? step.onSuccess : []\n      const onFailure = Array.isArray(step.onFailure) ? step.onFailure : []\n      for (const inner of onSuccess) visit(inner, fragmentId)\n      for (const inner of onFailure) visit(inner, fragmentId)\n      return\n    }\n\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_STEP',\n      message: 'Unknown step kind.',\n      source: { stepKey: key, ...(fragmentId ? { fragmentId } : null) },\n      detail: { kind: step.kind },\n    })\n  }\n\n  const sources = def.sources\n  const fragmentByStepKey = new Map<string, string | undefined>()\n  if (sources && typeof sources === 'object') {\n    for (const [k, v] of Object.entries(sources)) {\n      fragmentByStepKey.set(k, isRecord(v) ? asNonEmptyString(v.fragmentId) : undefined)\n    }\n  }\n\n  for (const step of def.steps) {\n    const key = isRecord(step) ? asNonEmptyString(step.key) : undefined\n    const fragmentId = key ? fragmentByStepKey.get(key) : undefined\n    visit(step, fragmentId)\n  }\n\n  // meta.generator must stay JSON-only.\n  const generator = isRecord(def.meta) ? def.meta.generator : undefined\n  if (generator !== undefined && !isJsonValue(generator)) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_DEF',\n      message: 'WorkflowDef.meta.generator must be JSON-serializable.',\n      detail: { generator },\n    })\n  }\n\n  // policy validation (minimal)\n  const policy = isRecord(def.policy) ? def.policy : undefined\n  if (policy) {\n    const concurrency = policy.concurrency\n    if (concurrency !== undefined && concurrency !== 'latest' && concurrency !== 'exhaust' && concurrency !== 'parallel') {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_INVALID_DEF',\n        message: 'policy.concurrency must be latest|exhaust|parallel.',\n        detail: { concurrency },\n      })\n    }\n    const priority = policy.priority\n    if (priority !== undefined && priority !== 'urgent' && priority !== 'nonUrgent') {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_INVALID_DEF',\n        message: 'policy.priority must be urgent|nonUrgent.',\n        detail: { priority },\n      })\n    }\n  }\n\n  // moduleId is only used to improve error context; no additional validation here.\n  void options?.moduleId\n}\n\nconst validateInputExpr = (expr: unknown, options?: { readonly stepKey?: string }): void => {\n  const visit = (e: unknown): void => {\n    if (!isRecord(e)) {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_INVALID_INPUT_EXPR',\n        message: 'InputExpr must be an object.',\n        source: { stepKey: options?.stepKey },\n        detail: { expr: e },\n      })\n    }\n    const kind = e.kind\n    switch (kind) {\n      case 'payload':\n        return\n      case 'payload.path': {\n        const pointer = e.pointer\n        if (typeof pointer !== 'string') {\n          throw makeWorkflowError({\n            code: 'WORKFLOW_INVALID_INPUT_EXPR',\n            message: 'InputExpr.payload.path.pointer must be a string.',\n            source: { stepKey: options?.stepKey },\n            detail: { pointer },\n          })\n        }\n        return\n      }\n      case 'const': {\n        const value = e.value\n        if (!isJsonValue(value)) {\n          throw makeWorkflowError({\n            code: 'WORKFLOW_INVALID_INPUT_EXPR',\n            message: 'InputExpr.const.value must be JSON-serializable.',\n            source: { stepKey: options?.stepKey },\n          })\n        }\n        return\n      }\n      case 'object': {\n        const fields = e.fields\n        if (!isRecord(fields)) {\n          throw makeWorkflowError({\n            code: 'WORKFLOW_INVALID_INPUT_EXPR',\n            message: 'InputExpr.object.fields must be a record.',\n            source: { stepKey: options?.stepKey },\n          })\n        }\n        for (const v of Object.values(fields)) {\n          visit(v)\n        }\n        return\n      }\n      case 'merge': {\n        const items = e.items\n        if (!Array.isArray(items)) {\n          throw makeWorkflowError({\n            code: 'WORKFLOW_INVALID_INPUT_EXPR',\n            message: 'InputExpr.merge.items must be an array.',\n            source: { stepKey: options?.stepKey },\n          })\n        }\n        for (const item of items) {\n          visit(item)\n        }\n        return\n      }\n      default:\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_INPUT_EXPR',\n          message: 'Unknown InputExpr kind.',\n          source: { stepKey: options?.stepKey },\n          detail: { kind },\n        })\n    }\n  }\n\n  visit(expr)\n}\n\n// ---- Static IR compilation ----\n\nconst makeDigest = (prefix: string, value: unknown): string => `${prefix}:${fnv1a32(stableStringify(value))}`\n\nconst makeTriggerNodeId = (programId: string): WorkflowNodeId => `wf_trigger_v1:${fnv1a32(programId)}`\n\nconst makeStepNodeId = (programId: string, stepKey: StepKey, kind: string): WorkflowNodeId =>\n  `wf_node_v1:${fnv1a32(`${programId}\\u0000${stepKey}\\u0000${kind}`)}`\n\nconst budgetJsonValue = (value: JsonValue): JsonValue => projectJsonValue(value).value\n\nconst budgetInputExpr = (expr: InputExprV1): InputExprV1 => {\n  switch (expr.kind) {\n    case 'payload':\n    case 'payload.path':\n      return expr\n    case 'const': {\n      const value: unknown = expr.value\n      if (!isJsonValue(value)) return expr\n      return { ...expr, value: budgetJsonValue(expr.value) }\n    }\n    case 'object': {\n      const out: { [k: string]: InputExprV1 } = {}\n      for (const k of Object.keys(expr.fields).sort()) {\n        out[k] = budgetInputExpr(expr.fields[k]!)\n      }\n      return { ...expr, fields: out }\n    }\n    case 'merge':\n      return { ...expr, items: expr.items.map(budgetInputExpr) }\n  }\n}\n\nconst toStaticStep = (step: WorkflowStepV1): WorkflowStaticStep => {\n  switch (step.kind) {\n    case 'dispatch':\n      return {\n        kind: 'dispatch',\n        actionTag: step.actionTag,\n        ...(step.payload ? { payload: budgetInputExpr(step.payload) } : null),\n      }\n    case 'delay':\n      return { kind: 'delay', ms: step.ms }\n    case 'call': {\n      const policy =\n        step.timeoutMs !== undefined || step.retry !== undefined\n          ? {\n              ...(step.timeoutMs !== undefined ? { timeoutMs: step.timeoutMs } : null),\n              ...(step.retry !== undefined ? { retry: { times: step.retry.times } } : null),\n            }\n          : undefined\n      return {\n        kind: 'call',\n        serviceId: step.serviceId,\n        ...(step.input ? { input: budgetInputExpr(step.input) } : null),\n        ...(policy ? { policy } : null),\n      }\n    }\n  }\n}\n\nexport const compileWorkflowStaticIrV1 = (args: {\n  readonly moduleId: string\n  readonly def: WorkflowDefV1\n}): WorkflowStaticIrV1 => {\n  const normalized = normalizeWorkflowDefV1(args.def)\n  validateWorkflowDefV1(normalized, { moduleId: args.moduleId })\n\n  const programId: WorkflowStableId = `${args.moduleId}.${normalized.localId}`\n  const triggerNodeId = makeTriggerNodeId(programId)\n\n  const fragmentByStepKey = new Map<string, string | undefined>()\n  if (normalized.sources && typeof normalized.sources === 'object') {\n    for (const [k, v] of Object.entries(normalized.sources)) {\n      fragmentByStepKey.set(k, isRecord(v) ? asNonEmptyString(v.fragmentId) : undefined)\n    }\n  }\n\n  const nodesByKey = new Map<string, WorkflowNodeId>()\n\n  const collectNodes = (steps: ReadonlyArray<WorkflowStepV1>) => {\n    for (const step of steps) {\n      const id = makeStepNodeId(programId, step.key, step.kind)\n      nodesByKey.set(step.key, id)\n      if (step.kind === 'call') {\n        collectNodes(step.onSuccess)\n        collectNodes(step.onFailure)\n      }\n    }\n  }\n  collectNodes(normalized.steps)\n\n  const nodes: WorkflowStaticNode[] = [\n    {\n      id: triggerNodeId,\n      kind: 'trigger',\n      trigger: normalized.trigger,\n    },\n  ]\n\n  const addStepNodes = (steps: ReadonlyArray<WorkflowStepV1>) => {\n    for (const step of steps) {\n      const id = nodesByKey.get(step.key)\n      if (!id) continue\n      const fragmentId = fragmentByStepKey.get(step.key)\n      nodes.push({\n        id,\n        kind: 'step',\n        step: toStaticStep(step),\n        source: {\n          stepKey: step.key,\n          ...(fragmentId ? { fragmentId } : null),\n        },\n      })\n      if (step.kind === 'call') {\n        addStepNodes(step.onSuccess)\n        addStepNodes(step.onFailure)\n      }\n    }\n  }\n  addStepNodes(normalized.steps)\n\n  const edges: WorkflowEdge[] = []\n\n  const pushEdge = (from: WorkflowNodeId, to: WorkflowNodeId, kind: WorkflowEdgeKind): void => {\n    edges.push({ from, to, kind })\n  }\n\n  const compileBlock = (args: {\n    readonly steps: ReadonlyArray<WorkflowStepV1>\n    readonly entryFrom: ReadonlyArray<WorkflowNodeId>\n    readonly entryKind: WorkflowEdgeKind\n    readonly continuation?: WorkflowNodeId\n  }): void => {\n    if (args.steps.length === 0) {\n      if (args.continuation) {\n        for (const from of args.entryFrom) {\n          pushEdge(from, args.continuation, args.entryKind)\n        }\n      }\n      return\n    }\n\n    const first = args.steps[0]!\n    const firstId = nodesByKey.get(first.key)\n    if (!firstId) {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_INVALID_STEP',\n        message: 'Internal error: missing node id for stepKey.',\n        programId,\n        source: { stepKey: first.key },\n      })\n    }\n\n    for (const from of args.entryFrom) {\n      pushEdge(from, firstId, args.entryKind)\n    }\n\n    const compileStepAndTail = (step: WorkflowStepV1, tail: ReadonlyArray<WorkflowStepV1>, continuation?: WorkflowNodeId) => {\n      const stepId = nodesByKey.get(step.key)\n      if (!stepId) return\n\n      if (step.kind !== 'call') {\n        compileBlock({ steps: tail, entryFrom: [stepId], entryKind: 'next', continuation })\n        return\n      }\n\n      const cont = tail.length > 0 ? nodesByKey.get(tail[0]!.key) : continuation\n\n      compileBlock({\n        steps: step.onSuccess,\n        entryFrom: [stepId],\n        entryKind: 'success',\n        continuation: cont,\n      })\n      compileBlock({\n        steps: step.onFailure,\n        entryFrom: [stepId],\n        entryKind: 'failure',\n        continuation: cont,\n      })\n\n      compileBlock({ steps: tail, entryFrom: [], entryKind: 'next', continuation })\n    }\n\n    compileStepAndTail(first, args.steps.slice(1), args.continuation)\n  }\n\n  compileBlock({ steps: normalized.steps, entryFrom: [triggerNodeId], entryKind: 'next', continuation: undefined })\n\n  // Stable ordering (for diff/digest).\n  nodes.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))\n  edges.sort((a, b) => {\n    if (a.from !== b.from) return a.from < b.from ? -1 : 1\n    if (a.to !== b.to) return a.to < b.to ? -1 : 1\n    const ak = String(a.kind ?? '')\n    const bk = String(b.kind ?? '')\n    if (ak !== bk) return ak < bk ? -1 : 1\n    return 0\n  })\n\n  const meta: Record<string, JsonValue> | undefined = (() => {\n    const generator = normalized.meta?.generator\n    if (generator === undefined) return undefined\n    return { generator: budgetJsonValue(generator) }\n  })()\n\n  const irNoDigest = {\n    version: 1,\n    programId,\n    nodes,\n    edges,\n    policy: normalized.policy,\n    meta,\n  } as const\n\n  const digest = makeDigest('workflow_ir_v1', irNoDigest)\n\n  return {\n    ...irNoDigest,\n    digest,\n  }\n}\n\n// ---- Runtime compilation (InputExpr precompile + shape checks) ----\n\nexport type CompiledWorkflowStep =\n  | { readonly kind: 'dispatch'; readonly key: StepKey; readonly actionTag: string; readonly payload?: CompiledInputExpr }\n  | { readonly kind: 'delay'; readonly key: StepKey; readonly ms: number }\n  | {\n      readonly kind: 'call'\n      readonly key: StepKey\n      readonly serviceId: string\n      readonly input?: CompiledInputExpr\n      readonly timeoutMs?: number\n      readonly retryTimes?: number\n      readonly onSuccess: ReadonlyArray<CompiledWorkflowStep>\n      readonly onFailure: ReadonlyArray<CompiledWorkflowStep>\n    }\n\nexport const compileWorkflowRuntimeStepsV1 = (args: {\n  readonly def: WorkflowDefV1\n}): ReadonlyArray<CompiledWorkflowStep> => {\n  const normalized = normalizeWorkflowDefV1(args.def)\n  validateWorkflowDefV1(normalized)\n\n  const compileStep = (step: WorkflowStepV1): CompiledWorkflowStep => {\n    const stepKey = step.key\n    switch (step.kind) {\n      case 'dispatch':\n        return {\n          kind: 'dispatch',\n          key: step.key,\n          actionTag: step.actionTag,\n          ...(step.payload ? { payload: compileInputExpr(step.payload, { stepKey }) } : null),\n        }\n      case 'delay':\n        return { kind: 'delay', key: step.key, ms: step.ms }\n      case 'call': {\n        const retryTimes = step.retry?.times\n        return {\n          kind: 'call',\n          key: step.key,\n          serviceId: step.serviceId,\n          ...(step.input ? { input: compileInputExpr(step.input, { stepKey }) } : null),\n          ...(step.timeoutMs !== undefined ? { timeoutMs: step.timeoutMs } : null),\n          ...(retryTimes !== undefined ? { retryTimes } : null),\n          onSuccess: step.onSuccess.map(compileStep),\n          onFailure: step.onFailure.map(compileStep),\n        }\n      }\n    }\n  }\n\n  return normalized.steps.map(compileStep)\n}\n"],
  "mappings": "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",
  "names": ["isRecord", "args"]
}
