nucleus-core-ts 0.10.124 → 0.10.126

package/dist/.build-ok

@@ -1 +1 @@
-0.10.124
+0.10.126

package/dist/fe/components/VerificationFlowPage/components/VerificationFlowPage.js

@@ -6,6 +6,7 @@ import { useEffect, useEffectEvent, useRef, useState } from 'react';
 import { cn } from '../../../utils/cn';
 import { newId } from '../../../utils/newId';
 import { DEFAULT_VERIFICATION_FLOW_LABELS, setActiveLabels } from '../labels';
+import { assignStepOrders } from '../stepOrder';
 import { useVerificationFlowStore } from '../store';
 import { getVerificationFlowTheme } from '../theme';
 import { setActiveTheme } from '../theme/store';
@@ -177,43 +178,26 @@ function buildSavePayload(flowId, entityName, flowName, flowDescription, trigger
             label: String(e.label || ''),
             animated: true
         }));
-    const stepNodeIds = new Set(nodes.filter((n)=>{
+    /*
+   * `step_order` comes from the DRAWING, through one shared pure function.
+   *
+   * This used to be an inline walk whose seed list and neighbour order
+   * followed whatever order the nodes and edges arrived in — heap order, for a
+   * flow loaded from the database. Re-saving a flow without touching it could
+   * therefore renumber its steps and hand the first decision to a different
+   * reviewer. `assignStepOrders` is deterministic and has a test that fails
+   * without it; `getFlow` returns ordered rows so both layers agree.
+   */ const stepNodeIds = new Set(nodes.filter((n)=>{
         const d = n.data;
         return (d.nodeType || n.type) === 'step';
     }).map((n)=>n.id));
-    const adjacency = {};
-    for (const e of flowEdges){
-        if (!adjacency[e.source_node_id]) adjacency[e.source_node_id] = [];
-        adjacency[e.source_node_id]?.push(e.target_node_id);
-    }
-    const findNextSteps = (fromId, visited = new Set())=>{
-        const result = [];
-        for (const t of adjacency[fromId] || []){
-            if (visited.has(t)) continue;
-            visited.add(t);
-            if (stepNodeIds.has(t)) result.push(t);
-            else result.push(...findNextSteps(t, visited));
-        }
-        return result;
-    };
-    const stepGraph = {};
-    const incomingSteps = new Set();
-    for (const sid of stepNodeIds){
-        stepGraph[sid] = findNextSteps(sid);
-        for (const next of stepGraph[sid])incomingSteps.add(next);
-    }
-    const stepOrderMap = {};
-    const queue = [
-        ...stepNodeIds
-    ].filter((id)=>!incomingSteps.has(id));
-    let order = 1;
-    while(queue.length > 0){
-        const current = queue.shift();
-        if (!current) break;
-        if (stepOrderMap[current] !== undefined) continue;
-        stepOrderMap[current] = order++;
-        for (const next of stepGraph[current] || [])queue.push(next);
-    }
+    const stepOrderMap = assignStepOrders({
+        stepNodeIds,
+        edges: flowEdges.map((e)=>({
+                source: e.source_node_id,
+                target: e.target_node_id
+            }))
+    });
     const steps = nodes.map((n)=>{
         const d = n.data;
         const nodeType = String(d.nodeType || n.type);
@@ -819,14 +803,14 @@ export function VerificationFlowPage({ entityName, title, subtitle, flowListActi
                                                         value: "update",
                                                         children: say.triggerOnUpdate
                                                     }),
-                                                    /*#__PURE__*/ _jsx("option", {
-                                                        value: "delete",
-                                                        children: say.triggerOnDelete
-                                                    }),
                                                     /*#__PURE__*/ _jsx("option", {
                                                         value: "manual",
                                                         children: say.triggerOnManual
-                                                    })
+                                                    }),
+                                                    flowTriggerOn === 'delete' ? /*#__PURE__*/ _jsx("option", {
+                                                        value: "delete",
+                                                        children: say.triggerOnDelete
+                                                    }) : null
                                                 ]
                                             })
                                         ]

