@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7195.1.b5efd1d51a

package/dist/modules/workflows/lib/route-edge.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/route-edge.ts"],
+  "sourcesContent": ["/**\n * Workflows Module - Route edge construction (pure)\n *\n * The ONE place a control-flow route becomes a React Flow edge.\n *\n * A route the author has just drawn and the same route re-read from a saved\n * definition are the same thing and must render identically. They did not:\n * `definitionToGraph` typed every stored transition `workflowTransition` \u2014 the\n * module's own bezier renderer \u2014 while the Studio's `handleConnect` and the\n * insert-on-route splice typed a newly authored NORMAL route `smoothstep`,\n * React Flow's built-in orthogonal renderer. ReactFlow merges\n * `defaultEdgeOptions` UNDER each edge (`{ ...defaultEdgeOptions, ...edge }`),\n * so the canvas default could not correct an explicit type, and a freshly drawn\n * route rendered as a right-angled staircase that only became a curve after a\n * save and a reload. The duplicated construction WAS the defect, so both paths\n * build their edge here.\n *\n * Render-time only: nothing here reaches `graphToDefinition`, which reads\n * endpoints, handles and `data` \u2014 an edge's `type` is how a route is drawn, not\n * what is stored.\n *\n * PURE \u2014 plain graph data in, plain graph data out. The `Edge` import is\n * type-only, so the visual-editor page keeps its lazy `@xyflow/react` boundary\n * (#3169).\n */\n\nimport type { Edge } from '@xyflow/react'\n\n/**\n * React Flow edge type registered for `WorkflowTransitionEdge` in\n * `WorkflowGraphImpl`'s `edgeTypes` (and its `defaultEdgeOptions`). Every\n * control-flow route \u2014 kinded or not, drawn or loaded \u2014 renders through it.\n */\nexport const WORKFLOW_TRANSITION_EDGE_TYPE = 'workflowTransition'\n\nexport interface WorkflowRouteEdgeInput {\n  id: string\n  source: string\n  target: string\n  /** Omitted entirely when absent, so a route without one keeps today's shape. */\n  sourceHandle?: string | null\n  targetHandle?: string | null\n  data?: Record<string, unknown>\n}\n\n/** Build the React Flow edge for one control-flow route. */\nexport function buildWorkflowRouteEdge(input: WorkflowRouteEdgeInput): Edge {\n  return {\n    id: input.id,\n    source: input.source,\n    target: input.target,\n    type: WORKFLOW_TRANSITION_EDGE_TYPE,\n    ...(input.sourceHandle ? { sourceHandle: input.sourceHandle } : {}),\n    ...(input.targetHandle ? { targetHandle: input.targetHandle } : {}),\n    data: input.data ?? {},\n  }\n}\n"],
+  "mappings": "AAiCO,MAAM,gCAAgC;AAatC,SAAS,uBAAuB,OAAqC;AAC1E,SAAO;AAAA,IACL,IAAI,MAAM;AAAA,IACV,QAAQ,MAAM;AAAA,IACd,QAAQ,MAAM;AAAA,IACd,MAAM;AAAA,IACN,GAAI,MAAM,eAAe,EAAE,cAAc,MAAM,aAAa,IAAI,CAAC;AAAA,IACjE,GAAI,MAAM,eAAe,EAAE,cAAc,MAAM,aAAa,IAAI,CAAC;AAAA,IACjE,MAAM,MAAM,QAAQ,CAAC;AAAA,EACvB;AACF;",
+  "names": []
+}

package/dist/modules/workflows/lib/route-kinds.js

@@ -0,0 +1,67 @@
+import { ERROR_SOURCE_HANDLE_ID, ERROR_TRANSITION_KIND } from "./error-routing.js";
+import { SLA_BREACH_SOURCE_HANDLE_ID, SLA_BREACH_TRANSITION_KIND } from "./breach-routing.js";
+import {
+  OUTCOME_TRANSITION_KIND,
+  isAgentOutcomeKind,
+  outcomeSourceHandleId,
+  parseOutcomeSourceHandleId
+} from "./outcome-routing.js";
+const NORMAL_TRANSITION_KIND = "normal";
+const DEFAULT_SOURCE_HANDLE_ID = "source";
+function fixedHandleDescriptor(kind, sourceHandleId) {
+  return {
+    kind,
+    matchesSourceHandle: (candidate) => candidate === sourceHandleId,
+    resolveSourceHandle: () => sourceHandleId,
+    discriminatorFields: () => ({})
+  };
+}
+const outcomeDescriptor = {
+  kind: OUTCOME_TRANSITION_KIND,
+  matchesSourceHandle: (candidate) => parseOutcomeSourceHandleId(candidate) !== null,
+  resolveSourceHandle: (transition) => outcomeSourceHandleId(
+    isAgentOutcomeKind(transition.outcomeKind) ? transition.outcomeKind : "approved"
+  ),
+  discriminatorFields: (edge) => {
+    const carried = edge.data?.outcomeKind;
+    const fromHandle = parseOutcomeSourceHandleId(edge.sourceHandle);
+    const outcome = isAgentOutcomeKind(carried) ? carried : fromHandle;
+    return { outcomeKind: outcome ?? "approved" };
+  }
+};
+const ROUTE_KIND_DESCRIPTORS = [
+  fixedHandleDescriptor(ERROR_TRANSITION_KIND, ERROR_SOURCE_HANDLE_ID),
+  fixedHandleDescriptor(SLA_BREACH_TRANSITION_KIND, SLA_BREACH_SOURCE_HANDLE_ID),
+  outcomeDescriptor
+];
+function listRouteKindDescriptors() {
+  return [...ROUTE_KIND_DESCRIPTORS];
+}
+function findRouteKindDescriptor(kind) {
+  if (typeof kind !== "string" || kind.length === 0) return null;
+  return ROUTE_KIND_DESCRIPTORS.find((descriptor) => descriptor.kind === kind) ?? null;
+}
+function findRouteKindDescriptorForHandle(sourceHandleId) {
+  if (typeof sourceHandleId !== "string" || sourceHandleId.length === 0) return null;
+  return ROUTE_KIND_DESCRIPTORS.find((descriptor) => descriptor.matchesSourceHandle(sourceHandleId)) ?? null;
+}
+function resolveEdgeRouteKind(edgeKind, sourceHandleId) {
+  return findRouteKindDescriptor(edgeKind) ?? findRouteKindDescriptorForHandle(sourceHandleId);
+}
+function isNonNormalRouteKind(kind) {
+  return findRouteKindDescriptor(kind) !== null;
+}
+function excludeNonNormalTransitions(transitions) {
+  return transitions.filter((transition) => !isNonNormalRouteKind(transition?.kind));
+}
+export {
+  DEFAULT_SOURCE_HANDLE_ID,
+  NORMAL_TRANSITION_KIND,
+  excludeNonNormalTransitions,
+  findRouteKindDescriptor,
+  findRouteKindDescriptorForHandle,
+  isNonNormalRouteKind,
+  listRouteKindDescriptors,
+  resolveEdgeRouteKind
+};
+//# sourceMappingURL=route-kinds.js.map

