@webiny/website-builder-sdk 0.0.0-unstable.6f45466a1d → 0.0.0-unstable.7be00a75a9

package/ConstraintEvaluator.test.js

@@ -0,0 +1,1634 @@
+import { describe, expect, it } from "vitest";
+import { evaluateConstraints, evaluateDeleteConstraint } from "./ConstraintEvaluator.js";
+function makeElement(id, componentName, parent) {
+    return {
+        type: "Webiny/Element",
+        id,
+        component: {
+            name: componentName
+        },
+        parent
+    };
+}
+function makeManifest(name, overrides) {
+    return {
+        name,
+        label: name,
+        inputs: [],
+        tags: [],
+        ...overrides
+    };
+}
+function makeDocument(elements, bindings = {}) {
+    const elementMap = {};
+    for (const el of elements)elementMap[el.id] = el;
+    return {
+        id: "doc-1",
+        state: {},
+        version: 1,
+        properties: {},
+        metadata: {},
+        extensions: {},
+        bindings,
+        elements: elementMap
+    };
+}
+describe("evaluateConstraints", ()=>{
+    it("should allow placement when there are no constraints", ()=>{
+        const parent = makeElement("parent-1", "Container");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Container: makeManifest("Container"),
+            Button: makeManifest("Button")
+        };
+        const result = evaluateConstraints({
+            componentName: "Button",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+        expect(result.violation).toBeUndefined();
+    });
+    it("should block when component's parent constraint fails", ()=>{
+        const parent = makeElement("parent-1", "Container");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Container: makeManifest("Container"),
+            TabPanel: makeManifest("TabPanel", {
+                constraints: [
+                    (ctx)=>{
+                        if ("Tabs" !== ctx.parent.name) return ctx.block("TabPanel must be inside Tabs");
+                    }
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "TabPanel",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation).toBeDefined();
+        expect(result.violation.message).toBe("TabPanel must be inside Tabs");
+    });
+    it("should allow when parent constraint passes", ()=>{
+        const parent = makeElement("parent-1", "Tabs");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Tabs: makeManifest("Tabs"),
+            TabPanel: makeManifest("TabPanel", {
+                constraints: [
+                    (ctx)=>{
+                        if ("Tabs" !== ctx.parent.name) return ctx.block("TabPanel must be inside Tabs");
+                    }
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "TabPanel",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+        expect(result.violation).toBeUndefined();
+    });
+    it("should block when ancestor constraint fails", ()=>{
+        const root = makeElement("root", "Page");
+        const section = makeElement("section-1", "Section", {
+            id: "root",
+            slot: "children"
+        });
+        const doc = makeDocument([
+            root,
+            section
+        ]);
+        const components = {
+            Page: makeManifest("Page"),
+            Section: makeManifest("Section"),
+            ProductPrice: makeManifest("ProductPrice", {
+                constraints: [
+                    (ctx)=>{
+                        if (!ctx.isDescendantOf("ProductBox")) return ctx.block("ProductPrice must be inside a ProductBox");
+                    }
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "ProductPrice",
+            parentId: "section-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("ProductPrice must be inside a ProductBox");
+    });
+    it("should allow when grandparent matches ancestor constraint", ()=>{
+        const root = makeElement("root", "ProductBox");
+        const inner = makeElement("inner-1", "Container", {
+            id: "root",
+            slot: "children"
+        });
+        const doc = makeDocument([
+            root,
+            inner
+        ]);
+        const components = {
+            ProductBox: makeManifest("ProductBox"),
+            Container: makeManifest("Container"),
+            ProductPrice: makeManifest("ProductPrice", {
+                constraints: [
+                    (ctx)=>{
+                        if (!ctx.isDescendantOf("ProductBox")) return ctx.block("ProductPrice must be inside a ProductBox");
+                    }
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "ProductPrice",
+            parentId: "inner-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+    });
+    it("should block via slot children limit constraint using slotChildCount", ()=>{
+        const parent = makeElement("parent-1", "Grid");
+        const child1 = makeElement("child-1", "Cell", {
+            id: "parent-1",
+            slot: "children"
+        });
+        const child2 = makeElement("child-2", "Cell", {
+            id: "parent-1",
+            slot: "children"
+        });
+        const doc = makeDocument([
+            parent,
+            child1,
+            child2
+        ], {
+            "parent-1": {
+                inputs: {
+                    children: {
+                        id: "inp-1",
+                        type: "slot",
+                        static: [
+                            "child-1",
+                            "child-2"
+                        ]
+                    }
+                }
+            }
+        });
+        const components = {
+            Grid: makeManifest("Grid"),
+            Cell: makeManifest("Cell", {
+                constraints: [
+                    (ctx)=>{
+                        if (!(ctx.slotChildCount() < 2)) return ctx.block("Maximum 2 children allowed");
+                    }
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "Cell",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("Maximum 2 children allowed");
+    });
+    it("should block via countInstances when max instances reached", ()=>{
+        const root = makeElement("root", "Page");
+        const hero = makeElement("hero-1", "Hero", {
+            id: "root",
+            slot: "children"
+        });
+        const doc = makeDocument([
+            root,
+            hero
+        ]);
+        const components = {
+            Page: makeManifest("Page"),
+            Hero: makeManifest("Hero", {
+                constraints: [
+                    (ctx)=>{
+                        if (!(ctx.countInstances("Hero") < 1)) return ctx.block("Only one Hero per page");
+                    }
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "Hero",
+            parentId: "root",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("Only one Hero per page");
+    });
+    it("should not evaluate parent's constraints against the placed component", ()=>{
+        const parent = makeElement("parent-1", "Tabs");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Tabs: makeManifest("Tabs", {
+                constraints: [
+                    (ctx)=>ctx.block("This should not run for children")
+                ]
+            }),
+            Button: makeManifest("Button")
+        };
+        const result = evaluateConstraints({
+            componentName: "Button",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+    });
+    it("should short-circuit on the first failed constraint", ()=>{
+        const parent = makeElement("parent-1", "Container");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Container: makeManifest("Container"),
+            Widget: makeManifest("Widget", {
+                constraints: [
+                    ()=>{},
+                    (ctx)=>ctx.block("Always fails"),
+                    (ctx)=>ctx.block("Also fails")
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "Widget",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("Always fails");
+    });
+    it("should allow placement when component manifest is not found", ()=>{
+        const parent = makeElement("parent-1", "Container");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Container: makeManifest("Container")
+        };
+        const result = evaluateConstraints({
+            componentName: "Unknown",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+    });
+    it("should allow placement when parent element is not found", ()=>{
+        const doc = makeDocument([]);
+        const components = {
+            Button: makeManifest("Button")
+        };
+        const result = evaluateConstraints({
+            componentName: "Button",
+            parentId: "nonexistent",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+    });
+    it("should handle multi-slot parent constraint checking specific slot", ()=>{
+        const parent = makeElement("parent-1", "TwoColumn");
+        const child = makeElement("child-1", "Widget", {
+            id: "parent-1",
+            slot: "leftColumn"
+        });
+        const doc = makeDocument([
+            parent,
+            child
+        ], {
+            "parent-1": {
+                inputs: {
+                    leftColumn: {
+                        id: "inp-left",
+                        type: "slot",
+                        static: [
+                            "child-1"
+                        ]
+                    },
+                    rightColumn: {
+                        id: "inp-right",
+                        type: "slot",
+                        static: []
+                    }
+                }
+            }
+        });
+        const components = {
+            TwoColumn: makeManifest("TwoColumn"),
+            Widget: makeManifest("Widget", {
+                constraints: [
+                    (ctx)=>{
+                        if (!(ctx.slotChildCount() < 1)) return ctx.block("Slot is full");
+                    }
+                ]
+            })
+        };
+        const leftResult = evaluateConstraints({
+            componentName: "Widget",
+            parentId: "parent-1",
+            slot: "leftColumn",
+            document: doc,
+            components
+        });
+        expect(leftResult.allowed).toBe(false);
+        const rightResult = evaluateConstraints({
+            componentName: "Widget",
+            parentId: "parent-1",
+            slot: "rightColumn",
+            document: doc,
+            components
+        });
+        expect(rightResult.allowed).toBe(true);
+    });
+    it("should provide a default message when constraint has no message", ()=>{
+        const parent = makeElement("parent-1", "Container");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Container: makeManifest("Container"),
+            Widget: makeManifest("Widget", {
+                constraints: [
+                    (ctx)=>ctx.block("Blocked")
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "Widget",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.violation.message).toBe("Blocked");
+    });
+    it("should use thrown error message as the violation message", ()=>{
+        const parent = makeElement("parent-1", "Container");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Container: makeManifest("Container"),
+            Widget: makeManifest("Widget", {
+                constraints: [
+                    (ctx)=>{
+                        throw new Error(`Widget cannot be placed inside ${ctx.parent.name}`);
+                    }
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "Widget",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("Widget cannot be placed inside Container");
+    });
+    it("should fall back to static message when a non-Error is thrown", ()=>{
+        const parent = makeElement("parent-1", "Container");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Container: makeManifest("Container"),
+            Widget: makeManifest("Widget", {
+                constraints: [
+                    ()=>{
+                        throw "not an error object";
+                    }
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "Widget",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("Cannot place Widget here.");
+    });
+    it("should fall back to default message when a non-Error is thrown and no static message", ()=>{
+        const parent = makeElement("parent-1", "Container");
+        const doc = makeDocument([
+            parent
+        ]);
+        const components = {
+            Container: makeManifest("Container"),
+            Widget: makeManifest("Widget", {
+                constraints: [
+                    ()=>{
+                        throw null;
+                    }
+                ]
+            })
+        };
+        const result = evaluateConstraints({
+            componentName: "Widget",
+            parentId: "parent-1",
+            slot: "children",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("Cannot place Widget here.");
+    });
+    describe("ctx.isChildOf", ()=>{
+        it("should return true when direct parent matches", ()=>{
+            const parent = makeElement("parent-1", "Tabs");
+            const doc = makeDocument([
+                parent
+            ]);
+            const components = {
+                Tabs: makeManifest("Tabs"),
+                TabPanel: makeManifest("TabPanel", {
+                    constraints: [
+                        (ctx)=>{
+                            if (!ctx.isChildOf("Tabs")) return ctx.block("TabPanel must be a direct child of Tabs");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "TabPanel",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(true);
+        });
+        it("should return false when direct parent does not match", ()=>{
+            const parent = makeElement("parent-1", "Container");
+            const doc = makeDocument([
+                parent
+            ]);
+            const components = {
+                Container: makeManifest("Container"),
+                TabPanel: makeManifest("TabPanel", {
+                    constraints: [
+                        (ctx)=>{
+                            if (!ctx.isChildOf("Tabs")) return ctx.block("TabPanel must be a direct child of Tabs");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "TabPanel",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(false);
+        });
+    });
+    describe("ctx.isDescendantOf", ()=>{
+        it("should return true when direct parent matches", ()=>{
+            const parent = makeElement("parent-1", "ProductBox");
+            const doc = makeDocument([
+                parent
+            ]);
+            const components = {
+                ProductBox: makeManifest("ProductBox"),
+                ProductPrice: makeManifest("ProductPrice", {
+                    constraints: [
+                        (ctx)=>{
+                            if (!ctx.isDescendantOf("ProductBox")) return ctx.block("Blocked");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "ProductPrice",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(true);
+        });
+        it("should return true when grandparent matches", ()=>{
+            const root = makeElement("root", "ProductBox");
+            const inner = makeElement("inner", "Container", {
+                id: "root",
+                slot: "children"
+            });
+            const doc = makeDocument([
+                root,
+                inner
+            ]);
+            const components = {
+                ProductBox: makeManifest("ProductBox"),
+                Container: makeManifest("Container"),
+                ProductPrice: makeManifest("ProductPrice", {
+                    constraints: [
+                        (ctx)=>{
+                            if (!ctx.isDescendantOf("ProductBox")) return ctx.block("Blocked");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "ProductPrice",
+                parentId: "inner",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(true);
+        });
+        it("should return false when no ancestor matches", ()=>{
+            const root = makeElement("root", "Page");
+            const inner = makeElement("inner", "Section", {
+                id: "root",
+                slot: "children"
+            });
+            const doc = makeDocument([
+                root,
+                inner
+            ]);
+            const components = {
+                Page: makeManifest("Page"),
+                Section: makeManifest("Section"),
+                ProductPrice: makeManifest("ProductPrice", {
+                    constraints: [
+                        (ctx)=>{
+                            if (!ctx.isDescendantOf("ProductBox")) return ctx.block("Blocked");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "ProductPrice",
+                parentId: "inner",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(false);
+        });
+    });
+    describe("ctx.slotChildCount", ()=>{
+        it("should return the number of children in the target slot", ()=>{
+            const parent = makeElement("parent-1", "Grid");
+            const doc = makeDocument([
+                parent
+            ], {
+                "parent-1": {
+                    inputs: {
+                        children: {
+                            id: "inp-1",
+                            type: "slot",
+                            static: [
+                                "child-1",
+                                "child-2",
+                                "child-3"
+                            ]
+                        }
+                    }
+                }
+            });
+            const components = {
+                Grid: makeManifest("Grid"),
+                Cell: makeManifest("Cell", {
+                    constraints: [
+                        (ctx)=>{
+                            if (!(ctx.slotChildCount() < 3)) return ctx.block("Max 3 children");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "Cell",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(false);
+        });
+        it("should return 0 when slot has no bindings", ()=>{
+            const parent = makeElement("parent-1", "Container");
+            const doc = makeDocument([
+                parent
+            ]);
+            const components = {
+                Container: makeManifest("Container"),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>{
+                            if (!(ctx.slotChildCount() < 5)) return ctx.block("Blocked");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "Widget",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(true);
+        });
+    });
+    describe("ctx.hasTag", ()=>{
+        it("should return true when the placed component has the tag", ()=>{
+            const parent = makeElement("parent-1", "Container");
+            const doc = makeDocument([
+                parent
+            ]);
+            const components = {
+                Container: makeManifest("Container"),
+                FunnelField: makeManifest("FunnelField", {
+                    tags: [
+                        "funnel-field",
+                        "input"
+                    ],
+                    constraints: [
+                        (ctx)=>{
+                            if (ctx.hasTag("funnel-field")) return ctx.block("Funnel fields not allowed here");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "FunnelField",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(false);
+        });
+        it("should return false when the placed component does not have the tag", ()=>{
+            const parent = makeElement("parent-1", "Container");
+            const doc = makeDocument([
+                parent
+            ]);
+            const components = {
+                Container: makeManifest("Container"),
+                Button: makeManifest("Button", {
+                    constraints: [
+                        (ctx)=>{
+                            if (ctx.hasTag("funnel-field")) return ctx.block("Blocked");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "Button",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(true);
+        });
+    });
+    describe("ctx.getAncestor", ()=>{
+        it("should return the matching ancestor element context", ()=>{
+            const root = makeElement("root", "ProductBox");
+            const inner = makeElement("inner", "Container", {
+                id: "root",
+                slot: "children"
+            });
+            const doc = makeDocument([
+                root,
+                inner
+            ]);
+            const components = {
+                ProductBox: makeManifest("ProductBox", {
+                    tags: [
+                        "product"
+                    ]
+                }),
+                Container: makeManifest("Container"),
+                ProductPrice: makeManifest("ProductPrice", {
+                    constraints: [
+                        (ctx)=>{
+                            const ancestor = ctx.getAncestor("ProductBox");
+                            if (!(void 0 !== ancestor && "ProductBox" === ancestor.name)) return ctx.block("Blocked");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "ProductPrice",
+                parentId: "inner",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(true);
+        });
+        it("should return undefined when no ancestor matches", ()=>{
+            const root = makeElement("root", "Page");
+            const doc = makeDocument([
+                root
+            ]);
+            const components = {
+                Page: makeManifest("Page"),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>{
+                            if (void 0 === ctx.getAncestor("ProductBox")) return ctx.block("Blocked");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "Widget",
+                parentId: "root",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(false);
+        });
+    });
+    describe("ctx.countInstances", ()=>{
+        it("should count instances of a component in the document", ()=>{
+            const root = makeElement("root", "Page");
+            const hero1 = makeElement("hero-1", "Hero", {
+                id: "root",
+                slot: "children"
+            });
+            const hero2 = makeElement("hero-2", "Hero", {
+                id: "root",
+                slot: "children"
+            });
+            const doc = makeDocument([
+                root,
+                hero1,
+                hero2
+            ]);
+            const components = {
+                Page: makeManifest("Page"),
+                Hero: makeManifest("Hero", {
+                    constraints: [
+                        (ctx)=>{
+                            if (!(ctx.countInstances("Hero") < 2)) return ctx.block("Max 2 Heroes");
+                        }
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "Hero",
+                parentId: "root",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(false);
+        });
+    });
+    describe("ctx.component", ()=>{
+        it("should expose the placed component's name and tags", ()=>{
+            const parent = makeElement("parent-1", "Container");
+            const doc = makeDocument([
+                parent
+            ]);
+            let capturedComponent;
+            const components = {
+                Container: makeManifest("Container"),
+                Widget: makeManifest("Widget", {
+                    tags: [
+                        "interactive",
+                        "form"
+                    ],
+                    constraints: [
+                        (ctx)=>{
+                            capturedComponent = ctx.component;
+                        }
+                    ]
+                })
+            };
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(capturedComponent).toBeDefined();
+            expect(capturedComponent.name).toBe("Widget");
+            expect(capturedComponent.tags).toEqual([
+                "interactive",
+                "form"
+            ]);
+        });
+    });
+    describe("parent.getParent", ()=>{
+        it("should return the grandparent element context", ()=>{
+            const root = makeElement("root", "Page");
+            const section = makeElement("section", "Section", {
+                id: "root",
+                slot: "children"
+            });
+            const doc = makeDocument([
+                root,
+                section
+            ]);
+            let grandparentName;
+            const components = {
+                Page: makeManifest("Page"),
+                Section: makeManifest("Section"),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>{
+                            const grandparent = ctx.parent.getParent();
+                            grandparentName = grandparent?.name;
+                        }
+                    ]
+                })
+            };
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "section",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(grandparentName).toBe("Page");
+        });
+        it("should return undefined for root element", ()=>{
+            const root = makeElement("root", "Page");
+            const doc = makeDocument([
+                root
+            ]);
+            let parentResult = "not-called";
+            const components = {
+                Page: makeManifest("Page"),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>{
+                            parentResult = ctx.parent.getParent();
+                        }
+                    ]
+                })
+            };
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "root",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(parentResult).toBeUndefined();
+        });
+    });
+    describe("parent.childIndex / childCount / isFirstChild / isLastChild", ()=>{
+        it("should return -1 for elements not in a list slot", ()=>{
+            const root = makeElement("root", "Page");
+            const doc = makeDocument([
+                root
+            ]);
+            let capturedIndex;
+            let capturedCount;
+            const components = {
+                Page: makeManifest("Page"),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>{
+                            capturedIndex = ctx.parent.childIndex();
+                            capturedCount = ctx.parent.childCount();
+                        }
+                    ]
+                })
+            };
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "root",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(capturedIndex).toBe(-1);
+            expect(capturedCount).toBe(-1);
+        });
+        it("should parse child index from list slot path", ()=>{
+            const root = makeElement("root", "FunnelBuilder");
+            const step = makeElement("step-1", "Step", {
+                id: "root",
+                slot: "steps/2/step"
+            });
+            const doc = makeDocument([
+                root,
+                step
+            ], {
+                root: {
+                    inputs: {
+                        "steps/0/step": {
+                            id: "s0",
+                            type: "slot",
+                            static: [
+                                "step-0"
+                            ]
+                        },
+                        "steps/1/step": {
+                            id: "s1",
+                            type: "slot",
+                            static: [
+                                "step-other"
+                            ]
+                        },
+                        "steps/2/step": {
+                            id: "s2",
+                            type: "slot",
+                            static: [
+                                "step-1"
+                            ]
+                        }
+                    }
+                }
+            });
+            let capturedIndex;
+            let capturedCount;
+            let capturedIsLast;
+            let capturedIsFirst;
+            const components = {
+                FunnelBuilder: makeManifest("FunnelBuilder"),
+                Step: makeManifest("Step"),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>{
+                            capturedIndex = ctx.parent.childIndex();
+                            capturedCount = ctx.parent.childCount();
+                            capturedIsLast = ctx.parent.isLastChild();
+                            capturedIsFirst = ctx.parent.isFirstChild();
+                        }
+                    ]
+                })
+            };
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "step-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(capturedIndex).toBe(2);
+            expect(capturedCount).toBe(3);
+            expect(capturedIsLast).toBe(true);
+            expect(capturedIsFirst).toBe(false);
+        });
+        it("should identify the first child correctly", ()=>{
+            const root = makeElement("root", "FunnelBuilder");
+            const step = makeElement("step-0", "Step", {
+                id: "root",
+                slot: "steps/0/step"
+            });
+            const doc = makeDocument([
+                root,
+                step
+            ], {
+                root: {
+                    inputs: {
+                        "steps/0/step": {
+                            id: "s0",
+                            type: "slot",
+                            static: [
+                                "step-0"
+                            ]
+                        },
+                        "steps/1/step": {
+                            id: "s1",
+                            type: "slot",
+                            static: [
+                                "step-1"
+                            ]
+                        }
+                    }
+                }
+            });
+            let capturedIsFirst;
+            let capturedIsLast;
+            const components = {
+                FunnelBuilder: makeManifest("FunnelBuilder"),
+                Step: makeManifest("Step"),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>{
+                            capturedIsFirst = ctx.parent.isFirstChild();
+                            capturedIsLast = ctx.parent.isLastChild();
+                        }
+                    ]
+                })
+            };
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "step-0",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(capturedIsFirst).toBe(true);
+            expect(capturedIsLast).toBe(false);
+        });
+        it("should resolve position from bindings even when element.parent.slot is stale", ()=>{
+            const root = makeElement("root", "FunnelBuilder");
+            const step = makeElement("step-final", "Step", {
+                id: "root",
+                slot: "steps/1/step"
+            });
+            const doc = makeDocument([
+                root,
+                step
+            ], {
+                root: {
+                    inputs: {
+                        "steps/0/step": {
+                            id: "s0",
+                            type: "slot",
+                            static: "step-0"
+                        },
+                        "steps/1/step": {
+                            id: "s1",
+                            type: "slot",
+                            static: "step-1"
+                        },
+                        "steps/2/step": {
+                            id: "s2",
+                            type: "slot",
+                            static: "step-2"
+                        },
+                        "steps/3/step": {
+                            id: "s3",
+                            type: "slot",
+                            static: "step-final"
+                        }
+                    }
+                }
+            });
+            let capturedIndex;
+            let capturedIsLast;
+            const components = {
+                FunnelBuilder: makeManifest("FunnelBuilder"),
+                Step: makeManifest("Step"),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>{
+                            capturedIndex = ctx.parent.childIndex();
+                            capturedIsLast = ctx.parent.isLastChild();
+                        }
+                    ]
+                })
+            };
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "step-final",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(capturedIndex).toBe(3);
+            expect(capturedIsLast).toBe(true);
+        });
+        it("should resolve position from direct list slot binding (static is an array of IDs)", ()=>{
+            const root = makeElement("root", "FunnelBuilder");
+            const step0 = makeElement("step-0", "Step", {
+                id: "root",
+                slot: "steps"
+            });
+            const step1 = makeElement("step-1", "Step", {
+                id: "root",
+                slot: "steps"
+            });
+            const step2 = makeElement("step-2", "Step", {
+                id: "root",
+                slot: "steps"
+            });
+            const doc = makeDocument([
+                root,
+                step0,
+                step1,
+                step2
+            ], {
+                root: {
+                    inputs: {
+                        steps: {
+                            id: "s",
+                            type: "slot",
+                            list: true,
+                            static: [
+                                "step-0",
+                                "step-1",
+                                "step-2"
+                            ]
+                        }
+                    }
+                }
+            });
+            let captured = {};
+            const comps = {
+                FunnelBuilder: makeManifest("FunnelBuilder"),
+                Step: makeManifest("Step"),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>{
+                            captured = {
+                                index: ctx.parent.childIndex(),
+                                count: ctx.parent.childCount(),
+                                isFirst: ctx.parent.isFirstChild(),
+                                isLast: ctx.parent.isLastChild()
+                            };
+                        }
+                    ]
+                })
+            };
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "step-0",
+                slot: "children",
+                document: doc,
+                components: comps
+            });
+            expect(captured.index).toBe(0);
+            expect(captured.count).toBe(3);
+            expect(captured.isFirst).toBe(true);
+            expect(captured.isLast).toBe(false);
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "step-1",
+                slot: "children",
+                document: doc,
+                components: comps
+            });
+            expect(captured.index).toBe(1);
+            expect(captured.count).toBe(3);
+            expect(captured.isFirst).toBe(false);
+            expect(captured.isLast).toBe(false);
+            evaluateConstraints({
+                componentName: "Widget",
+                parentId: "step-2",
+                slot: "children",
+                document: doc,
+                components: comps
+            });
+            expect(captured.index).toBe(2);
+            expect(captured.count).toBe(3);
+            expect(captured.isFirst).toBe(false);
+            expect(captured.isLast).toBe(true);
+        });
+    });
+    describe("descendantConstraints", ()=>{
+        it("should block a direct child via parent's descendantConstraints", ()=>{
+            const parent = makeElement("parent-1", "Step");
+            const doc = makeDocument([
+                parent
+            ]);
+            const components = {
+                Step: makeManifest("Step", {
+                    descendantConstraints: [
+                        (ctx)=>{
+                            if (ctx.hasTag("funnel-field")) return ctx.block("No funnel fields allowed");
+                        }
+                    ]
+                }),
+                TextField: makeManifest("TextField", {
+                    tags: [
+                        "funnel-field"
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "TextField",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(false);
+            expect(result.violation.message).toBe("No funnel fields allowed");
+        });
+        it("should block a nested descendant via ancestor's descendantConstraints", ()=>{
+            const step = makeElement("step-1", "Step");
+            const container = makeElement("container-1", "Container", {
+                id: "step-1",
+                slot: "children"
+            });
+            const doc = makeDocument([
+                step,
+                container
+            ]);
+            const components = {
+                Step: makeManifest("Step", {
+                    descendantConstraints: [
+                        (ctx)=>{
+                            if (ctx.hasTag("funnel-field")) return ctx.block("No funnel fields in this step");
+                        }
+                    ]
+                }),
+                Container: makeManifest("Container"),
+                TextField: makeManifest("TextField", {
+                    tags: [
+                        "funnel-field"
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "TextField",
+                parentId: "container-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(false);
+            expect(result.violation.message).toBe("No funnel fields in this step");
+        });
+        it("should allow when descendantConstraints pass", ()=>{
+            const step = makeElement("step-1", "Step");
+            const doc = makeDocument([
+                step
+            ]);
+            const components = {
+                Step: makeManifest("Step", {
+                    descendantConstraints: [
+                        (ctx)=>{
+                            if (ctx.hasTag("funnel-field")) return ctx.block("Blocked");
+                        }
+                    ]
+                }),
+                Button: makeManifest("Button")
+            };
+            const result = evaluateConstraints({
+                componentName: "Button",
+                parentId: "step-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(true);
+        });
+        it("should not run parent's descendantConstraints for unrelated ancestors", ()=>{
+            const page = makeElement("page", "Page");
+            const step = makeElement("step-1", "Step", {
+                id: "page",
+                slot: "children"
+            });
+            const doc = makeDocument([
+                page,
+                step
+            ]);
+            const components = {
+                Page: makeManifest("Page", {
+                    descendantConstraints: [
+                        (ctx)=>ctx.block("Page blocks everything")
+                    ]
+                }),
+                Step: makeManifest("Step"),
+                Button: makeManifest("Button")
+            };
+            const result = evaluateConstraints({
+                componentName: "Button",
+                parentId: "step-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.allowed).toBe(false);
+            expect(result.violation.message).toBe("Page blocks everything");
+        });
+        it("should evaluate component constraints before descendantConstraints", ()=>{
+            const parent = makeElement("parent-1", "Step");
+            const doc = makeDocument([
+                parent
+            ]);
+            const components = {
+                Step: makeManifest("Step", {
+                    descendantConstraints: [
+                        (ctx)=>ctx.block("descendant constraint")
+                    ]
+                }),
+                Widget: makeManifest("Widget", {
+                    constraints: [
+                        (ctx)=>ctx.block("component constraint")
+                    ]
+                })
+            };
+            const result = evaluateConstraints({
+                componentName: "Widget",
+                parentId: "parent-1",
+                slot: "children",
+                document: doc,
+                components
+            });
+            expect(result.violation.message).toBe("component constraint");
+        });
+    });
+});
+describe("evaluateDeleteConstraint", ()=>{
+    it("should allow when canDelete is undefined", ()=>{
+        const el = makeElement("el-1", "Widget", {
+            id: "root",
+            slot: "children"
+        });
+        const root = makeElement("root", "Page");
+        const doc = makeDocument([
+            root,
+            el
+        ]);
+        const components = {
+            Page: makeManifest("Page"),
+            Widget: makeManifest("Widget")
+        };
+        const result = evaluateDeleteConstraint({
+            elementId: "el-1",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+    });
+    it("should allow when canDelete is true", ()=>{
+        const el = makeElement("el-1", "Widget", {
+            id: "root",
+            slot: "children"
+        });
+        const root = makeElement("root", "Page");
+        const doc = makeDocument([
+            root,
+            el
+        ]);
+        const components = {
+            Page: makeManifest("Page"),
+            Widget: makeManifest("Widget", {
+                canDelete: true
+            })
+        };
+        const result = evaluateDeleteConstraint({
+            elementId: "el-1",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+    });
+    it("should block when canDelete is false", ()=>{
+        const el = makeElement("el-1", "GridColumn", {
+            id: "root",
+            slot: "children"
+        });
+        const root = makeElement("root", "Grid");
+        const doc = makeDocument([
+            root,
+            el
+        ]);
+        const components = {
+            Grid: makeManifest("Grid"),
+            GridColumn: makeManifest("GridColumn", {
+                canDelete: false
+            })
+        };
+        const result = evaluateDeleteConstraint({
+            elementId: "el-1",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("GridColumn cannot be deleted.");
+    });
+    it("should allow when canDelete check returns true", ()=>{
+        const funnel = makeElement("funnel", "Funnel");
+        const step1 = makeElement("step-1", "Step", {
+            id: "funnel",
+            slot: "steps/0/step"
+        });
+        const step2 = makeElement("step-2", "Step", {
+            id: "funnel",
+            slot: "steps/1/step"
+        });
+        const step3 = makeElement("step-3", "Step", {
+            id: "funnel",
+            slot: "steps/2/step"
+        });
+        const doc = makeDocument([
+            funnel,
+            step1,
+            step2,
+            step3
+        ], {
+            funnel: {
+                inputs: {
+                    "steps/0/step": {
+                        id: "s0",
+                        type: "slot",
+                        static: "step-1"
+                    },
+                    "steps/1/step": {
+                        id: "s1",
+                        type: "slot",
+                        static: "step-2"
+                    },
+                    "steps/2/step": {
+                        id: "s2",
+                        type: "slot",
+                        static: "step-3"
+                    }
+                }
+            }
+        });
+        const components = {
+            Funnel: makeManifest("Funnel"),
+            Step: makeManifest("Step", {
+                canDelete: (ctx)=>{
+                    if (!(ctx.countInstances("Step") > 2)) return ctx.block("Blocked");
+                }
+            })
+        };
+        const result = evaluateDeleteConstraint({
+            elementId: "step-2",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+    });
+    it("should block when canDelete check returns false", ()=>{
+        const funnel = makeElement("funnel", "Funnel");
+        const step1 = makeElement("step-1", "Step", {
+            id: "funnel",
+            slot: "steps/0/step"
+        });
+        const step2 = makeElement("step-2", "Step", {
+            id: "funnel",
+            slot: "steps/1/step"
+        });
+        const doc = makeDocument([
+            funnel,
+            step1,
+            step2
+        ], {
+            funnel: {
+                inputs: {
+                    "steps/0/step": {
+                        id: "s0",
+                        type: "slot",
+                        static: "step-1"
+                    },
+                    "steps/1/step": {
+                        id: "s1",
+                        type: "slot",
+                        static: "step-2"
+                    }
+                }
+            }
+        });
+        const components = {
+            Funnel: makeManifest("Funnel"),
+            Step: makeManifest("Step", {
+                canDelete: (ctx)=>{
+                    if (!(ctx.countInstances("Step") > 2)) return ctx.block("Need at least 2 steps");
+                }
+            })
+        };
+        const result = evaluateDeleteConstraint({
+            elementId: "step-1",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("Need at least 2 steps");
+    });
+    it("should use thrown error message as violation message", ()=>{
+        const root = makeElement("root", "Page");
+        const el = makeElement("el-1", "Widget", {
+            id: "root",
+            slot: "children"
+        });
+        const doc = makeDocument([
+            root,
+            el
+        ]);
+        const components = {
+            Page: makeManifest("Page"),
+            Widget: makeManifest("Widget", {
+                canDelete: ()=>{
+                    throw new Error("Cannot delete this widget right now");
+                }
+            })
+        };
+        const result = evaluateDeleteConstraint({
+            elementId: "el-1",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(false);
+        expect(result.violation.message).toBe("Cannot delete this widget right now");
+    });
+    it("should provide correct context to the check function", ()=>{
+        const root = makeElement("root", "Funnel");
+        const step = makeElement("step-1", "Step", {
+            id: "root",
+            slot: "steps/0/step"
+        });
+        const doc = makeDocument([
+            root,
+            step
+        ], {
+            root: {
+                inputs: {
+                    "steps/0/step": {
+                        id: "s0",
+                        type: "slot",
+                        static: "step-1"
+                    },
+                    "steps/1/step": {
+                        id: "s1",
+                        type: "slot",
+                        static: "step-2"
+                    }
+                }
+            }
+        });
+        let capturedCtx;
+        const components = {
+            Funnel: makeManifest("Funnel"),
+            Step: makeManifest("Step", {
+                tags: [
+                    "funnel-step"
+                ],
+                canDelete: (ctx)=>{
+                    capturedCtx = ctx;
+                }
+            })
+        };
+        evaluateDeleteConstraint({
+            elementId: "step-1",
+            document: doc,
+            components
+        });
+        expect(capturedCtx).toBeDefined();
+        expect(capturedCtx.component.name).toBe("Step");
+        expect(capturedCtx.component.tags).toEqual([
+            "funnel-step"
+        ]);
+        expect(capturedCtx.parent.name).toBe("Funnel");
+        expect(capturedCtx.slot).toBe("steps/0/step");
+        expect(capturedCtx.isChildOf("Funnel")).toBe(true);
+        expect(capturedCtx.hasTag("funnel-step")).toBe(true);
+    });
+    it("should allow when element is not found", ()=>{
+        const doc = makeDocument([]);
+        const components = {};
+        const result = evaluateDeleteConstraint({
+            elementId: "nonexistent",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+    });
+    it("should allow when manifest is not found", ()=>{
+        const el = makeElement("el-1", "Unknown");
+        const doc = makeDocument([
+            el
+        ]);
+        const components = {};
+        const result = evaluateDeleteConstraint({
+            elementId: "el-1",
+            document: doc,
+            components
+        });
+        expect(result.allowed).toBe(true);
+    });
+});
+
+//# sourceMappingURL=ConstraintEvaluator.test.js.map