@stigmer/react 1.0.4 → 2.0.1

package/workflow/graph-commands.js

@@ -417,6 +417,983 @@ function deleteNestedValue(obj, path) {
     return { ...obj, [head]: deleteNestedValue(child, restKeys.join(".")) };
 }
 // ---------------------------------------------------------------------------
+// T08: Branch-specific insertion commands
+// ---------------------------------------------------------------------------
+export class AddSwitchCaseCommand {
+    type = "add_switch_case";
+    description;
+    switchNodeId;
+    caseName;
+    condition;
+    childNode;
+    childEdge;
+    constructor(switchNodeId, caseName, condition, childNode = null, childEdge = null) {
+        this.switchNodeId = switchNodeId;
+        this.caseName = caseName;
+        this.condition = condition;
+        this.childNode = childNode;
+        this.childEdge = childEdge;
+        this.description = `Add case "${caseName}"`;
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.switchNodeId)
+                return node;
+            const prevCases = node.config.cases;
+            const nextCases = Array.isArray(prevCases) ? [...prevCases] : [];
+            nextCases.push({
+                name: this.caseName,
+                ...(this.condition.trim() && { when: this.condition.trim() }),
+            });
+            return { ...node, config: { ...node.config, cases: nextCases } };
+        });
+        const withChildNode = this.childNode ? [...nodes, this.childNode] : nodes;
+        const edges = this.childEdge ? [...model.edges, this.childEdge] : [...model.edges];
+        return { ...model, nodes: withChildNode, edges };
+    }
+    undo(model) {
+        const nodes = model.nodes
+            .filter((node) => !this.childNode || node.id !== this.childNode.id)
+            .map((node) => {
+            if (node.id !== this.switchNodeId)
+                return node;
+            const prevCases = node.config.cases;
+            const nextCases = Array.isArray(prevCases)
+                ? prevCases.filter((entry) => {
+                    if (typeof entry !== "object" || entry === null)
+                        return true;
+                    return entry.name !== this.caseName;
+                })
+                : [];
+            return { ...node, config: { ...node.config, cases: nextCases } };
+        });
+        const edges = this.childEdge
+            ? model.edges.filter((edge) => edge.id !== this.childEdge.id)
+            : [...model.edges];
+        return { ...model, nodes, edges };
+    }
+}
+export class AddParallelBranchCommand {
+    type = "add_parallel_branch";
+    description;
+    forkNodeId;
+    branchName;
+    childNode;
+    childEdge;
+    constructor(forkNodeId, branchName, childNode = null, childEdge = null) {
+        this.forkNodeId = forkNodeId;
+        this.branchName = branchName;
+        this.childNode = childNode;
+        this.childEdge = childEdge;
+        this.description = `Add branch "${branchName}"`;
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            const prevBranches = node.config.branches;
+            const nextBranches = Array.isArray(prevBranches) ? [...prevBranches] : [];
+            nextBranches.push({ name: this.branchName, do: [] });
+            return { ...node, config: { ...node.config, branches: nextBranches } };
+        });
+        const withChildNode = this.childNode ? [...nodes, this.childNode] : nodes;
+        const edges = this.childEdge ? [...model.edges, this.childEdge] : [...model.edges];
+        return { ...model, nodes: withChildNode, edges };
+    }
+    undo(model) {
+        const nodes = model.nodes
+            .filter((node) => !this.childNode || node.id !== this.childNode.id)
+            .map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            const prevBranches = node.config.branches;
+            const nextBranches = Array.isArray(prevBranches)
+                ? prevBranches.filter((entry) => {
+                    if (typeof entry !== "object" || entry === null)
+                        return true;
+                    return entry.name !== this.branchName;
+                })
+                : [];
+            return { ...node, config: { ...node.config, branches: nextBranches } };
+        });
+        const edges = this.childEdge
+            ? model.edges.filter((edge) => edge.id !== this.childEdge.id)
+            : [...model.edges];
+        return { ...model, nodes, edges };
+    }
+}
+export class AddCatchHandlerCommand {
+    type = "add_catch_handler";
+    description;
+    tryCatchNodeId;
+    errorType;
+    childNode;
+    childEdge;
+    previousCatch = undefined;
+    constructor(tryCatchNodeId, errorType, childNode = null, childEdge = null) {
+        this.tryCatchNodeId = tryCatchNodeId;
+        this.errorType = errorType;
+        this.childNode = childNode;
+        this.childEdge = childEdge;
+        this.description = "Add catch handler";
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.tryCatchNodeId)
+                return node;
+            this.previousCatch = node.config.catch;
+            const nextCatch = {
+                as: this.errorType.trim() || "error",
+                do: [],
+            };
+            return { ...node, config: { ...node.config, catch: nextCatch } };
+        });
+        const withChildNode = this.childNode ? [...nodes, this.childNode] : nodes;
+        const edges = this.childEdge ? [...model.edges, this.childEdge] : [...model.edges];
+        return { ...model, nodes: withChildNode, edges };
+    }
+    undo(model) {
+        const nodes = model.nodes
+            .filter((node) => !this.childNode || node.id !== this.childNode.id)
+            .map((node) => {
+            if (node.id !== this.tryCatchNodeId)
+                return node;
+            if (this.previousCatch === undefined) {
+                const { catch: _removed, ...rest } = node.config;
+                return { ...node, config: rest };
+            }
+            return { ...node, config: { ...node.config, catch: this.previousCatch } };
+        });
+        const edges = this.childEdge
+            ? model.edges.filter((edge) => edge.id !== this.childEdge.id)
+            : [...model.edges];
+        return { ...model, nodes, edges };
+    }
+}
+// ---------------------------------------------------------------------------
+// T09: Switch Case management commands
+// ---------------------------------------------------------------------------
+/**
+ * Removes a case from a switch_case node's `config.cases` array
+ * and deletes any associated canvas edge (identified by sourceHandle).
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class RemoveSwitchCaseCommand {
+    type = "remove_switch_case";
+    description;
+    switchNodeId;
+    caseName;
+    removedCase = undefined;
+    removedCaseIndex = -1;
+    removedEdges = [];
+    constructor(switchNodeId, caseName) {
+        this.switchNodeId = switchNodeId;
+        this.caseName = caseName;
+        this.description = `Remove case "${caseName}"`;
+    }
+    apply(model) {
+        const handleId = `case_${this.caseName}`;
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.switchNodeId)
+                return node;
+            const prevCases = node.config.cases;
+            if (!Array.isArray(prevCases))
+                return node;
+            this.removedCaseIndex = prevCases.findIndex((c) => c != null && typeof c === "object" && c.name === this.caseName);
+            if (this.removedCaseIndex >= 0) {
+                this.removedCase = prevCases[this.removedCaseIndex];
+            }
+            const nextCases = prevCases.filter((c) => !(c != null && typeof c === "object" && c.name === this.caseName));
+            return { ...node, config: { ...node.config, cases: nextCases } };
+        });
+        this.removedEdges = model.edges.filter((e) => e.source === this.switchNodeId && e.sourceHandle === handleId);
+        const edges = model.edges.filter((e) => !(e.source === this.switchNodeId && e.sourceHandle === handleId));
+        return { ...model, nodes, edges };
+    }
+    undo(model) {
+        if (this.removedCase === undefined || this.removedCaseIndex < 0)
+            return model;
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.switchNodeId)
+                return node;
+            const prevCases = node.config.cases;
+            const nextCases = Array.isArray(prevCases) ? [...prevCases] : [];
+            nextCases.splice(this.removedCaseIndex, 0, this.removedCase);
+            return { ...node, config: { ...node.config, cases: nextCases } };
+        });
+        const edges = [...model.edges, ...this.removedEdges];
+        return { ...model, nodes, edges };
+    }
+}
+/**
+ * Reorders cases in a switch_case node's `config.cases` array.
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class ReorderSwitchCasesCommand {
+    type = "reorder_switch_cases";
+    description;
+    switchNodeId;
+    newOrder;
+    previousOrder = [];
+    constructor(switchNodeId, newOrder) {
+        this.switchNodeId = switchNodeId;
+        this.newOrder = newOrder;
+        this.description = "Reorder switch cases";
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.switchNodeId)
+                return node;
+            const prevCases = node.config.cases;
+            if (!Array.isArray(prevCases))
+                return node;
+            this.previousOrder = prevCases
+                .filter((c) => c != null && typeof c === "object")
+                .map((c) => c.name);
+            const caseMap = new Map();
+            for (const c of prevCases) {
+                if (c != null && typeof c === "object") {
+                    caseMap.set(c.name, c);
+                }
+            }
+            const nextCases = this.newOrder
+                .map((name) => caseMap.get(name))
+                .filter((c) => c !== undefined);
+            return { ...node, config: { ...node.config, cases: nextCases } };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        if (this.previousOrder.length === 0)
+            return model;
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.switchNodeId)
+                return node;
+            const prevCases = node.config.cases;
+            if (!Array.isArray(prevCases))
+                return node;
+            const caseMap = new Map();
+            for (const c of prevCases) {
+                if (c != null && typeof c === "object") {
+                    caseMap.set(c.name, c);
+                }
+            }
+            const nextCases = this.previousOrder
+                .map((name) => caseMap.get(name))
+                .filter((c) => c !== undefined);
+            return { ...node, config: { ...node.config, cases: nextCases } };
+        });
+        return { ...model, nodes };
+    }
+}
+// ---------------------------------------------------------------------------
+// T09: Fork branch management commands
+// ---------------------------------------------------------------------------
+/**
+ * Removes a branch from a fork node's `config.branches` array.
+ * Refuses to execute if it would leave fewer than 2 branches (proto min_items constraint).
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class RemoveForkBranchCommand {
+    type = "remove_fork_branch";
+    description;
+    forkNodeId;
+    branchName;
+    removedBranch = undefined;
+    removedIndex = -1;
+    constructor(forkNodeId, branchName) {
+        this.forkNodeId = forkNodeId;
+        this.branchName = branchName;
+        this.description = `Remove branch "${branchName}"`;
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            const prevBranches = node.config.branches;
+            if (!Array.isArray(prevBranches) || prevBranches.length <= 2)
+                return node;
+            this.removedIndex = prevBranches.findIndex((b) => b != null && typeof b === "object" && b.name === this.branchName);
+            if (this.removedIndex >= 0) {
+                this.removedBranch = prevBranches[this.removedIndex];
+            }
+            const nextBranches = prevBranches.filter((b) => !(b != null && typeof b === "object" && b.name === this.branchName));
+            return { ...node, config: { ...node.config, branches: nextBranches } };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        if (this.removedBranch === undefined || this.removedIndex < 0)
+            return model;
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            const prevBranches = node.config.branches;
+            const nextBranches = Array.isArray(prevBranches) ? [...prevBranches] : [];
+            nextBranches.splice(this.removedIndex, 0, this.removedBranch);
+            return { ...node, config: { ...node.config, branches: nextBranches } };
+        });
+        return { ...model, nodes };
+    }
+}
+/**
+ * Reorders branches in a fork node's `config.branches` array.
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class ReorderForkBranchesCommand {
+    type = "reorder_fork_branches";
+    description;
+    forkNodeId;
+    newOrder;
+    previousOrder = [];
+    constructor(forkNodeId, newOrder) {
+        this.forkNodeId = forkNodeId;
+        this.newOrder = newOrder;
+        this.description = "Reorder fork branches";
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            const prevBranches = node.config.branches;
+            if (!Array.isArray(prevBranches))
+                return node;
+            this.previousOrder = prevBranches
+                .filter((b) => b != null && typeof b === "object")
+                .map((b) => b.name);
+            const branchMap = new Map();
+            for (const b of prevBranches) {
+                if (b != null && typeof b === "object") {
+                    branchMap.set(b.name, b);
+                }
+            }
+            const nextBranches = this.newOrder
+                .map((name) => branchMap.get(name))
+                .filter((b) => b !== undefined);
+            return { ...node, config: { ...node.config, branches: nextBranches } };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        if (this.previousOrder.length === 0)
+            return model;
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            const prevBranches = node.config.branches;
+            if (!Array.isArray(prevBranches))
+                return node;
+            const branchMap = new Map();
+            for (const b of prevBranches) {
+                if (b != null && typeof b === "object") {
+                    branchMap.set(b.name, b);
+                }
+            }
+            const nextBranches = this.previousOrder
+                .map((name) => branchMap.get(name))
+                .filter((b) => b !== undefined);
+            return { ...node, config: { ...node.config, branches: nextBranches } };
+        });
+        return { ...model, nodes };
+    }
+}
+/**
+ * Renames a branch in a fork node's `config.branches` array.
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class RenameForkBranchCommand {
+    type = "rename_fork_branch";
+    description;
+    forkNodeId;
+    oldName;
+    newName;
+    constructor(forkNodeId, oldName, newName) {
+        this.forkNodeId = forkNodeId;
+        this.oldName = oldName;
+        this.newName = newName;
+        this.description = `Rename branch "${oldName}" to "${newName}"`;
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            const prevBranches = node.config.branches;
+            if (!Array.isArray(prevBranches))
+                return node;
+            const nextBranches = prevBranches.map((b) => {
+                if (b != null && typeof b === "object" && b.name === this.oldName) {
+                    return { ...b, name: this.newName };
+                }
+                return b;
+            });
+            return { ...node, config: { ...node.config, branches: nextBranches } };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            const prevBranches = node.config.branches;
+            if (!Array.isArray(prevBranches))
+                return node;
+            const nextBranches = prevBranches.map((b) => {
+                if (b != null && typeof b === "object" && b.name === this.newName) {
+                    return { ...b, name: this.oldName };
+                }
+                return b;
+            });
+            return { ...node, config: { ...node.config, branches: nextBranches } };
+        });
+        return { ...model, nodes };
+    }
+}
+/**
+ * Toggles the `compete` flag on a fork node (race mode vs wait-for-all).
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class SetForkCompeteCommand {
+    type = "set_fork_compete";
+    description;
+    forkNodeId;
+    compete;
+    previousValue = false;
+    constructor(forkNodeId, compete) {
+        this.forkNodeId = forkNodeId;
+        this.compete = compete;
+        this.description = compete ? "Set fork to race mode" : "Set fork to wait-for-all";
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            this.previousValue = node.config.compete === true;
+            const config = { ...node.config };
+            if (this.compete) {
+                config.compete = true;
+            }
+            else {
+                delete config.compete;
+            }
+            return { ...node, config: config };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forkNodeId)
+                return node;
+            const config = { ...node.config };
+            if (this.previousValue) {
+                config.compete = true;
+            }
+            else {
+                delete config.compete;
+            }
+            return { ...node, config: config };
+        });
+        return { ...model, nodes };
+    }
+}
+// ---------------------------------------------------------------------------
+// T09: TryCatch management commands
+// ---------------------------------------------------------------------------
+/**
+ * Updates catch configuration fields (`as`, `compensate`) on a try_catch node.
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class UpdateCatchConfigCommand {
+    type = "update_catch_config";
+    description;
+    tryCatchNodeId;
+    updates;
+    previousValues = {};
+    updatedKeys = [];
+    constructor(tryCatchNodeId, updates) {
+        this.tryCatchNodeId = tryCatchNodeId;
+        this.updates = updates;
+        this.description = "Update catch configuration";
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.tryCatchNodeId)
+                return node;
+            const config = node.config;
+            const prevCatch = config.catch;
+            if (!prevCatch)
+                return node;
+            this.updatedKeys = [];
+            this.previousValues = {};
+            const nextCatch = { ...prevCatch };
+            if (this.updates.as !== undefined) {
+                this.previousValues.as = prevCatch.as;
+                this.updatedKeys.push("as");
+                nextCatch.as = this.updates.as;
+            }
+            if (this.updates.compensate !== undefined) {
+                this.previousValues.compensate = prevCatch.compensate;
+                this.updatedKeys.push("compensate");
+                if (this.updates.compensate) {
+                    nextCatch.compensate = true;
+                }
+                else {
+                    delete nextCatch.compensate;
+                }
+            }
+            return { ...node, config: { ...config, catch: nextCatch } };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.tryCatchNodeId)
+                return node;
+            const config = node.config;
+            const prevCatch = config.catch;
+            if (!prevCatch)
+                return node;
+            const nextCatch = { ...prevCatch };
+            for (const key of this.updatedKeys) {
+                const prevValue = this.previousValues[key];
+                if (prevValue === undefined) {
+                    delete nextCatch[key];
+                }
+                else {
+                    nextCatch[key] = prevValue;
+                }
+            }
+            return { ...node, config: { ...config, catch: nextCatch } };
+        });
+        return { ...model, nodes };
+    }
+}
+/**
+ * Removes the catch block from a try_catch node's config.
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class RemoveCatchBlockCommand {
+    type = "remove_catch_block";
+    description = "Remove catch handler";
+    tryCatchNodeId;
+    previousCatch = undefined;
+    constructor(tryCatchNodeId) {
+        this.tryCatchNodeId = tryCatchNodeId;
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.tryCatchNodeId)
+                return node;
+            const config = node.config;
+            this.previousCatch = config.catch;
+            const { catch: _removed, ...rest } = config;
+            return { ...node, config: rest };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        if (this.previousCatch === undefined)
+            return model;
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.tryCatchNodeId)
+                return node;
+            return { ...node, config: { ...node.config, catch: this.previousCatch } };
+        });
+        return { ...model, nodes };
+    }
+}
+// ---------------------------------------------------------------------------
+// T09: ForEach configuration command
+// ---------------------------------------------------------------------------
+/**
+ * Updates for_each configuration fields on a for_each node.
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class UpdateForEachConfigCommand {
+    type = "update_for_each_config";
+    description;
+    forEachNodeId;
+    updates;
+    previousValues = {};
+    constructor(forEachNodeId, updates) {
+        this.forEachNodeId = forEachNodeId;
+        this.updates = updates;
+        this.description = "Update for-each configuration";
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forEachNodeId)
+                return node;
+            const config = { ...node.config };
+            for (const [key, value] of Object.entries(this.updates)) {
+                if (value !== undefined) {
+                    this.previousValues[key] = config[key];
+                    config[key] = value;
+                }
+            }
+            return { ...node, config: config };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.forEachNodeId)
+                return node;
+            const config = { ...node.config };
+            for (const [key, value] of Object.entries(this.previousValues)) {
+                if (value === undefined) {
+                    delete config[key];
+                }
+                else {
+                    config[key] = value;
+                }
+            }
+            return { ...node, config: config };
+        });
+        return { ...model, nodes };
+    }
+}
+// ---------------------------------------------------------------------------
+// T09: Nested task editing commands
+// ---------------------------------------------------------------------------
+/**
+ * Adds a task to a nested `do[]` array within a container node's config.
+ * Path format: "branches.0.do" or "try" or "catch.do"
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class AddNestedTaskCommand {
+    type = "add_nested_task";
+    description;
+    containerNodeId;
+    arrayPath;
+    task;
+    constructor(containerNodeId, arrayPath, task) {
+        this.containerNodeId = containerNodeId;
+        this.arrayPath = arrayPath;
+        this.task = task;
+        const taskName = task.name || "task";
+        this.description = `Add nested task "${taskName}"`;
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.containerNodeId)
+                return node;
+            const config = { ...node.config };
+            const arr = getNestedArray(config, this.arrayPath);
+            if (!arr)
+                return node;
+            arr.push(this.task);
+            setNestedArray(config, this.arrayPath, arr);
+            return { ...node, config: config };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.containerNodeId)
+                return node;
+            const config = { ...node.config };
+            const arr = getNestedArray(config, this.arrayPath);
+            if (!arr || arr.length === 0)
+                return node;
+            arr.pop();
+            setNestedArray(config, this.arrayPath, arr);
+            return { ...node, config: config };
+        });
+        return { ...model, nodes };
+    }
+}
+/**
+ * Removes a task from a nested `do[]` array at a specific index.
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class RemoveNestedTaskCommand {
+    type = "remove_nested_task";
+    description;
+    containerNodeId;
+    arrayPath;
+    index;
+    removedTask = undefined;
+    constructor(containerNodeId, arrayPath, index) {
+        this.containerNodeId = containerNodeId;
+        this.arrayPath = arrayPath;
+        this.index = index;
+        this.description = "Remove nested task";
+    }
+    apply(model) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.containerNodeId)
+                return node;
+            const config = { ...node.config };
+            const arr = getNestedArray(config, this.arrayPath);
+            if (!arr || this.index < 0 || this.index >= arr.length)
+                return node;
+            this.removedTask = arr[this.index];
+            const next = [...arr];
+            next.splice(this.index, 1);
+            setNestedArray(config, this.arrayPath, next);
+            return { ...node, config: config };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        if (this.removedTask === undefined)
+            return model;
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.containerNodeId)
+                return node;
+            const config = { ...node.config };
+            const arr = getNestedArray(config, this.arrayPath);
+            if (!arr)
+                return node;
+            const next = [...arr];
+            next.splice(this.index, 0, this.removedTask);
+            setNestedArray(config, this.arrayPath, next);
+            return { ...node, config: config };
+        });
+        return { ...model, nodes };
+    }
+}
+/**
+ * Reorders tasks within a nested `do[]` array.
+ *
+ * @since T09 (Branch Management UX)
+ */
+export class ReorderNestedTasksCommand {
+    type = "reorder_nested_tasks";
+    description = "Reorder nested tasks";
+    containerNodeId;
+    arrayPath;
+    fromIndex;
+    toIndex;
+    constructor(containerNodeId, arrayPath, fromIndex, toIndex) {
+        this.containerNodeId = containerNodeId;
+        this.arrayPath = arrayPath;
+        this.fromIndex = fromIndex;
+        this.toIndex = toIndex;
+    }
+    apply(model) {
+        return this.reorder(model, this.fromIndex, this.toIndex);
+    }
+    undo(model) {
+        return this.reorder(model, this.toIndex, this.fromIndex);
+    }
+    reorder(model, from, to) {
+        const nodes = model.nodes.map((node) => {
+            if (node.id !== this.containerNodeId)
+                return node;
+            const config = { ...node.config };
+            const arr = getNestedArray(config, this.arrayPath);
+            if (!arr || from < 0 || from >= arr.length || to < 0 || to >= arr.length)
+                return node;
+            const next = [...arr];
+            const [item] = next.splice(from, 1);
+            next.splice(to, 0, item);
+            setNestedArray(config, this.arrayPath, next);
+            return { ...node, config: config };
+        });
+        return { ...model, nodes };
+    }
+}
+// ---------------------------------------------------------------------------
+// Nested array helpers (T09)
+// ---------------------------------------------------------------------------
+function getNestedArray(config, path) {
+    const keys = path.split(".");
+    let current = config;
+    for (const key of keys) {
+        if (current == null || typeof current !== "object")
+            return null;
+        const idx = Number(key);
+        if (!Number.isNaN(idx) && Array.isArray(current)) {
+            current = current[idx];
+        }
+        else {
+            current = current[key];
+        }
+    }
+    return Array.isArray(current) ? [...current] : null;
+}
+/**
+ * Immutably sets a value at a nested dot-notation path within a config object.
+ * Creates shallow copies at each level to avoid mutating the original.
+ * Handles numeric segments as array indices.
+ */
+function setNestedArray(config, path, value) {
+    const keys = path.split(".");
+    setAtPath(config, keys, 0, value);
+}
+function setAtPath(current, keys, depth, value) {
+    if (depth >= keys.length)
+        return;
+    const key = keys[depth];
+    const isLast = depth === keys.length - 1;
+    const idx = Number(key);
+    const isIndex = !Number.isNaN(idx) && Array.isArray(current);
+    if (isLast) {
+        if (isIndex && Array.isArray(current)) {
+            current[idx] = value;
+        }
+        else {
+            current[key] = value;
+        }
+        return;
+    }
+    if (isIndex && Array.isArray(current)) {
+        const child = current[idx];
+        if (child == null || typeof child !== "object")
+            return;
+        const childCopy = Array.isArray(child) ? [...child] : { ...child };
+        current[idx] = childCopy;
+        setAtPath(childCopy, keys, depth + 1, value);
+    }
+    else {
+        const obj = current;
+        const child = obj[key];
+        if (child == null || typeof child !== "object") {
+            obj[key] = {};
+        }
+        else if (Array.isArray(child)) {
+            obj[key] = [...child];
+        }
+        else {
+            obj[key] = { ...child };
+        }
+        setAtPath(obj[key], keys, depth + 1, value);
+    }
+}
+// ---------------------------------------------------------------------------
+// ToggleNodeDisabledCommand
+// ---------------------------------------------------------------------------
+/**
+ * Toggles the `disabled` flag on a graph node.
+ *
+ * Disabled nodes are visually dimmed on the canvas and skipped during
+ * execution. The flag round-trips as `x-stigmer-disabled: true` in YAML.
+ *
+ * @since T10 (Inspector Panel Refactor)
+ */
+export class ToggleNodeDisabledCommand {
+    type = "toggle_node_disabled";
+    description;
+    nodeId;
+    previousValue = false;
+    constructor(nodeId, taskName) {
+        this.nodeId = nodeId;
+        this.description = `Toggle disabled on "${taskName}"`;
+    }
+    apply(model) {
+        const nodes = model.nodes.map((n) => {
+            if (n.id !== this.nodeId)
+                return n;
+            const currentDisabled = n.config["x-stigmer-disabled"] === true;
+            this.previousValue = currentDisabled;
+            const config = { ...n.config };
+            if (currentDisabled) {
+                delete config["x-stigmer-disabled"];
+            }
+            else {
+                config["x-stigmer-disabled"] = true;
+            }
+            return { ...n, config: config };
+        });
+        return { ...model, nodes };
+    }
+    undo(model) {
+        const nodes = model.nodes.map((n) => {
+            if (n.id !== this.nodeId)
+                return n;
+            const config = { ...n.config };
+            if (this.previousValue) {
+                config["x-stigmer-disabled"] = true;
+            }
+            else {
+                delete config["x-stigmer-disabled"];
+            }
+            return { ...n, config: config };
+        });
+        return { ...model, nodes };
+    }
+}
+// ---------------------------------------------------------------------------
+// WrapInTryCatchCommand
+// ---------------------------------------------------------------------------
+/**
+ * Wraps a single node in a `try_catch` container.
+ *
+ * Creates a new `try_catch` node that contains the target node in its
+ * `try` block and inherits the target node's incoming/outgoing edges.
+ *
+ * @since T10 (Inspector Panel Refactor)
+ */
+export class WrapInTryCatchCommand {
+    type = "wrap_in_try_catch";
+    description;
+    nodeId;
+    tryCatchName;
+    snapshot = null;
+    constructor(nodeId, taskName, tryCatchName) {
+        this.nodeId = nodeId;
+        this.tryCatchName = tryCatchName;
+        this.description = `Wrap "${taskName}" in try/catch`;
+    }
+    apply(model) {
+        const targetNode = model.nodes.find((n) => n.id === this.nodeId);
+        if (!targetNode)
+            return model;
+        const affectedEdges = model.edges.filter((e) => e.source === this.nodeId || e.target === this.nodeId);
+        this.snapshot = {
+            originalNode: targetNode,
+            originalEdges: affectedEdges,
+        };
+        const tryCatchNode = {
+            id: this.tryCatchName,
+            taskName: this.tryCatchName,
+            kind: targetNode.kind,
+            category: "control_flow",
+            config: {
+                try: [{ name: targetNode.taskName, kind: targetNode.kind.toString(), task_config: targetNode.config }],
+            },
+            position: targetNode.position,
+        };
+        const nodes = model.nodes
+            .filter((n) => n.id !== this.nodeId)
+            .concat(tryCatchNode);
+        const edges = model.edges.map((e) => {
+            if (e.source === this.nodeId)
+                return { ...e, source: this.tryCatchName };
+            if (e.target === this.nodeId)
+                return { ...e, target: this.tryCatchName };
+            return e;
+        });
+        return { ...model, nodes, edges };
+    }
+    undo(model) {
+        if (!this.snapshot)
+            return model;
+        const nodes = model.nodes
+            .filter((n) => n.id !== this.tryCatchName)
+            .concat(this.snapshot.originalNode);
+        const tryCatchEdges = new Set(model.edges
+            .filter((e) => e.source === this.tryCatchName || e.target === this.tryCatchName)
+            .map((e) => e.id));
+        const edges = model.edges
+            .filter((e) => !tryCatchEdges.has(e.id))
+            .concat(this.snapshot.originalEdges);
+        return { ...model, nodes, edges };
+    }
+}
+// ---------------------------------------------------------------------------
 // GraphHistory
 // ---------------------------------------------------------------------------
 const MAX_HISTORY_SIZE = 50;