@mesh-tech/mesh-cli 0.36.0 → 0.37.0

package/dist/bin/mesh.src-5D5DFSLX.js

@@ -0,0 +1,1302 @@
+// packages/workflow-model/src/workflow-ir.ts
+function computeHappyPath(nodes, edges) {
+  const startNode = nodes.find((n) => n.type === "start");
+  const endNodes = nodes.filter((n) => n.type === "end");
+  if (!startNode || endNodes.length === 0) return [];
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const list = adjacency.get(edge.from) ?? [];
+    list.push(edge);
+    adjacency.set(edge.from, list);
+  }
+  const waitNodeIds = new Set(nodes.filter((n) => n.type === "wait").map((n) => n.id));
+  function pathHasWait(startId) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [startId];
+    for (let depth = 0; depth < 6 && queue.length > 0; depth++) {
+      const next = [];
+      for (const id of queue) {
+        if (waitNodeIds.has(id)) return true;
+        if (visited.has(id)) continue;
+        visited.add(id);
+        for (const e of adjacency.get(id) ?? []) {
+          if (!e.isExceptional && !e.isTimeout) next.push(e.to);
+        }
+      }
+      queue.length = 0;
+      queue.push(...next);
+    }
+    return false;
+  }
+  const successEndIds = new Set(
+    endNodes.filter((n) => n.outcome !== "failure").map((n) => n.id)
+  );
+  const failureEndIds = new Set(
+    endNodes.filter((n) => n.outcome === "failure").map((n) => n.id)
+  );
+  const allEndIds = new Set(endNodes.map((n) => n.id));
+  function bfs(targetIds, allowExceptional) {
+    const queue = [
+      { id: startNode.id, path: [startNode.id] }
+    ];
+    const visited = /* @__PURE__ */ new Set([startNode.id]);
+    while (queue.length > 0) {
+      const { id, path } = queue.shift();
+      if (targetIds.has(id)) return path;
+      const neighbors = adjacency.get(id) ?? [];
+      const hasMainEdge = neighbors.some((e) => e.isMainPath);
+      const candidates = hasMainEdge ? neighbors.filter((e) => e.isMainPath) : neighbors;
+      const sorted = [...candidates].sort((a, b) => {
+        const aErr = a.isExceptional || a.isTimeout;
+        const bErr = b.isExceptional || b.isTimeout;
+        if (aErr && !bErr) return 1;
+        if (!aErr && bErr) return -1;
+        const aWait = waitNodeIds.has(a.to) || pathHasWait(a.to);
+        const bWait = waitNodeIds.has(b.to) || pathHasWait(b.to);
+        if (aWait && !bWait) return 1;
+        if (!aWait && bWait) return -1;
+        return 0;
+      });
+      for (const neighbor of sorted) {
+        if (visited.has(neighbor.to)) continue;
+        if (!allowExceptional && (neighbor.isExceptional || neighbor.isTimeout || failureEndIds.has(neighbor.to)))
+          continue;
+        visited.add(neighbor.to);
+        queue.push({ id: neighbor.to, path: [...path, neighbor.to] });
+      }
+    }
+    return null;
+  }
+  return bfs(successEndIds, false) ?? bfs(allEndIds, false) ?? bfs(allEndIds, true) ?? [];
+}
+function isProcessArtifactProvenance(value) {
+  return typeof value === "object" && value !== null && value.source === "process-artifact";
+}
+function childGraphsOf(node) {
+  const graphs = [];
+  const withChild = node;
+  if (withChild.childGraph) graphs.push(withChild.childGraph);
+  const withBacking = node;
+  if (withBacking.backing?.backingGraph) graphs.push(withBacking.backing.backingGraph);
+  return graphs;
+}
+function walkProcessNodes(ir, scope = []) {
+  const out = [];
+  for (const node of ir.nodes) {
+    if (isProcessArtifactProvenance(node.provenance)) {
+      out.push({ nodeId: node.id, scope, node, provenance: node.provenance });
+    }
+    for (const child of childGraphsOf(node)) {
+      out.push(...walkProcessNodes(child, [...scope, node.id]));
+    }
+  }
+  return out;
+}
+function findProcessNodesByCommand(ir, command) {
+  return walkProcessNodes(ir).filter((m) => m.provenance.bind?.commands?.includes(command));
+}
+function findProcessNodesByElementId(ir, elementId, element) {
+  return walkProcessNodes(ir).filter(
+    (m) => m.provenance.elementId === elementId && (element === void 0 || m.provenance.element === element)
+  );
+}
+var WorkflowPatchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkflowPatchError";
+  }
+};
+function cloneWorkflow(workflow) {
+  return JSON.parse(JSON.stringify(workflow));
+}
+function cloneMaybeWorkflow(workflow) {
+  return workflow ? cloneWorkflow(workflow) : null;
+}
+function upsertAtIndex(items, item, index) {
+  const next = [...items];
+  if (index === void 0 || index < 0 || index >= next.length) {
+    next.push(item);
+    return next;
+  }
+  next.splice(index, 0, item);
+  return next;
+}
+function edgeMatches(edge, from, to) {
+  return edge.from === from && edge.to === to;
+}
+function ensureNodeExists(workflow, nodeId) {
+  if (!workflow.nodes.some((node) => node.id === nodeId)) {
+    throw new WorkflowPatchError(`Node not found: ${nodeId}`);
+  }
+}
+function ensureNoDuplicateNode(workflow, nodeId) {
+  if (workflow.nodes.some((node) => node.id === nodeId)) {
+    throw new WorkflowPatchError(`Duplicate node id: ${nodeId}`);
+  }
+}
+function isDuplicateEdge(workflow, edge) {
+  return workflow.edges.some(
+    (existing) => existing.from === edge.from && existing.to === edge.to && existing.fromExit === edge.fromExit
+  );
+}
+function sanitizeMainPath(workflow, mainPath) {
+  const nodeIds = new Set(workflow.nodes.map((node) => node.id));
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const nodeId of mainPath) {
+    if (!nodeIds.has(nodeId)) {
+      throw new WorkflowPatchError(`Main path references unknown node: ${nodeId}`);
+    }
+    if (seen.has(nodeId)) {
+      continue;
+    }
+    seen.add(nodeId);
+    normalized.push(nodeId);
+  }
+  return normalized;
+}
+function getChildGraph(node) {
+  if ("childGraph" in node && node.childGraph) return node.childGraph;
+  if ("backing" in node && node.backing?.backingGraph)
+    return node.backing.backingGraph;
+  return null;
+}
+function setChildGraph(node, childGraph) {
+  if ("childGraph" in node) return { ...node, childGraph };
+  if ("backing" in node && node.backing?.backingGraph) {
+    return {
+      ...node,
+      backing: { ...node.backing, backingGraph: childGraph }
+    };
+  }
+  return { ...node, childGraph };
+}
+function applyScopedPatch(workflow, scope, patch) {
+  const [headId, ...rest] = scope;
+  const next = cloneWorkflow(workflow);
+  const nodeIndex = next.nodes.findIndex((n) => n.id === headId);
+  if (nodeIndex === -1) {
+    throw new WorkflowPatchError(`Scoped patch: node '${headId}' not found in current graph`);
+  }
+  const node = next.nodes[nodeIndex];
+  let childGraph = getChildGraph(node);
+  if (!childGraph) {
+    const canHoldChildGraph = node.type === "group" || node.type === "child_workflow";
+    if (!canHoldChildGraph) {
+      throw new WorkflowPatchError(
+        `Scoped patch: node '${headId}' (type '${node.type}') cannot hold a child graph`
+      );
+    }
+    childGraph = { name: "", description: "", nodes: [], edges: [], mainPath: [] };
+  }
+  const unscopedPatch = { ...patch, scope: rest.length > 0 ? rest : void 0 };
+  const updatedChild = applyWorkflowPatch(childGraph, unscopedPatch);
+  next.nodes[nodeIndex] = setChildGraph(node, updatedChild);
+  return next;
+}
+function wrapIntoGroup(workflow, nodeIds, groupId, label, groupType) {
+  if (nodeIds.length === 0) throw new WorkflowPatchError("group: nodeIds is empty");
+  const inSet = new Set(nodeIds);
+  if (workflow.nodes.some((n) => n.id === groupId)) {
+    throw new WorkflowPatchError(`group: id '${groupId}' already exists`);
+  }
+  for (const id of nodeIds) {
+    const node = workflow.nodes.find((n) => n.id === id);
+    if (!node) throw new WorkflowPatchError(`group: node '${id}' not found`);
+    if (node.type === "start" || node.type === "end") {
+      throw new WorkflowPatchError(`group: cannot wrap a '${node.type}' node ('${id}')`);
+    }
+  }
+  const internal = [];
+  const incoming = [];
+  const outgoing = [];
+  const external = [];
+  for (const e of workflow.edges) {
+    const f = inSet.has(e.from);
+    const t = inSet.has(e.to);
+    if (f && t) internal.push(e);
+    else if (!f && t) incoming.push(e);
+    else if (f && !t) outgoing.push(e);
+    else external.push(e);
+  }
+  const entryNodes = new Set(incoming.map((e) => e.to));
+  if (entryNodes.size === 0) {
+    const internalIn = new Set(internal.map((e) => e.to));
+    for (const id of nodeIds) if (!internalIn.has(id)) entryNodes.add(id);
+  }
+  const exitNodes = new Set(outgoing.map((e) => e.from));
+  if (exitNodes.size === 0) {
+    const internalOut = new Set(internal.map((e) => e.from));
+    for (const id of nodeIds) if (!internalOut.has(id)) exitNodes.add(id);
+  }
+  if (entryNodes.size !== 1) {
+    throw new WorkflowPatchError(
+      `group: the selection has ${entryNodes.size} entry points; wrap a single-entry region`
+    );
+  }
+  const entry = [...entryNodes][0];
+  const startId = `${groupId}__start`;
+  const groupedNodes = workflow.nodes.filter((n) => inSet.has(n.id));
+  const inParentMain = workflow.mainPath.filter((id) => inSet.has(id));
+  let childGraph;
+  let parentExitEdges;
+  const pulledIds = /* @__PURE__ */ new Set();
+  if (outgoing.length === 0) {
+    const endId = `${groupId}__end`;
+    const childNodes = [
+      { id: startId, type: "start", label: "Start" },
+      ...groupedNodes,
+      { id: endId, type: "end", label: "Done", outcome: "success" }
+    ];
+    const childEdges = [
+      { from: startId, to: entry, isMainPath: true },
+      ...internal,
+      ...[...exitNodes].map((from) => ({ from, to: endId, isMainPath: true }))
+    ];
+    childGraph = {
+      name: label,
+      description: "",
+      nodes: childNodes,
+      edges: childEdges,
+      mainPath: [startId, ...inParentMain.length ? inParentMain : nodeIds, endId]
+    };
+    parentExitEdges = [];
+  } else {
+    const byTarget = /* @__PURE__ */ new Map();
+    for (const e of outgoing) {
+      const arr = byTarget.get(e.to);
+      if (arr) arr.push(e);
+      else byTarget.set(e.to, [e]);
+    }
+    const isSoleRefTerminal = (target) => {
+      const node = workflow.nodes.find((n) => n.id === target);
+      if (!node || node.type !== "end") return false;
+      return workflow.edges.every((e) => e.to !== target || inSet.has(e.from));
+    };
+    const toChildEdge = (e, to) => ({
+      from: e.from,
+      to,
+      ...e.label ? { label: e.label } : {},
+      ...e.isMainPath ? { isMainPath: true } : {},
+      ...e.isExceptional ? { isExceptional: true } : {},
+      ...e.isTimeout ? { isTimeout: true } : {}
+    });
+    const extraChildNodes = [];
+    const exitChildEdges = [];
+    parentExitEdges = [];
+    let exitN = 0;
+    for (const [target, edges] of byTarget) {
+      if (isSoleRefTerminal(target)) {
+        const endNode = workflow.nodes.find((n) => n.id === target);
+        extraChildNodes.push(endNode);
+        pulledIds.add(target);
+        for (const e of edges) exitChildEdges.push(toChildEdge(e, target));
+      } else {
+        exitN += 1;
+        const exitId = `${groupId}__exit_${exitN}`;
+        const first = edges[0];
+        const anyMain = edges.some((e) => e.isMainPath);
+        const allExceptional = edges.every((e) => e.isExceptional || e.isTimeout);
+        const exitLabel = first.label ? first.label.charAt(0).toUpperCase() + first.label.slice(1) : workflow.nodes.find((n) => n.id === target)?.label ?? `Exit ${exitN}`;
+        extraChildNodes.push({
+          id: exitId,
+          type: "end",
+          label: exitLabel,
+          outcome: allExceptional ? "failure" : "success"
+        });
+        for (const e of edges) exitChildEdges.push(toChildEdge(e, exitId));
+        parentExitEdges.push({
+          from: groupId,
+          to: target,
+          fromExit: exitId,
+          ...first.label ? { label: first.label } : {},
+          ...anyMain ? { isMainPath: true } : {},
+          ...!anyMain && edges.every((e) => e.isExceptional) ? { isExceptional: true } : {},
+          ...!anyMain && edges.every((e) => e.isTimeout) ? { isTimeout: true } : {}
+        });
+      }
+    }
+    const successExit = extraChildNodes.find(
+      (n) => n.type === "end" && !pulledIds.has(n.id) && n.outcome === "success"
+    );
+    const mainEdgeKeys = /* @__PURE__ */ new Set();
+    const edgeKey = (a, b) => `${a}\0${b}`;
+    let mainBody = inParentMain.length ? inParentMain : nodeIds;
+    let mainTail = [];
+    if (successExit) {
+      const exitSources = new Set(
+        exitChildEdges.filter((e) => e.to === successExit.id).map((e) => e.from)
+      );
+      const adj = /* @__PURE__ */ new Map();
+      for (const e of internal) {
+        if (e.isExceptional || e.isTimeout) continue;
+        const arr = adj.get(e.from);
+        if (arr) arr.push(e.to);
+        else adj.set(e.from, [e.to]);
+      }
+      const prev = /* @__PURE__ */ new Map();
+      const visited = /* @__PURE__ */ new Set([entry]);
+      const queue = [entry];
+      let found;
+      while (queue.length > 0) {
+        const cur = queue.shift();
+        if (exitSources.has(cur)) {
+          found = cur;
+          break;
+        }
+        for (const nx of adj.get(cur) ?? []) {
+          if (!visited.has(nx)) {
+            visited.add(nx);
+            prev.set(nx, cur);
+            queue.push(nx);
+          }
+        }
+      }
+      if (found) {
+        const path = [];
+        for (let c = found; c !== void 0; c = prev.get(c)) path.unshift(c);
+        for (let i = 0; i < path.length - 1; i++) mainEdgeKeys.add(edgeKey(path[i], path[i + 1]));
+        mainEdgeKeys.add(edgeKey(found, successExit.id));
+        mainBody = path;
+        mainTail = [successExit.id];
+      }
+    }
+    const markMain = (e) => mainEdgeKeys.has(edgeKey(e.from, e.to)) ? { ...e, isMainPath: true } : { ...e };
+    childGraph = {
+      name: label,
+      description: "",
+      nodes: [
+        { id: startId, type: "start", label: "Start" },
+        ...groupedNodes,
+        ...extraChildNodes
+      ],
+      edges: [
+        { from: startId, to: entry, isMainPath: true },
+        ...internal.map(markMain),
+        ...exitChildEdges.map(markMain)
+      ],
+      mainPath: [startId, ...mainBody, ...mainTail]
+    };
+  }
+  const groupNode = {
+    id: groupId,
+    type: "group",
+    groupType,
+    label,
+    childGraph
+  };
+  const newNodes = [];
+  let placed = false;
+  for (const n of workflow.nodes) {
+    if (inSet.has(n.id)) {
+      if (!placed) {
+        newNodes.push(groupNode);
+        placed = true;
+      }
+    } else if (!pulledIds.has(n.id)) {
+      newNodes.push(n);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const newEdges = [];
+  const pushEdge = (e) => {
+    const key = `${e.from} ${e.to} ${e.fromExit ?? ""} ${e.label ?? ""}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    newEdges.push(e);
+  };
+  for (const e of external) pushEdge(e);
+  for (const e of incoming) pushEdge({ ...e, to: groupId });
+  for (const e of parentExitEdges) pushEdge(e);
+  const newMain = [];
+  let mainInserted = false;
+  for (const id of workflow.mainPath) {
+    if (inSet.has(id)) {
+      if (!mainInserted) {
+        newMain.push(groupId);
+        mainInserted = true;
+      }
+    } else {
+      newMain.push(id);
+    }
+  }
+  return { ...workflow, nodes: newNodes, edges: newEdges, mainPath: newMain };
+}
+function emptyWorkflowIR(name = "untitled") {
+  return { name, description: "", nodes: [], edges: [], mainPath: [] };
+}
+function applyWorkflowPatch(workflow, patch) {
+  if (patch.scope && patch.scope.length > 0) {
+    return applyScopedPatch(workflow, patch.scope, patch);
+  }
+  if (patch.op === "batch") {
+    return patch.patches.reduce(
+      (current, operation) => applyWorkflowPatch(current, operation),
+      workflow
+    );
+  }
+  if (patch.op === "replace") {
+    return cloneWorkflow(patch.workflow);
+  }
+  const next = cloneWorkflow(workflow);
+  switch (patch.op) {
+    case "addNode": {
+      ensureNoDuplicateNode(next, patch.node.id);
+      next.nodes = upsertAtIndex(next.nodes, patch.node, patch.index);
+      return next;
+    }
+    case "updateNode": {
+      const index = next.nodes.findIndex((node) => node.id === patch.nodeId);
+      if (index === -1) {
+        throw new WorkflowPatchError(`Node not found: ${patch.nodeId}`);
+      }
+      const existing = next.nodes.at(index);
+      if (!existing) {
+        throw new WorkflowPatchError(`Node not found at index: ${index}`);
+      }
+      next.nodes[index] = {
+        ...existing,
+        ...patch.patch,
+        id: existing.id
+      };
+      return next;
+    }
+    case "removeNode": {
+      ensureNodeExists(next, patch.nodeId);
+      next.nodes = next.nodes.filter((node) => node.id !== patch.nodeId);
+      next.mainPath = next.mainPath.filter((nodeId) => nodeId !== patch.nodeId);
+      const shouldRemoveEdges = patch.removeAttachedEdges ?? true;
+      if (shouldRemoveEdges) {
+        next.edges = next.edges.filter(
+          (edge) => edge.from !== patch.nodeId && edge.to !== patch.nodeId
+        );
+      }
+      return next;
+    }
+    case "addEdge": {
+      ensureNodeExists(next, patch.from);
+      ensureNodeExists(next, patch.to);
+      const edge = {
+        from: patch.from,
+        to: patch.to,
+        ...patch.fromExit !== void 0 ? { fromExit: patch.fromExit } : {},
+        ...patch.label !== void 0 ? { label: patch.label } : {},
+        ...patch.isMainPath !== void 0 ? { isMainPath: patch.isMainPath } : {},
+        ...patch.isExceptional !== void 0 ? { isExceptional: patch.isExceptional } : {},
+        ...patch.isTimeout !== void 0 ? { isTimeout: patch.isTimeout } : {}
+      };
+      if (isDuplicateEdge(next, edge)) {
+        return next;
+      }
+      next.edges = upsertAtIndex(next.edges, edge, patch.index);
+      return next;
+    }
+    case "updateEdge": {
+      const index = next.edges.findIndex((edge) => edgeMatches(edge, patch.from, patch.to));
+      if (index === -1) {
+        throw new WorkflowPatchError(`Edge not found: ${patch.from} -> ${patch.to}`);
+      }
+      const existing = next.edges.at(index);
+      if (!existing) {
+        throw new WorkflowPatchError(`Edge not found at index: ${index}`);
+      }
+      next.edges[index] = {
+        ...existing,
+        ...patch.patch,
+        from: patch.from,
+        to: patch.to
+      };
+      return next;
+    }
+    case "removeEdge": {
+      const initialLength = next.edges.length;
+      next.edges = next.edges.filter((edge) => !edgeMatches(edge, patch.from, patch.to));
+      if (next.edges.length === initialLength) {
+        throw new WorkflowPatchError(`Edge not found: ${patch.from} -> ${patch.to}`);
+      }
+      return next;
+    }
+    case "group": {
+      return wrapIntoGroup(
+        next,
+        patch.nodeIds,
+        patch.groupId,
+        patch.label,
+        patch.groupType ?? "function"
+      );
+    }
+    case "setMainPath": {
+      next.mainPath = sanitizeMainPath(next, patch.mainPath);
+      return next;
+    }
+    case "setUiSpecs": {
+      next.uiSpecs = { ...next.uiSpecs, ...patch.uiSpecs };
+      return next;
+    }
+    case "setMeta": {
+      if (patch.name !== void 0) next.name = patch.name;
+      if (patch.description !== void 0) next.description = patch.description;
+      if (patch.signals !== void 0) next.signals = patch.signals;
+      if (patch.changes !== void 0) next.changes = patch.changes;
+      return next;
+    }
+    default:
+      return next;
+  }
+}
+function applyWorkflowPatches(workflow, patches) {
+  return patches.reduce((current, patch) => applyWorkflowPatch(current, patch), workflow);
+}
+function validateWorkflowPatches(ir, patches) {
+  const errors = [];
+  let clone = cloneWorkflow(ir);
+  patches.forEach((patch, index) => {
+    try {
+      clone = applyWorkflowPatch(clone, patch);
+    } catch (err) {
+      errors.push({
+        index,
+        op: patch.op ?? "?",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+  return errors;
+}
+var WorkflowPatchStream = class {
+  currentWorkflow;
+  undoStack = [];
+  redoStack = [];
+  constructor(initialWorkflow = null) {
+    this.currentWorkflow = cloneMaybeWorkflow(initialWorkflow);
+  }
+  get current() {
+    return cloneMaybeWorkflow(this.currentWorkflow);
+  }
+  get canUndo() {
+    return this.undoStack.length > 0;
+  }
+  get canRedo() {
+    return this.redoStack.length > 0;
+  }
+  reset(workflow = null) {
+    this.currentWorkflow = cloneMaybeWorkflow(workflow);
+    this.undoStack = [];
+    this.redoStack = [];
+    return this.current;
+  }
+  apply(patchOrPatches) {
+    const patches = Array.isArray(patchOrPatches) ? patchOrPatches : [patchOrPatches];
+    if (patches.length === 0) {
+      if (!this.currentWorkflow) {
+        throw new WorkflowPatchError("Cannot apply empty patch list without an initial workflow");
+      }
+      return cloneWorkflow(this.currentWorkflow);
+    }
+    const previous = cloneMaybeWorkflow(this.currentWorkflow);
+    let next = cloneMaybeWorkflow(this.currentWorkflow);
+    for (const patch of patches) {
+      if (!next) {
+        if (patch.op !== "replace") {
+          throw new WorkflowPatchError(
+            "Patch stream is empty. First patch must be a replace operation."
+          );
+        }
+        next = cloneWorkflow(patch.workflow);
+        continue;
+      }
+      next = applyWorkflowPatch(next, patch);
+    }
+    if (!next) {
+      throw new WorkflowPatchError("Patch application produced an empty workflow");
+    }
+    this.undoStack.push(previous);
+    this.redoStack = [];
+    this.currentWorkflow = next;
+    return cloneWorkflow(next);
+  }
+  undo() {
+    if (!this.canUndo) {
+      return this.current;
+    }
+    const previous = this.undoStack.pop() ?? null;
+    this.redoStack.push(cloneMaybeWorkflow(this.currentWorkflow));
+    this.currentWorkflow = cloneMaybeWorkflow(previous);
+    return this.current;
+  }
+  redo() {
+    if (!this.canRedo) {
+      return this.current;
+    }
+    const next = this.redoStack.pop() ?? null;
+    this.undoStack.push(cloneMaybeWorkflow(this.currentWorkflow));
+    this.currentWorkflow = cloneMaybeWorkflow(next);
+    return this.current;
+  }
+};
+
+// packages/workflow-model/src/workflow-ir-validate.ts
+function outgoingEdges(edges, nodeId) {
+  return edges.filter((e) => e.from === nodeId);
+}
+function incomingEdges(edges, nodeId) {
+  return edges.filter((e) => e.to === nodeId);
+}
+function hasFailureEnd(workflow) {
+  return workflow.nodes.some(
+    (n) => n.type === "end" && n.outcome === "failure"
+  );
+}
+function hasExceptionalEdge(edges, nodeId) {
+  return edges.some((e) => e.from === nodeId && e.isExceptional);
+}
+function validateWorkflowIR(workflow, options) {
+  const maxDepth = options?.maxDepth ?? 10;
+  const diagnostics = [];
+  collectDiagnostics(workflow, diagnostics, 0, maxDepth);
+  const byNodeId = /* @__PURE__ */ new Map();
+  for (const d of diagnostics) {
+    const existing = byNodeId.get(d.nodeId);
+    if (existing) {
+      existing.push(d);
+    } else {
+      byNodeId.set(d.nodeId, [d]);
+    }
+  }
+  return { diagnostics, byNodeId };
+}
+function collectDiagnostics(workflow, out, depth, maxDepth) {
+  if (depth > maxDepth) return;
+  const { nodes, edges } = workflow;
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeMap.set(node.id, node);
+  }
+  for (const node of nodes) {
+    const outEdges = outgoingEdges(edges, node.id);
+    const inEdges = incomingEdges(edges, node.id);
+    if (node.type === "wait" && node.timeout) {
+      if (!outEdges.some((e) => e.isTimeout)) {
+        out.push({
+          code: "WAIT_NO_TIMEOUT_EDGE",
+          severity: "warning",
+          nodeId: node.id,
+          message: `Wait node "${node.label}" has timeout (${node.timeout}) but no timeout edge.`
+        });
+      }
+    }
+    if (node.type === "decision" && outEdges.length < 2) {
+      out.push({
+        code: "DECISION_DEAD_END",
+        severity: "warning",
+        nodeId: node.id,
+        message: `Decision node "${node.label}" has ${outEdges.length} outgoing edge(s); expected at least 2.`
+      });
+    }
+    if (node.type === "child_workflow" && node.childGraph) {
+      if (hasFailureEnd(node.childGraph) && !hasExceptionalEdge(edges, node.id)) {
+        out.push({
+          code: "CHILD_FAILURE_UNHANDLED",
+          severity: "warning",
+          nodeId: node.id,
+          message: `Child workflow "${node.label}" can fail but parent has no error edge.`
+        });
+      }
+      collectDiagnostics(node.childGraph, out, depth + 1, maxDepth);
+    }
+    if (node.type === "nexus_operation" && node.backing?.backingGraph) {
+      if (hasFailureEnd(node.backing.backingGraph) && !hasExceptionalEdge(edges, node.id)) {
+        out.push({
+          code: "NEXUS_FAILURE_UNHANDLED",
+          severity: "warning",
+          nodeId: node.id,
+          message: `Nexus operation "${node.label}" backing graph can fail but parent has no error edge.`
+        });
+      }
+      collectDiagnostics(node.backing.backingGraph, out, depth + 1, maxDepth);
+    }
+    if (node.type !== "start" && inEdges.length === 0 && edges.length > 0) {
+      out.push({
+        code: "UNREACHABLE_NODE",
+        severity: "error",
+        nodeId: node.id,
+        message: `Node "${node.label}" has no incoming edges and is unreachable.`
+      });
+    }
+    if (node.type !== "end" && outEdges.length === 0 && edges.length > 0) {
+      out.push({
+        code: "TERMINAL_NON_END",
+        severity: "error",
+        nodeId: node.id,
+        message: `Non-terminal node "${node.label}" has no outgoing edges (dead end).`
+      });
+    }
+  }
+  for (const edge of edges) {
+    if (edge.isTimeout) {
+      const sourceNode = nodeMap.get(edge.from);
+      if (sourceNode && sourceNode.type !== "wait") {
+        out.push({
+          code: "TIMEOUT_ON_NON_WAIT",
+          severity: "warning",
+          nodeId: edge.from,
+          message: `Edge from "${sourceNode.label}" to "${nodeMap.get(edge.to)?.label ?? edge.to}" has isTimeout but source is a ${sourceNode.type} node, not a wait node.`
+        });
+      }
+    }
+  }
+}
+
+// packages/workflow-model/src/apply-preview-patch.ts
+function applyPreviewPatch(ir, patch) {
+  try {
+    return applyWorkflowPatch(ir, patch);
+  } catch {
+    return ir;
+  }
+}
+
+// packages/workflow-model/src/change-counts.ts
+var zero = () => ({ extend: 0, add: 0, remove: 0, rewire: 0, total: 0 });
+function countChanges(changes) {
+  if (!changes) return null;
+  const counts = {
+    asBuilt: zero(),
+    asPractised: zero(),
+    total: changes.length,
+    newSites: 0
+  };
+  const sites = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    const face = change.face === "as-practised" ? counts.asPractised : counts.asBuilt;
+    face[change.kind] += 1;
+    face.total += 1;
+    if (change.kind === "add") sites.add(change.site);
+  }
+  counts.newSites = sites.size;
+  return counts;
+}
+function describeChanges(counts) {
+  if (!counts) return "no change list yet \u2014 nothing has counted what this proposal changes";
+  if (counts.total === 0) return "no changes \u2014 this proposal is the captures, unaltered";
+  const surface = counts.newSites === 0 ? "no new places for work to land" : `${counts.newSites} new place${counts.newSites === 1 ? "" : "s"} for work to land`;
+  const faces = [];
+  if (counts.asBuilt.total > 0) {
+    faces.push(`${counts.asBuilt.total} to what the system does`);
+  }
+  if (counts.asPractised.total > 0) {
+    faces.push(`${counts.asPractised.total} to what people do`);
+  }
+  return `${surface} \xB7 ${faces.join(", ")}`;
+}
+
+// packages/workflow-model/src/process-artifact.ts
+import { z } from "zod";
+var CURRENT_PROCESS_VERSION = 2;
+var SUPPORTED_PROCESS_VERSIONS = [1, 2];
+var UNVERSIONED_REVISION = "unversioned";
+var LEGACY_V1_ACTOR_CATEGORY = {
+  customer: "human",
+  banker: "approval",
+  system: "data"
+};
+var actorSchema = z.object({
+  label: z.string(),
+  category: z.string().min(1).optional(),
+  selector: z.string().min(1).optional(),
+  cardinality: z.enum(["one", "many"]).optional()
+}).strict();
+var selectorSchema = z.object({
+  label: z.string(),
+  description: z.string().optional()
+}).strict();
+var substepBindSchema = z.object({
+  commands: z.array(z.string()).optional(),
+  activities: z.array(z.string()).optional()
+}).strict().superRefine((bind, ctx) => {
+  if (!bind.commands?.length && !bind.activities?.length) {
+    ctx.addIssue({
+      code: "custom",
+      message: "bind must include at least one of commands or activities",
+      params: { code: "EMPTY_SUBSTEP_BIND" }
+    });
+  }
+});
+var substepSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  actor: z.string().optional(),
+  /**
+   * Overrides the actor's own `selector` for this substep only — the case
+   * where one cast entry is resolved differently at one step (a handoff
+   * target, an escalation pool). Must be declared in `process.selectors`.
+   */
+  selector: z.string().min(1).optional(),
+  bind: substepBindSchema
+}).strict();
+var outcomeTriggerSchema = z.union([
+  z.object({ predicate: z.string().min(1) }).strict(),
+  z.object({ timeoutOf: z.string().min(1) }).strict(),
+  z.object({ command: z.string().min(1) }).strict()
+]);
+var outcomeWhenSchema = z.union([
+  outcomeTriggerSchema,
+  z.array(outcomeTriggerSchema).superRefine((triggers, ctx) => {
+    if (triggers.length === 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: "when must declare at least one trigger",
+        params: { code: "EMPTY_OUTCOME_TRIGGER" }
+      });
+    }
+  })
+]);
+var outcomeSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  kind: z.enum(["success", "failure"]),
+  when: outcomeWhenSchema,
+  description: z.string().optional()
+}).strict();
+var stageCompleteSchema = z.object({
+  predicate: z.string()
+}).strict();
+var stageSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+  actor: z.string().optional(),
+  substeps: z.array(substepSchema).optional(),
+  complete: stageCompleteSchema,
+  pointOfNoReturn: z.literal(true).optional()
+}).strict();
+var processBlockSchema = z.object({
+  version: z.number(),
+  /**
+   * Pinned identity of this authored content. Opaque to the platform —
+   * a date, a semver, a content hash, a monotonic counter all work. What
+   * matters is that changing the process changes it, so an execution can
+   * be pinned to the revision it started under. Required from V2; a V1
+   * artifact is upgraded with {@link UNVERSIONED_REVISION} and a warning.
+   */
+  revision: z.string().min(1).optional(),
+  workflowType: z.string(),
+  actors: z.record(z.string(), actorSchema),
+  /** Named selector registry — every `selector` reference resolves here. */
+  selectors: z.record(z.string(), selectorSchema).optional(),
+  stages: z.array(stageSchema),
+  outcomes: z.array(outcomeSchema),
+  internalCommands: z.array(z.string()).optional()
+}).strict().superRefine((process, ctx) => {
+  if (!SUPPORTED_PROCESS_VERSIONS.includes(process.version)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["version"],
+      message: `Unsupported process.version ${JSON.stringify(process.version)}; this parser understands ${SUPPORTED_PROCESS_VERSIONS.join(" and ")}. Upgrade the parser or downgrade the artifact.`,
+      params: { code: "UNSUPPORTED_VERSION" }
+    });
+  }
+  if (process.version >= CURRENT_PROCESS_VERSION && process.revision === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["revision"],
+      message: `process.revision is required from version ${CURRENT_PROCESS_VERSION}. Give this authored content a pinned identity (a date, a semver, or a content hash) so an execution can name the revision it is running.`,
+      params: { code: "MISSING_PROCESS_REVISION" }
+    });
+  }
+  const declaredSelectors = new Set(Object.keys(process.selectors ?? {}));
+  const checkActor = (actorId, path) => {
+    if (actorId === void 0) return;
+    if (!Object.prototype.hasOwnProperty.call(process.actors, actorId)) {
+      ctx.addIssue({
+        code: "custom",
+        path,
+        message: `Actor "${actorId}" is referenced at ${z.core.toDotPath(path)} but not declared in process.actors. Declare the actor (label, and optionally category/selector) or fix the reference.`,
+        params: { code: "UNDECLARED_ACTOR" }
+      });
+    }
+  };
+  const checkSelector = (selector, path) => {
+    if (selector === void 0) return;
+    if (!declaredSelectors.has(selector)) {
+      ctx.addIssue({
+        code: "custom",
+        path,
+        message: `Selector "${selector}" is referenced at ${z.core.toDotPath(path)} but not declared in process.selectors. Declare the selector or fix the reference.`,
+        params: { code: "UNDECLARED_SELECTOR" }
+      });
+    }
+  };
+  for (const [actorId, actor] of Object.entries(process.actors)) {
+    checkSelector(actor.selector, ["actors", actorId, "selector"]);
+  }
+  const SAME_KIND_CODE = {
+    stage: "DUPLICATE_STAGE_ID",
+    substep: "DUPLICATE_SUBSTEP_ID",
+    outcome: "DUPLICATE_OUTCOME_ID"
+  };
+  const idFirstSeenAt = /* @__PURE__ */ new Map();
+  const checkId = (id, kind, path) => {
+    const first = idFirstSeenAt.get(id);
+    if (first) {
+      const kindLabel = kind === first.kind ? kind : "process";
+      ctx.addIssue({
+        code: "custom",
+        path,
+        message: `Duplicate ${kindLabel} id "${id}": ${kind} at ${z.core.toDotPath(path)} collides with ${first.kind} at ${z.core.toDotPath(first.path)}.`,
+        params: {
+          code: kind === first.kind ? SAME_KIND_CODE[kind] : "DUPLICATE_PROCESS_ID"
+        }
+      });
+    } else {
+      idFirstSeenAt.set(id, { kind, path });
+    }
+  };
+  process.stages.forEach((stage, stageIndex) => {
+    checkId(stage.id, "stage", ["stages", stageIndex, "id"]);
+    checkActor(stage.actor, ["stages", stageIndex, "actor"]);
+    stage.substeps?.forEach((substep, substepIndex) => {
+      checkId(substep.id, "substep", ["stages", stageIndex, "substeps", substepIndex, "id"]);
+      checkActor(substep.actor, ["stages", stageIndex, "substeps", substepIndex, "actor"]);
+      checkSelector(substep.selector, [
+        "stages",
+        stageIndex,
+        "substeps",
+        substepIndex,
+        "selector"
+      ]);
+    });
+  });
+  process.outcomes.forEach((outcome, outcomeIndex) => {
+    checkId(outcome.id, "outcome", ["outcomes", outcomeIndex, "id"]);
+  });
+});
+var processArtifactSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  phase: z.enum(["draft", "workflow_review"]).optional(),
+  process: processBlockSchema
+}).passthrough();
+function outcomeTriggers(outcome) {
+  const raw = Array.isArray(outcome.when) ? outcome.when : [outcome.when];
+  return raw.map((trigger) => {
+    if ("predicate" in trigger) return { kind: "predicate", name: trigger.predicate };
+    if ("timeoutOf" in trigger) return { kind: "timeout", name: trigger.timeoutOf };
+    return { kind: "command", name: trigger.command };
+  });
+}
+function resolveSubstepActor(artifact, stage, substep) {
+  const actorId = substep.actor ?? stage.actor;
+  if (!actorId) return void 0;
+  const actor = artifact.process.actors[actorId];
+  if (!actor) return void 0;
+  return {
+    id: actorId,
+    label: actor.label,
+    ...actor.category ? { category: actor.category } : {},
+    ...substep.selector ?? actor.selector ? { selector: substep.selector ?? actor.selector } : {},
+    ...actor.cardinality ? { cardinality: actor.cardinality } : {}
+  };
+}
+function resolveActorRef(artifact, actorId) {
+  const actor = artifact.process.actors[actorId];
+  if (!actor) return void 0;
+  return {
+    id: actorId,
+    label: actor.label,
+    ...actor.category ? { category: actor.category } : {},
+    ...actor.selector ? { selector: actor.selector } : {},
+    ...actor.cardinality ? { cardinality: actor.cardinality } : {}
+  };
+}
+function buildProcessManifest(artifact, outcomeNodeIds) {
+  const { process } = artifact;
+  const actors = {};
+  for (const actorId of Object.keys(process.actors)) {
+    actors[actorId] = resolveActorRef(artifact, actorId);
+  }
+  let selectors;
+  if (process.selectors) {
+    selectors = {};
+    for (const [name, selector] of Object.entries(process.selectors)) {
+      selectors[name] = {
+        name,
+        label: selector.label,
+        ...selector.description ? { description: selector.description } : {}
+      };
+    }
+  }
+  const outcomes = process.outcomes.map((outcome) => {
+    const nodeId = outcomeNodeIds?.get(outcome.id);
+    return {
+      id: outcome.id,
+      label: outcome.label,
+      kind: outcome.kind,
+      triggers: outcomeTriggers(outcome),
+      ...outcome.description ? { description: outcome.description } : {},
+      ...nodeId ? { nodeId } : {}
+    };
+  });
+  const pointOfNoReturnStage = process.stages.find((stage) => stage.pointOfNoReturn);
+  return {
+    source: "process-artifact",
+    artifactVersion: process.version,
+    revision: process.revision,
+    workflowType: process.workflowType,
+    actors,
+    ...selectors ? { selectors } : {},
+    outcomes,
+    ...pointOfNoReturnStage ? { pointOfNoReturnStageId: pointOfNoReturnStage.id } : {}
+  };
+}
+function formatPath(path) {
+  return path.length > 0 ? z.core.toDotPath(path) : "(root)";
+}
+function issueToDiagnostic(issue) {
+  const path = formatPath(issue.path);
+  let code = "SCHEMA_INVALID";
+  if (issue.code === "custom") {
+    const paramCode = issue.params?.code;
+    if (typeof paramCode === "string") {
+      code = paramCode;
+    }
+  }
+  return {
+    severity: "error",
+    code,
+    message: `${path}: ${issue.message}`,
+    path
+  };
+}
+function upgradeV1(artifact) {
+  const diagnostics = [
+    {
+      severity: "warning",
+      code: "DEPRECATED_ARTIFACT_VERSION",
+      message: `process.version: artifact is version 1; upgraded in memory to version ${CURRENT_PROCESS_VERSION}. Migrate the file (add process.revision, declare actor categories/selectors) \u2014 version 1 is a deprecated input, not a second authoring format.`,
+      path: "process.version"
+    },
+    {
+      severity: "warning",
+      code: "MISSING_PROCESS_REVISION",
+      message: `process.revision: version 1 has no revision; recorded as "${UNVERSIONED_REVISION}". Anything pinned to this artifact cannot name which version of the process it ran.`,
+      path: "process.revision"
+    }
+  ];
+  const process = artifact.process;
+  const actors = {};
+  for (const [actorId, actor] of Object.entries(process.actors)) {
+    const legacyCategory = LEGACY_V1_ACTOR_CATEGORY[actorId];
+    actors[actorId] = {
+      ...actor,
+      ...actor.category === void 0 && legacyCategory ? { category: legacyCategory } : {}
+    };
+  }
+  return {
+    artifact: {
+      ...artifact,
+      process: {
+        ...process,
+        version: CURRENT_PROCESS_VERSION,
+        revision: UNVERSIONED_REVISION,
+        actors
+      }
+    },
+    diagnostics
+  };
+}
+function parseProcessArtifact(json) {
+  const result = processArtifactSchema.safeParse(json);
+  if (!result.success) {
+    return { diagnostics: result.error.issues.map(issueToDiagnostic) };
+  }
+  if (result.data.process.version < CURRENT_PROCESS_VERSION) {
+    return upgradeV1(result.data);
+  }
+  return { artifact: result.data, diagnostics: [] };
+}
+
+// packages/workflow-model/src/process-lint.ts
+function stagePath(stageIndex) {
+  return `process.stages[${stageIndex}]`;
+}
+function substepPath(stageIndex, substepIndex) {
+  return `${stagePath(stageIndex)}.substeps[${substepIndex}]`;
+}
+function lintProcess(artifact, inventory, predicateNames, options = {}) {
+  const diagnostics = [];
+  const process = artifact.process;
+  const commandNames = new Set(inventory.commands.map((c) => c.name));
+  const activityNames = new Set(inventory.activities);
+  const predicateSet = new Set(predicateNames);
+  const internalCommands = process.internalCommands ?? [];
+  const internalSet = new Set(internalCommands);
+  const boundCommandPaths = /* @__PURE__ */ new Map();
+  const checkPredicate = (predicate, path) => {
+    if (!predicateSet.has(predicate)) {
+      diagnostics.push({
+        severity: "error",
+        code: "UNKNOWN_PREDICATE",
+        message: `Predicate "${predicate}" referenced at ${path} is not in the predicate registry.`,
+        path
+      });
+    }
+  };
+  if (options.selectorNames) {
+    const selectorSet = new Set(options.selectorNames);
+    for (const [name] of Object.entries(process.selectors ?? {})) {
+      if (!selectorSet.has(name)) {
+        diagnostics.push({
+          severity: "error",
+          code: "UNKNOWN_SELECTOR",
+          message: `Selector "${name}" declared at process.selectors.${name} is not in the selector registry; the application has no rule resolving it to subjects.`,
+          path: `process.selectors.${name}`
+        });
+      }
+    }
+  }
+  process.stages.forEach((stage, stageIndex) => {
+    const predicatePath = `${stagePath(stageIndex)}.complete.predicate`;
+    const predicate = stage.complete?.predicate;
+    if (typeof predicate !== "string" || predicate.length === 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "MISSING_STAGE_PREDICATE",
+        message: `Stage "${stage.id}" (${stagePath(stageIndex)}) has no complete.predicate.`,
+        path: predicatePath
+      });
+    } else {
+      checkPredicate(predicate, predicatePath);
+    }
+    stage.substeps?.forEach((substep, substepIndex) => {
+      const bindPath = substepPath(stageIndex, substepIndex);
+      substep.bind.commands?.forEach((commandName, commandIndex) => {
+        if (!boundCommandPaths.has(commandName)) {
+          boundCommandPaths.set(commandName, `${bindPath}.bind.commands[${commandIndex}]`);
+        }
+        if (!commandNames.has(commandName)) {
+          diagnostics.push({
+            severity: "error",
+            code: "BOUND_COMMAND_NOT_IN_INVENTORY",
+            message: `Command "${commandName}" bound by substep "${substep.id}" (${bindPath}.bind.commands[${commandIndex}]) does not exist in the inventory.`,
+            path: `${bindPath}.bind.commands[${commandIndex}]`
+          });
+        }
+      });
+      substep.bind.activities?.forEach((activityName, activityIndex) => {
+        if (!activityNames.has(activityName)) {
+          diagnostics.push({
+            severity: "error",
+            code: "BOUND_ACTIVITY_NOT_IN_INVENTORY",
+            message: `Activity "${activityName}" bound by substep "${substep.id}" (${bindPath}.bind.activities[${activityIndex}]) does not exist in the inventory.`,
+            path: `${bindPath}.bind.activities[${activityIndex}]`
+          });
+        }
+      });
+    });
+  });
+  process.outcomes.forEach((outcome, outcomeIndex) => {
+    const whenPath = `process.outcomes[${outcomeIndex}].when`;
+    outcomeTriggers(outcome).forEach((trigger, triggerIndex) => {
+      const path = Array.isArray(outcome.when) ? `${whenPath}[${triggerIndex}]` : whenPath;
+      if (trigger.kind === "predicate") {
+        checkPredicate(trigger.name, `${path}.predicate`);
+      } else if (trigger.kind === "command") {
+        if (!boundCommandPaths.has(trigger.name)) {
+          boundCommandPaths.set(trigger.name, `${path}.command`);
+        }
+        if (!commandNames.has(trigger.name)) {
+          diagnostics.push({
+            severity: "error",
+            code: "BOUND_COMMAND_NOT_IN_INVENTORY",
+            message: `Command "${trigger.name}" triggering outcome "${outcome.id}" (${path}.command) does not exist in the inventory.`,
+            path: `${path}.command`
+          });
+        }
+      }
+    });
+  });
+  const hasSuccessOutcome = process.outcomes.some((o) => o.kind === "success");
+  const hasFailureOutcome = process.outcomes.some((o) => o.kind === "failure");
+  if (!hasSuccessOutcome) {
+    diagnostics.push({
+      severity: "error",
+      code: "MISSING_SUCCESS_OUTCOME",
+      message: 'process.outcomes has no outcome with kind "success"; every process needs at least one.',
+      path: "process.outcomes"
+    });
+  }
+  if (!hasFailureOutcome) {
+    diagnostics.push({
+      severity: "error",
+      code: "MISSING_FAILURE_OUTCOME",
+      message: 'process.outcomes has no outcome with kind "failure"; every process needs at least one.',
+      path: "process.outcomes"
+    });
+  }
+  internalCommands.forEach((commandName, index) => {
+    if (!commandNames.has(commandName)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "STALE_INTERNAL_COMMAND",
+        message: `internalCommands entry "${commandName}" (process.internalCommands[${index}]) does not exist in the inventory; this looks like a stale marker.`,
+        path: `process.internalCommands[${index}]`
+      });
+    }
+  });
+  inventory.commands.forEach((command) => {
+    const boundPath = boundCommandPaths.get(command.name);
+    const isBound = boundPath !== void 0;
+    const isInternal = internalSet.has(command.name);
+    if (isBound && isInternal) {
+      diagnostics.push({
+        severity: "warning",
+        code: "CONTRADICTORY_COMMAND_DECLARATION",
+        message: `Inventory command "${command.name}" is both bound (at ${boundPath}) and listed in internalCommands \u2014 contradictory declaration.`,
+        path: boundPath
+      });
+    } else if (!isBound && !isInternal) {
+      diagnostics.push({
+        severity: "error",
+        code: "UNBOUND_INVENTORY_COMMAND",
+        message: `Inventory command "${command.name}" is neither bound by any substep, nor named as an outcome trigger, nor listed in process.internalCommands.`,
+        path: "process.internalCommands"
+      });
+    }
+  });
+  if (process.workflowType !== inventory.workflowType) {
+    diagnostics.push({
+      severity: "error",
+      code: "WORKFLOW_TYPE_MISMATCH",
+      message: `process.workflowType "${process.workflowType}" does not match inventory.workflowType "${inventory.workflowType}"; this artifact is bound to the wrong workflow.`,
+      path: "process.workflowType"
+    });
+  }
+  return diagnostics;
+}
+export {
+  CURRENT_PROCESS_VERSION,
+  SUPPORTED_PROCESS_VERSIONS,
+  UNVERSIONED_REVISION,
+  WorkflowPatchError,
+  WorkflowPatchStream,
+  applyPreviewPatch,
+  applyWorkflowPatch,
+  applyWorkflowPatches,
+  buildProcessManifest,
+  computeHappyPath,
+  countChanges,
+  describeChanges,
+  emptyWorkflowIR,
+  findProcessNodesByCommand,
+  findProcessNodesByElementId,
+  lintProcess,
+  outcomeTriggers,
+  parseProcessArtifact,
+  processArtifactSchema,
+  resolveActorRef,
+  resolveSubstepActor,
+  validateWorkflowIR,
+  validateWorkflowPatches,
+  walkProcessNodes
+};