package/dist/modules/workflows/lib/route-kinds.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/route-kinds.ts"],
+  "sourcesContent": ["/**\n * Workflows Module - Route kind round-trip (pure)\n *\n * A transition's `kind` is what keeps a route off the happy path: `error` is\n * reachable only from a failure, `slaBreach` only from a deadline passing. Each\n * kind is drawn from its own canvas source handle, so persisting a route means\n * answering two questions in both directions:\n *\n *   canvas edge  \u2192 which `kind` does this connection compile to?\n *   stored route \u2192 which source handle does it re-attach to?\n *\n * Both answers used to be inlined per kind, which is why `slaBreach` \u2014 added\n * after `error` \u2014 was silently downgraded to a normal transition the moment a\n * definition carrying one was opened in the Studio and saved: `graphToDefinition`\n * only ever special-cased `'error'`. Registering a kind here is now the single\n * step that makes it survive the round trip, so the next kind cannot repeat it.\n *\n * PURE: no ORM, DI, React or registry imports, so `graph-utils` can consume it\n * without pulling the editor's render chain (enforced by the xyflow\n * import-boundary test).\n */\n\nimport { ERROR_SOURCE_HANDLE_ID, ERROR_TRANSITION_KIND } from './error-routing'\nimport { SLA_BREACH_SOURCE_HANDLE_ID, SLA_BREACH_TRANSITION_KIND } from './breach-routing'\nimport {\n  OUTCOME_TRANSITION_KIND,\n  isAgentOutcomeKind,\n  outcomeSourceHandleId,\n  parseOutcomeSourceHandleId,\n} from './outcome-routing'\n\n/**\n * The absent form. A transition with no `kind` and a transition with\n * `kind: 'normal'` mean the same thing to every routing lookup, so the canvas\n * serializes both as absent \u2014 which is what keeps a definition declaring no\n * kinds byte-identical through a save.\n */\nexport const NORMAL_TRANSITION_KIND = 'normal'\n\n/**\n * The canvas source handle a normal route leaves from \u2014 every node's ordinary\n * output, and the one handle no `RouteKindDescriptor` claims.\n *\n * FROZEN: stored transitions re-attach to it by id (`definitionToGraph` emits\n * no `sourceHandle` for a normal route, which React Flow resolves to the node's\n * only unnamed source), and moving where it RENDERS must never change what it\n * is called. It moved into the outcome-row footer so every outgoing connection\n * leaves from a row; the id did not move with it.\n */\nexport const DEFAULT_SOURCE_HANDLE_ID = 'source'\n\nexport interface RouteKindTransitionLike {\n  kind?: string\n  outcomeKind?: string\n}\n\nexport interface RouteKindDescriptor {\n  /** Value persisted as `transition.kind`. */\n  kind: string\n  /** True when a connection drawn from this handle compiles to this kind. */\n  matchesSourceHandle(sourceHandleId: string): boolean\n  /** Canvas source handle a stored transition of this kind re-attaches to. */\n  resolveSourceHandle(transition: RouteKindTransitionLike): string\n  /**\n   * Fields beyond `kind` this route persists, derived from what the canvas\n   * carries. A kind whose handles fan out (outcome routes) stores WHICH handle\n   * it was drawn from; a fixed-handle kind stores nothing extra.\n   */\n  discriminatorFields(edge: RouteKindEdgeLike): Record<string, unknown>\n}\n\nexport interface RouteKindEdgeLike {\n  data?: RouteKindTransitionLike | null\n  sourceHandle?: string | null\n}\n\nfunction fixedHandleDescriptor(kind: string, sourceHandleId: string): RouteKindDescriptor {\n  return {\n    kind,\n    matchesSourceHandle: (candidate) => candidate === sourceHandleId,\n    resolveSourceHandle: () => sourceHandleId,\n    discriminatorFields: () => ({}),\n  }\n}\n\n/**\n * Outcome routes are the one kind that fans out: an agent node exposes a handle\n * per \u00A77.2 disposition kind, so the handle carries the outcome and the stored\n * route carries it back as `outcomeKind`. `approved` is the fallback because it\n * is the outcome \u00A77.2 renders unconditionally.\n */\nconst outcomeDescriptor: RouteKindDescriptor = {\n  kind: OUTCOME_TRANSITION_KIND,\n  matchesSourceHandle: (candidate) => parseOutcomeSourceHandleId(candidate) !== null,\n  resolveSourceHandle: (transition) =>\n    outcomeSourceHandleId(\n      isAgentOutcomeKind(transition.outcomeKind) ? transition.outcomeKind : 'approved',\n    ),\n  discriminatorFields: (edge) => {\n    const carried = edge.data?.outcomeKind\n    const fromHandle = parseOutcomeSourceHandleId(edge.sourceHandle)\n    const outcome = isAgentOutcomeKind(carried) ? carried : fromHandle\n    return { outcomeKind: outcome ?? 'approved' }\n  },\n}\n\n/**\n * Every non-normal kind the canvas can author. Order is only the lookup order:\n * handle ids are disjoint, so at most one descriptor ever matches.\n */\nconst ROUTE_KIND_DESCRIPTORS: RouteKindDescriptor[] = [\n  fixedHandleDescriptor(ERROR_TRANSITION_KIND, ERROR_SOURCE_HANDLE_ID),\n  fixedHandleDescriptor(SLA_BREACH_TRANSITION_KIND, SLA_BREACH_SOURCE_HANDLE_ID),\n  outcomeDescriptor,\n]\n\nexport function listRouteKindDescriptors(): RouteKindDescriptor[] {\n  return [...ROUTE_KIND_DESCRIPTORS]\n}\n\n/** Descriptor for a stored `transition.kind`, or null for normal / unknown kinds. */\nexport function findRouteKindDescriptor(kind: unknown): RouteKindDescriptor | null {\n  if (typeof kind !== 'string' || kind.length === 0) return null\n  return ROUTE_KIND_DESCRIPTORS.find((descriptor) => descriptor.kind === kind) ?? null\n}\n\n/** Descriptor for a canvas source handle, or null when the handle is the default one. */\nexport function findRouteKindDescriptorForHandle(sourceHandleId: unknown): RouteKindDescriptor | null {\n  if (typeof sourceHandleId !== 'string' || sourceHandleId.length === 0) return null\n  return ROUTE_KIND_DESCRIPTORS.find((descriptor) => descriptor.matchesSourceHandle(sourceHandleId)) ?? null\n}\n\n/**\n * The kind a canvas edge compiles to, from its carried `data.kind` and the\n * handle it leaves from. Returns null for a normal route, which is what makes\n * \"no kind config \u21D2 identical serialization\" the default rather than a case.\n *\n * The carried kind wins over the handle so a route authored before its handle\n * existed still serializes as its kind.\n */\nexport function resolveEdgeRouteKind(\n  edgeKind: unknown,\n  sourceHandleId: unknown,\n): RouteKindDescriptor | null {\n  return findRouteKindDescriptor(edgeKind) ?? findRouteKindDescriptorForHandle(sourceHandleId)\n}\n\n/** True for any route the engine reaches only through its own dedicated path. */\nexport function isNonNormalRouteKind(kind: unknown): boolean {\n  return findRouteKindDescriptor(kind) !== null\n}\n\n/**\n * Strip every kinded route from a normal-routing lookup.\n *\n * Each kind is reachable ONLY from its own trigger \u2014 a failure, a passed\n * deadline, a resolved disposition \u2014 so a routing lookup that forgot one would\n * auto-select it as a happy path. That is the bug shape `route-priority.ts`\n * already had for `slaBreach`, so the filter lives here once and every lookup\n * calls it instead of composing per-kind excludes and eventually missing one.\n */\nexport function excludeNonNormalTransitions<T extends { kind?: string }>(\n  transitions: T[],\n): T[] {\n  return transitions.filter((transition) => !isNonNormalRouteKind(transition?.kind))\n}\n"],
+  "mappings": "AAsBA,SAAS,wBAAwB,6BAA6B;AAC9D,SAAS,6BAA6B,kCAAkC;AACxE;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAQA,MAAM,yBAAyB;AAY/B,MAAM,2BAA2B;AA2BxC,SAAS,sBAAsB,MAAc,gBAA6C;AACxF,SAAO;AAAA,IACL;AAAA,IACA,qBAAqB,CAAC,cAAc,cAAc;AAAA,IAClD,qBAAqB,MAAM;AAAA,IAC3B,qBAAqB,OAAO,CAAC;AAAA,EAC/B;AACF;AAQA,MAAM,oBAAyC;AAAA,EAC7C,MAAM;AAAA,EACN,qBAAqB,CAAC,cAAc,2BAA2B,SAAS,MAAM;AAAA,EAC9E,qBAAqB,CAAC,eACpB;AAAA,IACE,mBAAmB,WAAW,WAAW,IAAI,WAAW,cAAc;AAAA,EACxE;AAAA,EACF,qBAAqB,CAAC,SAAS;AAC7B,UAAM,UAAU,KAAK,MAAM;AAC3B,UAAM,aAAa,2BAA2B,KAAK,YAAY;AAC/D,UAAM,UAAU,mBAAmB,OAAO,IAAI,UAAU;AACxD,WAAO,EAAE,aAAa,WAAW,WAAW;AAAA,EAC9C;AACF;AAMA,MAAM,yBAAgD;AAAA,EACpD,sBAAsB,uBAAuB,sBAAsB;AAAA,EACnE,sBAAsB,4BAA4B,2BAA2B;AAAA,EAC7E;AACF;AAEO,SAAS,2BAAkD;AAChE,SAAO,CAAC,GAAG,sBAAsB;AACnC;AAGO,SAAS,wBAAwB,MAA2C;AACjF,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAAG,QAAO;AAC1D,SAAO,uBAAuB,KAAK,CAAC,eAAe,WAAW,SAAS,IAAI,KAAK;AAClF;AAGO,SAAS,iCAAiC,gBAAqD;AACpG,MAAI,OAAO,mBAAmB,YAAY,eAAe,WAAW,EAAG,QAAO;AAC9E,SAAO,uBAAuB,KAAK,CAAC,eAAe,WAAW,oBAAoB,cAAc,CAAC,KAAK;AACxG;AAUO,SAAS,qBACd,UACA,gBAC4B;AAC5B,SAAO,wBAAwB,QAAQ,KAAK,iCAAiC,cAAc;AAC7F;AAGO,SAAS,qBAAqB,MAAwB;AAC3D,SAAO,wBAAwB,IAAI,MAAM;AAC3C;AAWO,SAAS,4BACd,aACK;AACL,SAAO,YAAY,OAAO,CAAC,eAAe,CAAC,qBAAqB,YAAY,IAAI,CAAC;AACnF;",
+  "names": []
+}

