Refactor workflow auto-run to node graph

background/steps/registry.js

@@ -1,48 +1,49 @@
 (function attachBackgroundStepRegistry(root, factory) {
   root.MultiPageBackgroundStepRegistry = factory();
 })(typeof self !== 'undefined' ? self : globalThis, function createBackgroundStepRegistryModule() {
-  function createStepRegistry(definitions = []) {
+  function createNodeRegistry(definitions = []) {
     const ordered = (Array.isArray(definitions) ? definitions : [])
       .map((definition) => ({
-        id: Number(definition?.id),
-        order: Number(definition?.order),
-        key: String(definition?.key || '').trim(),
+        nodeId: String(definition?.nodeId || definition?.key || '').trim(),
+        displayOrder: Number(definition?.displayOrder ?? definition?.order),
+        executeKey: String(definition?.executeKey || definition?.key || definition?.nodeId || '').trim(),
         title: String(definition?.title || '').trim(),
         execute: definition?.execute,
       }))
-      .filter((definition) => Number.isFinite(definition.id) && typeof definition.execute === 'function')
+      .filter((definition) => definition.nodeId && typeof definition.execute === 'function')
       .sort((left, right) => {
-        const leftOrder = Number.isFinite(left.order) ? left.order : left.id;
-        const rightOrder = Number.isFinite(right.order) ? right.order : right.id;
-        return leftOrder - rightOrder;
+        const leftOrder = Number.isFinite(left.displayOrder) ? left.displayOrder : 0;
+        const rightOrder = Number.isFinite(right.displayOrder) ? right.displayOrder : 0;
+        if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+        return left.nodeId.localeCompare(right.nodeId);
       });
 
-    const byId = new Map(ordered.map((definition) => [definition.id, definition]));
+    const byId = new Map(ordered.map((definition) => [definition.nodeId, definition]));
 
-    function getStepDefinition(step) {
-      return byId.get(Number(step)) || null;
+    function getNodeDefinition(nodeId) {
+      return byId.get(String(nodeId || '').trim()) || null;
     }
 
-    function getOrderedSteps() {
+    function getOrderedNodes() {
       return ordered.slice();
     }
 
-    function executeStep(step, state) {
-      const definition = getStepDefinition(step);
+    function executeNode(nodeId, state) {
+      const definition = getNodeDefinition(nodeId);
       if (!definition) {
-        throw new Error(`未知步骤：${step}`);
+        throw new Error(`未知节点：${nodeId}`);
       }
       return definition.execute(state);
     }
 
     return {
-      executeStep,
-      getOrderedSteps,
-      getStepDefinition,
+      executeNode,
+      getNodeDefinition,
+      getOrderedNodes,
     };
   }
 
   return {
-    createStepRegistry,
+    createNodeRegistry,
   };
 });