package/dist/fe/components/VerificationFlowPage/stepOrder.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Which step comes first, second, third — derived from the DRAWING alone.
+ *
+ * The editor does not store a step's position; it re-derives it from the graph
+ * on every save. That derivation used to depend on the order the nodes and
+ * edges happened to arrive in, and for a flow loaded from the database that is
+ * heap order, which changes after updates. So opening a saved flow and pressing
+ * save without touching anything could renumber the steps — a different
+ * reviewer asked first, on a chain whose entire purpose is who is asked when.
+ *
+ * Extracted as a pure function so that property can be tested without a
+ * renderer: the same graph must always produce the same numbering, whatever
+ * order its nodes and edges are handed over in.
+ *
+ * Steps are numbered breadth-first from the steps nothing points at. A
+ * non-step node (a verifier, a notification) is walked THROUGH, so a step
+ * wired to the next one via an intermediate node still counts as adjacent.
+ * Ties — several roots, several next steps — are broken by node id, which is
+ * arbitrary but stable, and that is the whole point.
+ */
+export type StepOrderGraph = {
+    /** Every node, with the ids of the step nodes among them. */
+    stepNodeIds: Iterable<string>;
+    /** Directed edges, source → target. */
+    edges: Array<{
+        source: string;
+        target: string;
+    }>;
+};
+export declare function assignStepOrders(graph: StepOrderGraph): Record<string, number>;

package/dist/fe/components/VerificationFlowPage/stepOrder.js

@@ -0,0 +1,62 @@
+/**
+ * Which step comes first, second, third — derived from the DRAWING alone.
+ *
+ * The editor does not store a step's position; it re-derives it from the graph
+ * on every save. That derivation used to depend on the order the nodes and
+ * edges happened to arrive in, and for a flow loaded from the database that is
+ * heap order, which changes after updates. So opening a saved flow and pressing
+ * save without touching anything could renumber the steps — a different
+ * reviewer asked first, on a chain whose entire purpose is who is asked when.
+ *
+ * Extracted as a pure function so that property can be tested without a
+ * renderer: the same graph must always produce the same numbering, whatever
+ * order its nodes and edges are handed over in.
+ *
+ * Steps are numbered breadth-first from the steps nothing points at. A
+ * non-step node (a verifier, a notification) is walked THROUGH, so a step
+ * wired to the next one via an intermediate node still counts as adjacent.
+ * Ties — several roots, several next steps — are broken by node id, which is
+ * arbitrary but stable, and that is the whole point.
+ */ export function assignStepOrders(graph) {
+    const stepIds = new Set(graph.stepNodeIds);
+    const adjacency = {};
+    for (const e of graph.edges){
+        if (!adjacency[e.source]) adjacency[e.source] = [];
+        adjacency[e.source]?.push(e.target);
+    }
+    const nextSteps = (fromId, visited = new Set())=>{
+        const result = [];
+        for (const t of [
+            ...adjacency[fromId] || []
+        ].sort()){
+            if (visited.has(t)) continue;
+            visited.add(t);
+            if (stepIds.has(t)) result.push(t);
+            else result.push(...nextSteps(t, visited));
+        }
+        return result;
+    };
+    const stepGraph = {};
+    const hasIncoming = new Set();
+    // Sorted so `stepGraph`'s own construction does not depend on set insertion
+    // order either.
+    for (const sid of [
+        ...stepIds
+    ].sort()){
+        stepGraph[sid] = nextSteps(sid);
+        for (const n of stepGraph[sid])hasIncoming.add(n);
+    }
+    const order = {};
+    const queue = [
+        ...stepIds
+    ].filter((id)=>!hasIncoming.has(id)).sort();
+    let next = 1;
+    while(queue.length > 0){
+        const current = queue.shift();
+        if (!current) break;
+        if (order[current] !== undefined) continue;
+        order[current] = next++;
+        for (const n of stepGraph[current] || [])queue.push(n);
+    }
+    return order;
+}