package/dist/modules/workflows/lib/route-priority.js

@@ -0,0 +1,104 @@
+import { isNonNormalRouteKind } from "./route-kinds.js";
+import { routeCarriesCondition } from "./route-chips.js";
+const ROUTE_PRIORITY_TOP = 100;
+const ROUTE_PRIORITY_STEP = 10;
+const ROUTE_PRIORITY_OTHERWISE = 0;
+function edgeData(edge) {
+  return edge.data ?? {};
+}
+function readPriority(edge) {
+  const raw = edgeData(edge).priority;
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : 0;
+}
+function outgoingNormalRoutes(edges, nodeId) {
+  return edges.filter(
+    (edge) => edge.source === nodeId && edge.type !== "workflowDataMapping" && !isNonNormalRouteKind(edgeData(edge).kind)
+  );
+}
+function orderRoutesByPriority(routes) {
+  return routes.map((edge, index) => ({ edge, index, priority: readPriority(edge) })).sort((a, b) => b.priority - a.priority || a.index - b.index).map((entry) => entry.edge);
+}
+function derivePriorities(entries) {
+  const count = entries.length;
+  if (count === 0) return [];
+  const lastIndex = count - 1;
+  const hasConditionedRoute = entries.some((entry) => entry.hasCondition);
+  const trailingOtherwise = count > 1 && hasConditionedRoute && !entries[lastIndex].hasCondition;
+  const caseCount = trailingOtherwise ? lastIndex : count;
+  const top = Math.max(ROUTE_PRIORITY_TOP, caseCount * ROUTE_PRIORITY_STEP);
+  return entries.map((_entry, index) => {
+    if (trailingOtherwise && index === lastIndex) return ROUTE_PRIORITY_OTHERWISE;
+    return top - index * ROUTE_PRIORITY_STEP;
+  });
+}
+function readRouteOrder(edges, nodeId) {
+  const ordered = orderRoutesByPriority(outgoingNormalRoutes(edges, nodeId));
+  const hasConditionedRoute = ordered.some((edge) => routeCarriesCondition(edgeData(edge)));
+  const lastIndex = ordered.length - 1;
+  return ordered.map((edge, index) => {
+    const data = edgeData(edge);
+    const hasCondition = routeCarriesCondition(data);
+    return {
+      transitionId: edge.id,
+      toStepId: edge.target,
+      label: data.transitionName || data.label || void 0,
+      priority: readPriority(edge),
+      hasCondition,
+      isOtherwise: !hasCondition && hasConditionedRoute && index === lastIndex && ordered.length > 1
+    };
+  });
+}
+function moveRoute(entries, fromIndex, toIndex) {
+  if (fromIndex === toIndex) return entries;
+  if (fromIndex < 0 || fromIndex >= entries.length) return entries;
+  const clampedTo = Math.min(Math.max(toIndex, 0), entries.length - 1);
+  const next = [...entries];
+  const [moved] = next.splice(fromIndex, 1);
+  next.splice(clampedTo, 0, moved);
+  return next;
+}
+function applyDerivedPriorities(entries) {
+  const priorities = derivePriorities(entries);
+  return entries.map((entry, index) => ({
+    ...entry,
+    priority: priorities[index],
+    isOtherwise: priorities[index] === ROUTE_PRIORITY_OTHERWISE && !entry.hasCondition && entries.length > 1
+  }));
+}
+function applyRouteOrder(edges, nodeId, entries) {
+  const priorityByTransitionId = new Map(entries.map((entry) => [entry.transitionId, entry.priority]));
+  return edges.map((edge) => {
+    if (edge.source !== nodeId) return edge;
+    if (!priorityByTransitionId.has(edge.id)) return edge;
+    return { ...edge, data: { ...edge.data ?? {}, priority: priorityByTransitionId.get(edge.id) } };
+  });
+}
+function needsPriorityNormalization(edges, nodeId) {
+  const entries = readRouteOrder(edges, nodeId);
+  if (entries.length < 2) return false;
+  const derived = derivePriorities(entries);
+  return entries.some((entry, index) => entry.priority !== derived[index]);
+}
+function canNormalizeRoutePriorities(source) {
+  return source !== "code";
+}
+function normalizeRoutePriorities(edges, nodeId) {
+  if (!needsPriorityNormalization(edges, nodeId)) return edges;
+  return applyRouteOrder(edges, nodeId, applyDerivedPriorities(readRouteOrder(edges, nodeId)));
+}
+export {
+  ROUTE_PRIORITY_OTHERWISE,
+  ROUTE_PRIORITY_STEP,
+  ROUTE_PRIORITY_TOP,
+  applyDerivedPriorities,
+  applyRouteOrder,
+  canNormalizeRoutePriorities,
+  derivePriorities,
+  moveRoute,
+  needsPriorityNormalization,
+  normalizeRoutePriorities,
+  orderRoutesByPriority,
+  outgoingNormalRoutes,
+  readRouteOrder
+};
+//# sourceMappingURL=route-priority.js.map

package/dist/modules/workflows/lib/route-priority.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/route-priority.ts"],
+  "sourcesContent": ["/**\n * Workflows Module - Route Priority (pure)\n *\n * Spec 2026-07-26-workflows-ux-redesign.md section 4.4: \"Priority becomes\n * drag-to-reorder of a node's outgoing routes; the number is derived and\n * demoted to advanced. First edit of a node's routes runs a priority\n * normalization pass (existing definitions mix dialog-default 100 with\n * schema-default 0).\"\n *\n * The engine is untouched: `findValidTransitions` still evaluates outgoing\n * transitions highest-priority-first with ties keeping definition order. This\n * module only decides which NUMBERS express a given author-visible ORDER, and\n * the normalization pass rewrites messy legacy numbers into clean ones WITHOUT\n * changing that evaluation order.\n *\n * Error routes (`kind: 'error'`) are never part of normal-route ordering \u2014 they\n * are only reachable from a failure, so their priority means something else\n * entirely (`findErrorTransition`). They pass through untouched.\n *\n * PURE: no React, no ORM, no DI. The only xyflow dependency is the `Edge` type.\n */\n\nimport type { Edge } from '@xyflow/react'\nimport { isNonNormalRouteKind } from './route-kinds'\nimport { routeCarriesCondition } from './route-chips'\n\n/** Priority of the highest route when a node has at most 10 normal routes. */\nexport const ROUTE_PRIORITY_TOP = 100\n\n/** Gap between consecutive routes, matching the Switch compiler (step 2.2). */\nexport const ROUTE_PRIORITY_STEP = 10\n\n/** The trailing unconditioned route always evaluates last. */\nexport const ROUTE_PRIORITY_OTHERWISE = 0\n\nexport interface RouteOrderEntry {\n  transitionId: string\n  toStepId: string\n  label?: string\n  priority: number\n  hasCondition: boolean\n  isOtherwise: boolean\n}\n\ninterface EdgeDataLike {\n  priority?: number\n  condition?: unknown\n  preConditions?: unknown\n  transitionName?: string\n  label?: string\n  kind?: string\n}\n\nfunction edgeData(edge: Edge): EdgeDataLike {\n  return (edge.data ?? {}) as EdgeDataLike\n}\n\nfunction readPriority(edge: Edge): number {\n  const raw = edgeData(edge).priority\n  return typeof raw === 'number' && Number.isFinite(raw) ? raw : 0\n}\n\n/**\n * A node's outgoing NORMAL routes \u2014 every kinded route (error, SLA-breach,\n * agent outcome) and data-mapping edge excluded. Filtering only error routes\n * here used to let a breach or outcome route into the priority ladder, where it\n * would read as a happy path the author never wired.\n */\nexport function outgoingNormalRoutes(edges: Edge[], nodeId: string): Edge[] {\n  return edges.filter(\n    (edge) =>\n      edge.source === nodeId &&\n      edge.type !== 'workflowDataMapping' &&\n      !isNonNormalRouteKind(edgeData(edge).kind),\n  )\n}\n\n/**\n * The order the engine evaluates a node's routes in today: priority descending,\n * ties keeping definition order. Implemented as an index-decorated comparison so\n * it stays stable on every runtime, with an explicit comparator (#3620).\n */\nexport function orderRoutesByPriority(routes: Edge[]): Edge[] {\n  return routes\n    .map((edge, index) => ({ edge, index, priority: readPriority(edge) }))\n    .sort((a, b) => (b.priority - a.priority) || (a.index - b.index))\n    .map((entry) => entry.edge)\n}\n\n/**\n * Derived priorities for an ordered route list. The last route is the\n * \"otherwise\" \u2014 and gets priority 0 \u2014 only when it carries no condition while an\n * earlier one does; otherwise every route keeps a positive, evenly spaced slot.\n * The top value grows with the route count so a node with more than ten routes\n * still gets unique, non-negative numbers.\n */\nexport function derivePriorities(entries: Array<{ hasCondition: boolean }>): number[] {\n  const count = entries.length\n  if (count === 0) return []\n\n  const lastIndex = count - 1\n  const hasConditionedRoute = entries.some((entry) => entry.hasCondition)\n  const trailingOtherwise = count > 1 && hasConditionedRoute && !entries[lastIndex].hasCondition\n  const caseCount = trailingOtherwise ? lastIndex : count\n  const top = Math.max(ROUTE_PRIORITY_TOP, caseCount * ROUTE_PRIORITY_STEP)\n\n  return entries.map((_entry, index) => {\n    if (trailingOtherwise && index === lastIndex) return ROUTE_PRIORITY_OTHERWISE\n    return top - index * ROUTE_PRIORITY_STEP\n  })\n}\n\n/** The inspector's view of a node's outgoing routes, in evaluation order. */\nexport function readRouteOrder(edges: Edge[], nodeId: string): RouteOrderEntry[] {\n  const ordered = orderRoutesByPriority(outgoingNormalRoutes(edges, nodeId))\n  const hasConditionedRoute = ordered.some((edge) => routeCarriesCondition(edgeData(edge)))\n  const lastIndex = ordered.length - 1\n\n  return ordered.map((edge, index) => {\n    const data = edgeData(edge)\n    const hasCondition = routeCarriesCondition(data)\n    return {\n      transitionId: edge.id,\n      toStepId: edge.target,\n      label: data.transitionName || data.label || undefined,\n      priority: readPriority(edge),\n      hasCondition,\n      isOtherwise: !hasCondition && hasConditionedRoute && index === lastIndex && ordered.length > 1,\n    }\n  })\n}\n\n/** Move one route within the list, returning a new array (drag-to-reorder). */\nexport function moveRoute(entries: RouteOrderEntry[], fromIndex: number, toIndex: number): RouteOrderEntry[] {\n  if (fromIndex === toIndex) return entries\n  if (fromIndex < 0 || fromIndex >= entries.length) return entries\n  const clampedTo = Math.min(Math.max(toIndex, 0), entries.length - 1)\n  const next = [...entries]\n  const [moved] = next.splice(fromIndex, 1)\n  next.splice(clampedTo, 0, moved)\n  return next\n}\n\n/** Re-derive priorities so the entries read top-to-bottom in evaluation order. */\nexport function applyDerivedPriorities(entries: RouteOrderEntry[]): RouteOrderEntry[] {\n  const priorities = derivePriorities(entries)\n  return entries.map((entry, index) => ({\n    ...entry,\n    priority: priorities[index],\n    isOtherwise: priorities[index] === ROUTE_PRIORITY_OTHERWISE && !entry.hasCondition && entries.length > 1,\n  }))\n}\n\n/** Write an inspector route list back onto the node's outgoing edges. */\nexport function applyRouteOrder(edges: Edge[], nodeId: string, entries: RouteOrderEntry[]): Edge[] {\n  const priorityByTransitionId = new Map(entries.map((entry) => [entry.transitionId, entry.priority]))\n  return edges.map((edge) => {\n    if (edge.source !== nodeId) return edge\n    if (!priorityByTransitionId.has(edge.id)) return edge\n    return { ...edge, data: { ...(edge.data ?? {}), priority: priorityByTransitionId.get(edge.id) } }\n  })\n}\n\n/**\n * True when a node's outgoing routes still carry legacy numbering \u2014 duplicated\n * priorities (the dialog default of 100 on every route) or values off the\n * derived scale. A single route never needs normalizing.\n */\nexport function needsPriorityNormalization(edges: Edge[], nodeId: string): boolean {\n  const entries = readRouteOrder(edges, nodeId)\n  if (entries.length < 2) return false\n  const derived = derivePriorities(entries)\n  return entries.some((entry, index) => entry.priority !== derived[index])\n}\n\n/**\n * Whether the normalization pass may run for a definition of this `source`.\n *\n * A `code` definition is authored in TypeScript and is read-only in the editor \u2014\n * rewriting its priorities would silently diverge the canvas from the code. It\n * becomes normalizable only after Customize, which mints an editable override\n * (`code_override`), which is exactly the spec's \"for `source: 'code'`\n * definitions this happens only on Customize\".\n */\nexport function canNormalizeRoutePriorities(source: string | null | undefined): boolean {\n  return source !== 'code'\n}\n\n/**\n * The normalization pass: rewrite a node's outgoing normal-route priorities to\n * clean descending values while PRESERVING the order the engine evaluates them\n * in today. Idempotent, and a no-op for a node whose routes are already clean.\n */\nexport function normalizeRoutePriorities(edges: Edge[], nodeId: string): Edge[] {\n  if (!needsPriorityNormalization(edges, nodeId)) return edges\n  return applyRouteOrder(edges, nodeId, applyDerivedPriorities(readRouteOrder(edges, nodeId)))\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/workflows/lib/run-duration.js

@@ -0,0 +1,44 @@
+const SECOND_MS = 1e3;
+const MINUTE_MS = 60 * SECOND_MS;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+function toMillis(value) {
+  if (!value) return null;
+  const parsed = value instanceof Date ? value.getTime() : new Date(value).getTime();
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function formatDurationMs(durationMs) {
+  const value = Math.max(durationMs, 0);
+  if (value < SECOND_MS) return `${Math.round(value)}ms`;
+  if (value < MINUTE_MS) return `${(value / SECOND_MS).toFixed(value < 10 * SECOND_MS ? 1 : 0)}s`;
+  if (value < HOUR_MS) {
+    return `${Math.floor(value / MINUTE_MS)}m ${Math.floor(value % MINUTE_MS / SECOND_MS)}s`;
+  }
+  if (value < DAY_MS) {
+    return `${Math.floor(value / HOUR_MS)}h ${Math.floor(value % HOUR_MS / MINUTE_MS)}m`;
+  }
+  return `${Math.floor(value / DAY_MS)}d ${Math.floor(value % DAY_MS / HOUR_MS)}h`;
+}
+function formatRunDuration(startedAt, endedAt, measuredMs) {
+  if (typeof measuredMs === "number" && Number.isFinite(measuredMs)) {
+    return formatDurationMs(measuredMs);
+  }
+  const start = toMillis(startedAt);
+  if (start === null) return null;
+  const end = toMillis(endedAt);
+  if (end === null) return null;
+  return formatDurationMs(end - start);
+}
+function formatElapsedSince(startedAt, endedAt, now = Date.now()) {
+  const start = toMillis(startedAt);
+  if (start === null) return null;
+  const end = toMillis(endedAt) ?? now;
+  return formatDurationMs(end - start);
+}
+export {
+  formatDurationMs,
+  formatElapsedSince,
+  formatRunDuration,
+  toMillis
+};
+//# sourceMappingURL=run-duration.js.map

package/dist/modules/workflows/lib/run-duration.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/run-duration.ts"],
+  "sourcesContent": ["/**\n * Run duration formatting (spec \u00A78.3) \u2014 PURE.\n *\n * One implementation so the overview card, the per-step inspector, the Gantt\n * axis and the run list cannot each round a duration differently.\n */\n\nconst SECOND_MS = 1000\nconst MINUTE_MS = 60 * SECOND_MS\nconst HOUR_MS = 60 * MINUTE_MS\nconst DAY_MS = 24 * HOUR_MS\n\nexport function toMillis(value: string | Date | null | undefined): number | null {\n  if (!value) return null\n  const parsed = value instanceof Date ? value.getTime() : new Date(value).getTime()\n  return Number.isNaN(parsed) ? null : parsed\n}\n\n/**\n * Human-readable elapsed time. Sub-second durations keep their milliseconds\n * because an automated step that takes 8ms and one that takes 800ms are not\n * the same thing to whoever is debugging the run.\n */\nexport function formatDurationMs(durationMs: number): string {\n  const value = Math.max(durationMs, 0)\n  if (value < SECOND_MS) return `${Math.round(value)}ms`\n  if (value < MINUTE_MS) return `${(value / SECOND_MS).toFixed(value < 10 * SECOND_MS ? 1 : 0)}s`\n  if (value < HOUR_MS) {\n    return `${Math.floor(value / MINUTE_MS)}m ${Math.floor((value % MINUTE_MS) / SECOND_MS)}s`\n  }\n  if (value < DAY_MS) {\n    return `${Math.floor(value / HOUR_MS)}h ${Math.floor((value % HOUR_MS) / MINUTE_MS)}m`\n  }\n  return `${Math.floor(value / DAY_MS)}d ${Math.floor((value % DAY_MS) / HOUR_MS)}h`\n}\n\n/**\n * Duration between two timestamps, preferring an engine-measured value when\n * one was recorded. Returns `null` when nothing can be derived, so callers\n * render a dash rather than a misleading `0ms`.\n */\nexport function formatRunDuration(\n  startedAt: string | Date | null | undefined,\n  endedAt: string | Date | null | undefined,\n  measuredMs?: number | null\n): string | null {\n  if (typeof measuredMs === 'number' && Number.isFinite(measuredMs)) {\n    return formatDurationMs(measuredMs)\n  }\n  const start = toMillis(startedAt)\n  if (start === null) return null\n  const end = toMillis(endedAt)\n  if (end === null) return null\n  return formatDurationMs(end - start)\n}\n\n/**\n * Elapsed time for a run that has not finished \u2014 measured against `now` rather\n * than left blank, so a stuck instance reads as stuck.\n */\nexport function formatElapsedSince(\n  startedAt: string | Date | null | undefined,\n  endedAt: string | Date | null | undefined,\n  now: number = Date.now()\n): string | null {\n  const start = toMillis(startedAt)\n  if (start === null) return null\n  const end = toMillis(endedAt) ?? now\n  return formatDurationMs(end - start)\n}\n"],
+  "mappings": "AAOA,MAAM,YAAY;AAClB,MAAM,YAAY,KAAK;AACvB,MAAM,UAAU,KAAK;AACrB,MAAM,SAAS,KAAK;AAEb,SAAS,SAAS,OAAwD;AAC/E,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,SAAS,iBAAiB,OAAO,MAAM,QAAQ,IAAI,IAAI,KAAK,KAAK,EAAE,QAAQ;AACjF,SAAO,OAAO,MAAM,MAAM,IAAI,OAAO;AACvC;AAOO,SAAS,iBAAiB,YAA4B;AAC3D,QAAM,QAAQ,KAAK,IAAI,YAAY,CAAC;AACpC,MAAI,QAAQ,UAAW,QAAO,GAAG,KAAK,MAAM,KAAK,CAAC;AAClD,MAAI,QAAQ,UAAW,QAAO,IAAI,QAAQ,WAAW,QAAQ,QAAQ,KAAK,YAAY,IAAI,CAAC,CAAC;AAC5F,MAAI,QAAQ,SAAS;AACnB,WAAO,GAAG,KAAK,MAAM,QAAQ,SAAS,CAAC,KAAK,KAAK,MAAO,QAAQ,YAAa,SAAS,CAAC;AAAA,EACzF;AACA,MAAI,QAAQ,QAAQ;AAClB,WAAO,GAAG,KAAK,MAAM,QAAQ,OAAO,CAAC,KAAK,KAAK,MAAO,QAAQ,UAAW,SAAS,CAAC;AAAA,EACrF;AACA,SAAO,GAAG,KAAK,MAAM,QAAQ,MAAM,CAAC,KAAK,KAAK,MAAO,QAAQ,SAAU,OAAO,CAAC;AACjF;AAOO,SAAS,kBACd,WACA,SACA,YACe;AACf,MAAI,OAAO,eAAe,YAAY,OAAO,SAAS,UAAU,GAAG;AACjE,WAAO,iBAAiB,UAAU;AAAA,EACpC;AACA,QAAM,QAAQ,SAAS,SAAS;AAChC,MAAI,UAAU,KAAM,QAAO;AAC3B,QAAM,MAAM,SAAS,OAAO;AAC5B,MAAI,QAAQ,KAAM,QAAO;AACzB,SAAO,iBAAiB,MAAM,KAAK;AACrC;AAMO,SAAS,mBACd,WACA,SACA,MAAc,KAAK,IAAI,GACR;AACf,QAAM,QAAQ,SAAS,SAAS;AAChC,MAAI,UAAU,KAAM,QAAO;AAC3B,QAAM,MAAM,SAAS,OAAO,KAAK;AACjC,SAAO,iBAAiB,MAAM,KAAK;AACrC;",
+  "names": []
+}

package/dist/modules/workflows/lib/run-event-tone.js

@@ -0,0 +1,25 @@
+const TONE_RULES = [
+  { tone: "error", matches: (type) => type.includes("FAILED") || type.includes("Failed") },
+  { tone: "error", matches: (type) => type.includes("REJECTED") || type.includes("TIMEOUT") },
+  { tone: "warning", matches: (type) => type.startsWith("COMPENSAT") || type.includes("Compensation") },
+  { tone: "warning", matches: (type) => type.startsWith("ERROR_") || type === "OUTCOME_UNHANDLED" },
+  { tone: "warning", matches: (type) => type.includes("ESCALATED") || type.includes("PAUSED") },
+  { tone: "neutral", matches: (type) => type.includes("CANCELLED") || type.includes("SKIPPED") },
+  { tone: "success", matches: (type) => type.includes("COMPLETED") || type.includes("EXITED") || type.includes("Exited") },
+  { tone: "info", matches: (type) => type.includes("STARTED") || type.includes("ENTERED") || type.includes("Entered") },
+  { tone: "info", matches: (type) => type.includes("EXECUTED") || type.includes("ROUTED") || type.includes("RECEIVED") }
+];
+function classifyRunEventType(eventType) {
+  for (const rule of TONE_RULES) {
+    if (rule.matches(eventType)) return rule.tone;
+  }
+  return "neutral";
+}
+function isRunMilestoneEvent(eventType) {
+  return eventType.startsWith("STEP_") || eventType.startsWith("WORKFLOW_") || eventType.startsWith("TRANSITION_") || eventType.startsWith("ERROR_") || eventType.startsWith("OUTCOME_");
+}
+export {
+  classifyRunEventType,
+  isRunMilestoneEvent
+};
+//# sourceMappingURL=run-event-tone.js.map

package/dist/modules/workflows/lib/run-event-tone.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/run-event-tone.ts"],
+  "sourcesContent": ["/**\n * Workflow-event tone classification (spec \u00A78.3) \u2014 PURE.\n *\n * The instance viewer used to classify event types inline with hardcoded\n * Tailwind shades (`bg-orange-100`, `bg-blue-100`, \u2026), which is both a DS\n * violation and untestable. The mapping is data, so it lives here and every\n * surface that renders an event badge reads the same answer.\n */\n\nexport type RunEventTone = 'success' | 'error' | 'warning' | 'info' | 'neutral'\n\n/**\n * Matched most-specific first. A `COMPENSATION_ACTIVITY_FAILED` is a failure\n * before it is a compensation event \u2014 the previous inline chain answered\n * \"compensation\" for it, which painted a real failure the same warning colour\n * as a routine rollback step.\n */\nconst TONE_RULES: ReadonlyArray<{ tone: RunEventTone; matches: (eventType: string) => boolean }> = [\n  { tone: 'error', matches: (type) => type.includes('FAILED') || type.includes('Failed') },\n  { tone: 'error', matches: (type) => type.includes('REJECTED') || type.includes('TIMEOUT') },\n  { tone: 'warning', matches: (type) => type.startsWith('COMPENSAT') || type.includes('Compensation') },\n  { tone: 'warning', matches: (type) => type.startsWith('ERROR_') || type === 'OUTCOME_UNHANDLED' },\n  { tone: 'warning', matches: (type) => type.includes('ESCALATED') || type.includes('PAUSED') },\n  { tone: 'neutral', matches: (type) => type.includes('CANCELLED') || type.includes('SKIPPED') },\n  { tone: 'success', matches: (type) => type.includes('COMPLETED') || type.includes('EXITED') || type.includes('Exited') },\n  { tone: 'info', matches: (type) => type.includes('STARTED') || type.includes('ENTERED') || type.includes('Entered') },\n  { tone: 'info', matches: (type) => type.includes('EXECUTED') || type.includes('ROUTED') || type.includes('RECEIVED') },\n]\n\nexport function classifyRunEventType(eventType: string): RunEventTone {\n  for (const rule of TONE_RULES) {\n    if (rule.matches(eventType)) return rule.tone\n  }\n  return 'neutral'\n}\n\n/** Events that describe the run's shape rather than its bookkeeping. */\nexport function isRunMilestoneEvent(eventType: string): boolean {\n  return (\n    eventType.startsWith('STEP_')\n    || eventType.startsWith('WORKFLOW_')\n    || eventType.startsWith('TRANSITION_')\n    || eventType.startsWith('ERROR_')\n    || eventType.startsWith('OUTCOME_')\n  )\n}\n"],
+  "mappings": "AAiBA,MAAM,aAA6F;AAAA,EACjG,EAAE,MAAM,SAAS,SAAS,CAAC,SAAS,KAAK,SAAS,QAAQ,KAAK,KAAK,SAAS,QAAQ,EAAE;AAAA,EACvF,EAAE,MAAM,SAAS,SAAS,CAAC,SAAS,KAAK,SAAS,UAAU,KAAK,KAAK,SAAS,SAAS,EAAE;AAAA,EAC1F,EAAE,MAAM,WAAW,SAAS,CAAC,SAAS,KAAK,WAAW,WAAW,KAAK,KAAK,SAAS,cAAc,EAAE;AAAA,EACpG,EAAE,MAAM,WAAW,SAAS,CAAC,SAAS,KAAK,WAAW,QAAQ,KAAK,SAAS,oBAAoB;AAAA,EAChG,EAAE,MAAM,WAAW,SAAS,CAAC,SAAS,KAAK,SAAS,WAAW,KAAK,KAAK,SAAS,QAAQ,EAAE;AAAA,EAC5F,EAAE,MAAM,WAAW,SAAS,CAAC,SAAS,KAAK,SAAS,WAAW,KAAK,KAAK,SAAS,SAAS,EAAE;AAAA,EAC7F,EAAE,MAAM,WAAW,SAAS,CAAC,SAAS,KAAK,SAAS,WAAW,KAAK,KAAK,SAAS,QAAQ,KAAK,KAAK,SAAS,QAAQ,EAAE;AAAA,EACvH,EAAE,MAAM,QAAQ,SAAS,CAAC,SAAS,KAAK,SAAS,SAAS,KAAK,KAAK,SAAS,SAAS,KAAK,KAAK,SAAS,SAAS,EAAE;AAAA,EACpH,EAAE,MAAM,QAAQ,SAAS,CAAC,SAAS,KAAK,SAAS,UAAU,KAAK,KAAK,SAAS,QAAQ,KAAK,KAAK,SAAS,UAAU,EAAE;AACvH;AAEO,SAAS,qBAAqB,WAAiC;AACpE,aAAW,QAAQ,YAAY;AAC7B,QAAI,KAAK,QAAQ,SAAS,EAAG,QAAO,KAAK;AAAA,EAC3C;AACA,SAAO;AACT;AAGO,SAAS,oBAAoB,WAA4B;AAC9D,SACE,UAAU,WAAW,OAAO,KACzB,UAAU,WAAW,WAAW,KAChC,UAAU,WAAW,aAAa,KAClC,UAAU,WAAW,QAAQ,KAC7B,UAAU,WAAW,UAAU;AAEtC;",
+  "names": []
+}

package/dist/modules/workflows/lib/run-execution.js

@@ -0,0 +1,305 @@
+const STEP_ENTERED_EVENT_TYPES = /* @__PURE__ */ new Set(["STEP_ENTERED", "StepEntered"]);
+const STEP_COMPLETED_EVENT_TYPES = /* @__PURE__ */ new Set(["STEP_COMPLETED", "STEP_EXITED", "StepExited"]);
+const STEP_FAILED_EVENT_TYPES = /* @__PURE__ */ new Set(["STEP_FAILED", "StepFailed"]);
+const STEP_SKIPPED_EVENT_TYPES = /* @__PURE__ */ new Set(["STEP_SKIPPED", "StepSkipped"]);
+const TRANSITION_EXECUTED_EVENT_TYPES = /* @__PURE__ */ new Set(["TRANSITION_EXECUTED", "TransitionExecuted"]);
+const WAIT_RESOLVED_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "ACTIVITY_COMPLETED",
+  "ACTIVITY_FAILED",
+  "SIGNAL_RECEIVED",
+  "TIMER_FIRED",
+  "CONDITION_MET",
+  "CONDITION_TIMED_OUT",
+  "USER_TASK_COMPLETED",
+  "PARALLEL_JOIN_COMPLETED"
+]);
+const BRANCH_SETTLED_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "PARALLEL_BRANCH_COMPLETED",
+  "PARALLEL_BRANCH_FAILED",
+  "PARALLEL_BRANCH_CANCELLED"
+]);
+function toDate(value) {
+  if (!value) return null;
+  const parsed = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function readStringField(data, key) {
+  const value = data?.[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function stepPairKey(fromStepId, toStepId) {
+  return `${fromStepId}->${toStepId}`;
+}
+function stepInstanceStatusToRunStatus(status) {
+  switch (status) {
+    case "COMPLETED":
+      return "completed";
+    case "FAILED":
+      return "failed";
+    case "SKIPPED":
+      return "skipped";
+    case "ACTIVE":
+      return "active";
+    case "CANCELLED":
+      return "skipped";
+    default:
+      return "pending";
+  }
+}
+function isNewerExecution(candidate, existing) {
+  const candidateAt = candidate.completedAt ?? candidate.startedAt;
+  const existingAt = existing.completedAt ?? existing.startedAt;
+  if (!existingAt) return true;
+  if (!candidateAt) return false;
+  return candidateAt.getTime() >= existingAt.getTime();
+}
+function stateFromStepInstance(stepInstance) {
+  const startedAt = toDate(stepInstance.enteredAt);
+  const completedAt = toDate(stepInstance.exitedAt);
+  const measured = typeof stepInstance.executionTimeMs === "number" && Number.isFinite(stepInstance.executionTimeMs) ? stepInstance.executionTimeMs : null;
+  const derived = startedAt && completedAt ? completedAt.getTime() - startedAt.getTime() : null;
+  const retries = typeof stepInstance.retryCount === "number" && Number.isFinite(stepInstance.retryCount) ? Math.max(stepInstance.retryCount, 0) : 0;
+  return {
+    stepId: stepInstance.stepId,
+    status: stepInstanceStatusToRunStatus(stepInstance.status),
+    startedAt,
+    completedAt,
+    durationMs: measured ?? derived,
+    attempts: retries + 1
+  };
+}
+function mergeState(target, candidate) {
+  const existing = target.get(candidate.stepId);
+  if (!existing || isNewerExecution(candidate, existing)) {
+    target.set(candidate.stepId, candidate);
+  }
+}
+function applyEvent(target, event) {
+  const stepId = readStringField(event.eventData, "stepId");
+  if (!stepId) return;
+  const occurredAt = toDate(event.occurredAt);
+  const existing = target.get(stepId);
+  const base = existing ?? {
+    stepId,
+    status: "pending",
+    startedAt: null,
+    completedAt: null,
+    durationMs: null,
+    attempts: 1
+  };
+  if (STEP_ENTERED_EVENT_TYPES.has(event.eventType)) {
+    target.set(stepId, {
+      ...base,
+      startedAt: occurredAt,
+      completedAt: null,
+      durationMs: null,
+      status: "active"
+    });
+    return;
+  }
+  const terminalStatus = STEP_COMPLETED_EVENT_TYPES.has(event.eventType) ? "completed" : STEP_FAILED_EVENT_TYPES.has(event.eventType) ? "failed" : STEP_SKIPPED_EVENT_TYPES.has(event.eventType) ? "skipped" : null;
+  if (!terminalStatus) return;
+  const startedAt = base.startedAt;
+  target.set(stepId, {
+    ...base,
+    status: terminalStatus,
+    completedAt: occurredAt,
+    durationMs: startedAt && occurredAt ? occurredAt.getTime() - startedAt.getTime() : base.durationMs
+  });
+}
+function applyLiveInstanceStatus(stepStates, currentStepId, instanceStatus) {
+  if (!currentStepId) return;
+  const existing = stepStates.get(currentStepId);
+  if (existing && (existing.status === "completed" || existing.status === "failed" || existing.status === "skipped")) {
+    return;
+  }
+  const liveStatus = instanceStatus === "FAILED" ? "failed" : instanceStatus === "PAUSED" || instanceStatus === "WAITING_FOR_ACTIVITIES" ? "paused" : "active";
+  stepStates.set(currentStepId, {
+    stepId: currentStepId,
+    status: liveStatus,
+    startedAt: existing?.startedAt ?? null,
+    completedAt: null,
+    durationMs: existing?.durationMs ?? null,
+    attempts: existing?.attempts ?? 1
+  });
+}
+function readBooleanish(data, key) {
+  const value = data?.[key];
+  if (Array.isArray(value)) return value.length > 0;
+  return typeof value === "string" ? value.length > 0 : Boolean(value);
+}
+function readRoleQueue(data) {
+  const value = data?.assignedToRoles;
+  if (Array.isArray(value)) {
+    const named = value.filter((entry) => typeof entry === "string" && entry.length > 0);
+    return named.length > 0 ? named.join(", ") : null;
+  }
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function waitEvidenceFromEvent(event) {
+  const data = event.eventData ?? null;
+  switch (event.eventType) {
+    case "ACTIVITY_QUEUED":
+      return {
+        kind: "asyncActivity",
+        activityName: readStringField(data, "activityName") ?? readStringField(data, "activityType")
+      };
+    case "SIGNAL_AWAITING": {
+      const reason = readStringField(data, "reason");
+      const childInstanceId = readStringField(data, "childInstanceId");
+      if (reason === "SUB_WORKFLOW" || childInstanceId) {
+        return { kind: "subWorkflow", childInstanceId };
+      }
+      const proposalId = readStringField(data, "proposalId");
+      if (reason === "INVOKE_AGENT") {
+        return proposalId ? { kind: "agentDisposition", proposalId } : { kind: "agentRunning", agentId: readStringField(data, "agentId") };
+      }
+      return { kind: "signal", signalName: readStringField(data, "signalName") };
+    }
+    case "TIMER_AWAITING":
+      return { kind: "timer", fireAt: toDate(readStringField(data, "fireAt")) };
+    case "CONDITION_AWAITING":
+      return { kind: "condition", deadlineAt: toDate(readStringField(data, "deadlineAt")) };
+    case "USER_TASK_CREATED": {
+      const proposalId = readStringField(data, "proposalId");
+      if (proposalId) return { kind: "agentDisposition", proposalId };
+      return {
+        kind: "userTask",
+        roleQueue: readRoleQueue(data),
+        hasAssignee: readBooleanish(data, "assignedTo")
+      };
+    }
+    default:
+      return null;
+  }
+}
+function deriveRunExecution(input) {
+  const stepStates = /* @__PURE__ */ new Map();
+  const routes = [];
+  const takenTransitionIds = /* @__PURE__ */ new Set();
+  const takenStepPairs = /* @__PURE__ */ new Set();
+  const waits = /* @__PURE__ */ new Map();
+  const stepIdByStepInstanceId = /* @__PURE__ */ new Map();
+  let forkTally = null;
+  const erroredRoutedSteps = /* @__PURE__ */ new Set();
+  for (const stepInstance of input.stepInstances ?? []) {
+    if (stepInstance.id) stepIdByStepInstanceId.set(stepInstance.id, stepInstance.stepId);
+  }
+  const orderedEvents = [...input.events ?? []].sort((left, right) => {
+    const leftAt = toDate(left.occurredAt)?.getTime() ?? 0;
+    const rightAt = toDate(right.occurredAt)?.getTime() ?? 0;
+    return leftAt - rightAt;
+  });
+  for (const event of orderedEvents) {
+    applyEvent(stepStates, event);
+    const eventStepId = readStringField(event.eventData, "stepId") ?? (event.stepInstanceId ? stepIdByStepInstanceId.get(event.stepInstanceId) ?? null : null);
+    if (eventStepId) {
+      if (STEP_ENTERED_EVENT_TYPES.has(event.eventType) || WAIT_RESOLVED_EVENT_TYPES.has(event.eventType)) {
+        waits.delete(eventStepId);
+      }
+      const evidence = waitEvidenceFromEvent(event);
+      if (evidence) waits.set(eventStepId, evidence);
+    }
+    if (eventStepId && STEP_ENTERED_EVENT_TYPES.has(event.eventType)) {
+      erroredRoutedSteps.delete(eventStepId);
+    } else if (event.eventType === "OUTCOME_ROUTED") {
+      const outcome = readStringField(event.eventData, "outcome");
+      const routedStepId = readStringField(event.eventData, "stepId");
+      if (routedStepId && (outcome === "error" || outcome === "guardrailBlocked")) {
+        erroredRoutedSteps.add(routedStepId);
+      }
+    } else if (event.eventType === "ERROR_ROUTED") {
+      const failedStepId = readStringField(event.eventData, "failedStepId");
+      if (failedStepId) erroredRoutedSteps.add(failedStepId);
+    }
+    if (event.eventType === "PARALLEL_FORK_OPENED") {
+      const forkStepId = readStringField(event.eventData, "forkStepId");
+      const branchKeys = event.eventData?.branchKeys;
+      if (forkStepId && Array.isArray(branchKeys)) {
+        forkTally = {
+          stepId: forkStepId,
+          branchKeys: new Set(branchKeys.filter((key) => typeof key === "string")),
+          settled: /* @__PURE__ */ new Set()
+        };
+      }
+    } else if (BRANCH_SETTLED_EVENT_TYPES.has(event.eventType) && forkTally) {
+      const branchKey = readStringField(event.eventData, "branchKey");
+      if (branchKey && forkTally.branchKeys.has(branchKey)) forkTally.settled.add(branchKey);
+    } else if (event.eventType === "PARALLEL_JOIN_COMPLETED" && forkTally) {
+      waits.delete(forkTally.stepId);
+      forkTally = null;
+    }
+    if (!TRANSITION_EXECUTED_EVENT_TYPES.has(event.eventType)) continue;
+    const fromStepId = readStringField(event.eventData, "fromStepId");
+    const toStepId = readStringField(event.eventData, "toStepId");
+    if (!fromStepId || !toStepId) continue;
+    const transitionId = readStringField(event.eventData, "transitionId");
+    routes.push({
+      transitionId,
+      fromStepId,
+      toStepId,
+      at: toDate(event.occurredAt) ?? /* @__PURE__ */ new Date(0)
+    });
+    if (transitionId) takenTransitionIds.add(transitionId);
+    takenStepPairs.add(stepPairKey(fromStepId, toStepId));
+  }
+  for (const stepInstance of input.stepInstances ?? []) {
+    mergeState(stepStates, stateFromStepInstance(stepInstance));
+  }
+  for (const stepId of erroredRoutedSteps) {
+    const existing = stepStates.get(stepId);
+    if (existing && existing.status === "completed") {
+      stepStates.set(stepId, { ...existing, status: "failed" });
+    }
+  }
+  applyLiveInstanceStatus(stepStates, input.currentStepId, input.instanceStatus);
+  if (forkTally && forkTally.branchKeys.size > forkTally.settled.size) {
+    waits.set(forkTally.stepId, {
+      kind: "fork",
+      branchTotal: forkTally.branchKeys.size,
+      branchesSettled: forkTally.settled.size
+    });
+  }
+  return {
+    stepStates,
+    routes,
+    takenTransitionIds,
+    takenStepPairs,
+    currentStepId: input.currentStepId ?? null,
+    instanceStatus: input.instanceStatus ?? null,
+    waits,
+    attention: readAttention(input.attention)
+  };
+}
+function readAttention(value) {
+  if (!value || typeof value !== "object") return null;
+  const reason = value.reason;
+  return { reason: typeof reason === "string" && reason.length > 0 ? reason : null };
+}
+function resolveNodeRunStatus(execution, node, options = {}) {
+  const recorded = execution.stepStates.get(node.id);
+  if (recorded) return recorded.status;
+  const currentStepId = options.currentStepId ?? execution.currentStepId;
+  const instanceStatus = options.instanceStatus ?? execution.instanceStatus;
+  const isCurrentStep = currentStepId === node.id;
+  if (node.type === "start") {
+    return isCurrentStep ? "active" : "completed";
+  }
+  if (node.type === "end") {
+    return isCurrentStep || instanceStatus === "COMPLETED" ? "completed" : "pending";
+  }
+  return "pending";
+}
+function isRouteTaken(execution, route) {
+  if (route.transitionId && execution.takenTransitionIds.has(route.transitionId)) return true;
+  if (!route.fromStepId || !route.toStepId) return false;
+  return execution.takenStepPairs.has(stepPairKey(route.fromStepId, route.toStepId));
+}
+export {
+  deriveRunExecution,
+  isRouteTaken,
+  resolveNodeRunStatus,
+  stepInstanceStatusToRunStatus,
+  stepPairKey
+};
+//# sourceMappingURL=run-execution.js.map