@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/child-contract-compose.js

@@ -0,0 +1,140 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * The compose-time half of the drop/render agreement (AGL-1389).
+ *
+ * A guard that only inspects a component function misses this entirely, and
+ * the miss is not hypothetical: `reusableInstance` renders `{children}` — it
+ * looks perfect — and destroyed every node dropped into it anyway, because
+ * {@link composeReusableComponentNodes} REPLACES the instance's child list
+ * with the grafted definition subtree before any renderer sees the tree
+ * (`nodes: [prefixId(definition.rootId)]`). Reading the component alone would
+ * have cleared it.
+ *
+ * So the child a node holds is checked where every render surface gets its
+ * tree from: after compose. Pure data in, pure data out — no React, no
+ * providers, no canvas singleton, and therefore no exemptions.
+ */ import { NODE_ROOT_ID } from "../canvas-manager/canvas-manager.js";
+import { composeLayoutAndScreenNodes } from "./compose-layout-nodes.js";
+import { composeReusableComponentNodes } from "./compose-reusable-components.js";
+const SUBJECT_ID = 'child-contract-subject';
+const SENTINEL_ID = 'child-contract-sentinel';
+const DEFINITION_ID = 'child-contract-definition';
+/**
+ * A minimal screen: root → one node of `componentId` → one sentinel child.
+ *
+ * `props.refId` is set on every subject, not only on instances: it is what
+ * makes the reusable graft actually fire, and a probe that quietly skipped
+ * the expansion would report "children survive" about a code path it never
+ * entered.
+ */ function probeScreen(componentId) {
+    return {
+        [NODE_ROOT_ID]: {
+            $id: NODE_ROOT_ID,
+            parentId: null,
+            componentId: 'div',
+            nodes: [
+                SUBJECT_ID
+            ]
+        },
+        [SUBJECT_ID]: {
+            $id: SUBJECT_ID,
+            parentId: NODE_ROOT_ID,
+            componentId,
+            props: {
+                refId: DEFINITION_ID
+            },
+            nodes: [
+                SENTINEL_ID
+            ]
+        },
+        [SENTINEL_ID]: {
+            $id: SENTINEL_ID,
+            parentId: SUBJECT_ID,
+            componentId: 'muiTypography',
+            props: {
+                children: 'sentinel'
+            },
+            nodes: []
+        }
+    };
+}
+/** A one-node definition for the graft to resolve `refId` against. */ function probeDefinition() {
+    return {
+        rootId: 'def-root',
+        nodes: {
+            'def-root': {
+                $id: 'def-root',
+                parentId: null,
+                componentId: 'muiStack',
+                nodes: []
+            }
+        }
+    };
+}
+/** A layout whose slot the screen's top-level nodes are grafted into. */ function probeLayout() {
+    return {
+        [NODE_ROOT_ID]: {
+            $id: NODE_ROOT_ID,
+            parentId: null,
+            componentId: 'div',
+            nodes: [
+                'slot'
+            ]
+        },
+        slot: {
+            $id: 'slot',
+            parentId: NODE_ROOT_ID,
+            componentId: 'layoutSlot',
+            nodes: []
+        }
+    };
+}
+/** Whether the sentinel is still in the map AND still the subject's child. */ function sentinelSurvives(composed) {
+    var _composed_SUBJECT_ID;
+    if (!(composed == null ? void 0 : composed[SENTINEL_ID])) return false;
+    const children = (_composed_SUBJECT_ID = composed[SUBJECT_ID]) == null ? void 0 : _composed_SUBJECT_ID.nodes;
+    return Array.isArray(children) && children.includes(SENTINEL_ID);
+}
+/**
+ * Every component id whose children a compose pass destroys, as
+ * reviewer-facing lines (empty = the contract holds).
+ *
+ * Call it with the ids the editor accepts a drop into
+ * (`listAcceptingComponentIds`), which is exactly the set for which "the
+ * author put a node here" must survive to a render surface. Ids the editor
+ * already refuses are not probed — a component that cannot receive a drop is
+ * free to rewrite its own child list, which is what `reusableInstance` and
+ * `layoutSlot` do for a living.
+ */ export function auditComposeChildSurvival(acceptingComponentIds) {
+    const problems = [];
+    for (const componentId of acceptingComponentIds){
+        if (!componentId) continue;
+        const grafted = composeReusableComponentNodes(probeScreen(componentId), {
+            [DEFINITION_ID]: probeDefinition()
+        });
+        if (!sentinelSurvives(grafted)) {
+            problems.push(`${componentId} accepts a drop, but composeReusableComponentNodes ` + 'destroys the node dropped into it — the author would see it in ' + 'the hierarchy and the published page would not have it. Declare ' + 'flags.dropping: FEATURE_FLAG.DISABLED, or stop rewriting its ' + 'child list (AGL-1389)');
+        }
+        const laidOut = composeLayoutAndScreenNodes(probeLayout(), probeScreen(componentId));
+        if (!sentinelSurvives(laidOut)) {
+            problems.push(`${componentId} accepts a drop, but composeLayoutAndScreenNodes ` + 'destroys the node dropped into it — the author would see it in ' + 'the hierarchy and the published page would not have it. Declare ' + 'flags.dropping: FEATURE_FLAG.DISABLED, or stop rewriting its ' + 'child list (AGL-1389)');
+        }
+    }
+    return problems.sort();
+}
+
+//# sourceMappingURL=child-contract-compose.js.map

package/src/lib/app-utils/child-contract-compose.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/child-contract-compose.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The compose-time half of the drop/render agreement (AGL-1389).\n *\n * A guard that only inspects a component function misses this entirely, and\n * the miss is not hypothetical: `reusableInstance` renders `{children}` — it\n * looks perfect — and destroyed every node dropped into it anyway, because\n * {@link composeReusableComponentNodes} REPLACES the instance's child list\n * with the grafted definition subtree before any renderer sees the tree\n * (`nodes: [prefixId(definition.rootId)]`). Reading the component alone would\n * have cleared it.\n *\n * So the child a node holds is checked where every render surface gets its\n * tree from: after compose. Pure data in, pure data out — no React, no\n * providers, no canvas singleton, and therefore no exemptions.\n */\n\nimport { NODE_ROOT_ID } from '../canvas-manager/canvas-manager'\nimport type { AglynNodeSchema, NodeId } from '../foundation'\nimport { composeLayoutAndScreenNodes } from './compose-layout-nodes'\nimport {\n  composeReusableComponentNodes,\n  type ReusableComponentTree,\n} from './compose-reusable-components'\n\nconst SUBJECT_ID = 'child-contract-subject'\nconst SENTINEL_ID = 'child-contract-sentinel'\nconst DEFINITION_ID = 'child-contract-definition'\n\ntype Nodes = Record<NodeId, AglynNodeSchema>\n\n/**\n * A minimal screen: root → one node of `componentId` → one sentinel child.\n *\n * `props.refId` is set on every subject, not only on instances: it is what\n * makes the reusable graft actually fire, and a probe that quietly skipped\n * the expansion would report \"children survive\" about a code path it never\n * entered.\n */\nfunction probeScreen(componentId: string): Nodes {\n  return {\n    [NODE_ROOT_ID]: {\n      $id: NODE_ROOT_ID,\n      parentId: null,\n      componentId: 'div',\n      nodes: [SUBJECT_ID],\n    },\n    [SUBJECT_ID]: {\n      $id: SUBJECT_ID,\n      parentId: NODE_ROOT_ID,\n      componentId,\n      props: { refId: DEFINITION_ID },\n      nodes: [SENTINEL_ID],\n    },\n    [SENTINEL_ID]: {\n      $id: SENTINEL_ID,\n      parentId: SUBJECT_ID,\n      componentId: 'muiTypography',\n      props: { children: 'sentinel' },\n      nodes: [],\n    },\n  } as unknown as Nodes\n}\n\n/** A one-node definition for the graft to resolve `refId` against. */\nfunction probeDefinition(): ReusableComponentTree {\n  return {\n    rootId: 'def-root',\n    nodes: {\n      'def-root': {\n        $id: 'def-root',\n        parentId: null,\n        componentId: 'muiStack',\n        nodes: [],\n      },\n    } as unknown as ReusableComponentTree['nodes'],\n  }\n}\n\n/** A layout whose slot the screen's top-level nodes are grafted into. */\nfunction probeLayout(): Nodes {\n  return {\n    [NODE_ROOT_ID]: {\n      $id: NODE_ROOT_ID,\n      parentId: null,\n      componentId: 'div',\n      nodes: ['slot'],\n    },\n    slot: {\n      $id: 'slot',\n      parentId: NODE_ROOT_ID,\n      componentId: 'layoutSlot',\n      nodes: [],\n    },\n  } as unknown as Nodes\n}\n\n/** Whether the sentinel is still in the map AND still the subject's child. */\nfunction sentinelSurvives(composed: Nodes): boolean {\n  if (!composed?.[SENTINEL_ID]) return false\n  const children = composed[SUBJECT_ID]?.nodes\n  return Array.isArray(children) && (children as NodeId[]).includes(SENTINEL_ID)\n}\n\n/**\n * Every component id whose children a compose pass destroys, as\n * reviewer-facing lines (empty = the contract holds).\n *\n * Call it with the ids the editor accepts a drop into\n * (`listAcceptingComponentIds`), which is exactly the set for which \"the\n * author put a node here\" must survive to a render surface. Ids the editor\n * already refuses are not probed — a component that cannot receive a drop is\n * free to rewrite its own child list, which is what `reusableInstance` and\n * `layoutSlot` do for a living.\n */\nexport function auditComposeChildSurvival(\n  acceptingComponentIds: readonly string[],\n): string[] {\n  const problems: string[] = []\n  for (const componentId of acceptingComponentIds) {\n    if (!componentId) continue\n\n    const grafted = composeReusableComponentNodes(probeScreen(componentId), {\n      [DEFINITION_ID]: probeDefinition(),\n    }) as Nodes\n    if (!sentinelSurvives(grafted)) {\n      problems.push(\n        `${componentId} accepts a drop, but composeReusableComponentNodes ` +\n          'destroys the node dropped into it — the author would see it in ' +\n          'the hierarchy and the published page would not have it. Declare ' +\n          'flags.dropping: FEATURE_FLAG.DISABLED, or stop rewriting its ' +\n          'child list (AGL-1389)',\n      )\n    }\n\n    const laidOut = composeLayoutAndScreenNodes(\n      probeLayout(),\n      probeScreen(componentId),\n    ) as Nodes\n    if (!sentinelSurvives(laidOut)) {\n      problems.push(\n        `${componentId} accepts a drop, but composeLayoutAndScreenNodes ` +\n          'destroys the node dropped into it — the author would see it in ' +\n          'the hierarchy and the published page would not have it. Declare ' +\n          'flags.dropping: FEATURE_FLAG.DISABLED, or stop rewriting its ' +\n          'child list (AGL-1389)',\n      )\n    }\n  }\n  return problems.sort()\n}\n"],"names":["NODE_ROOT_ID","composeLayoutAndScreenNodes","composeReusableComponentNodes","SUBJECT_ID","SENTINEL_ID","DEFINITION_ID","probeScreen","componentId","$id","parentId","nodes","props","refId","children","probeDefinition","rootId","probeLayout","slot","sentinelSurvives","composed","Array","isArray","includes","auditComposeChildSurvival","acceptingComponentIds","problems","grafted","push","laidOut","sort"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;CAcC,GAED,SAASA,YAAY,QAAQ,sCAAkC;AAE/D,SAASC,2BAA2B,QAAQ,4BAAwB;AACpE,SACEC,6BAA6B,QAExB,mCAA+B;AAEtC,MAAMC,aAAa;AACnB,MAAMC,cAAc;AACpB,MAAMC,gBAAgB;AAItB;;;;;;;CAOC,GACD,SAASC,YAAYC,WAAmB;IACtC,OAAO;QACL,CAACP,aAAa,EAAE;YACdQ,KAAKR;YACLS,UAAU;YACVF,aAAa;YACbG,OAAO;gBAACP;aAAW;QACrB;QACA,CAACA,WAAW,EAAE;YACZK,KAAKL;YACLM,UAAUT;YACVO;YACAI,OAAO;gBAAEC,OAAOP;YAAc;YAC9BK,OAAO;gBAACN;aAAY;QACtB;QACA,CAACA,YAAY,EAAE;YACbI,KAAKJ;YACLK,UAAUN;YACVI,aAAa;YACbI,OAAO;gBAAEE,UAAU;YAAW;YAC9BH,OAAO,EAAE;QACX;IACF;AACF;AAEA,oEAAoE,GACpE,SAASI;IACP,OAAO;QACLC,QAAQ;QACRL,OAAO;YACL,YAAY;gBACVF,KAAK;gBACLC,UAAU;gBACVF,aAAa;gBACbG,OAAO,EAAE;YACX;QACF;IACF;AACF;AAEA,uEAAuE,GACvE,SAASM;IACP,OAAO;QACL,CAAChB,aAAa,EAAE;YACdQ,KAAKR;YACLS,UAAU;YACVF,aAAa;YACbG,OAAO;gBAAC;aAAO;QACjB;QACAO,MAAM;YACJT,KAAK;YACLC,UAAUT;YACVO,aAAa;YACbG,OAAO,EAAE;QACX;IACF;AACF;AAEA,4EAA4E,GAC5E,SAASQ,iBAAiBC,QAAe;QAEtBA;IADjB,IAAI,EAACA,4BAAAA,QAAU,CAACf,YAAY,GAAE,OAAO;IACrC,MAAMS,YAAWM,uBAAAA,QAAQ,CAAChB,WAAW,qBAApBgB,qBAAsBT,KAAK;IAC5C,OAAOU,MAAMC,OAAO,CAACR,aAAa,AAACA,SAAsBS,QAAQ,CAAClB;AACpE;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASmB,0BACdC,qBAAwC;IAExC,MAAMC,WAAqB,EAAE;IAC7B,KAAK,MAAMlB,eAAeiB,sBAAuB;QAC/C,IAAI,CAACjB,aAAa;QAElB,MAAMmB,UAAUxB,8BAA8BI,YAAYC,cAAc;YACtE,CAACF,cAAc,EAAES;QACnB;QACA,IAAI,CAACI,iBAAiBQ,UAAU;YAC9BD,SAASE,IAAI,CACX,GAAGpB,YAAY,mDAAmD,CAAC,GACjE,oEACA,qEACA,kEACA;QAEN;QAEA,MAAMqB,UAAU3B,4BACde,eACAV,YAAYC;QAEd,IAAI,CAACW,iBAAiBU,UAAU;YAC9BH,SAASE,IAAI,CACX,GAAGpB,YAAY,iDAAiD,CAAC,GAC/D,oEACA,qEACA,kEACA;QAEN;IACF;IACA,OAAOkB,SAASI,IAAI;AACtB"}

package/src/lib/app-utils/child-contract.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The drop/render agreement (AGL-1389).
+ *
+ * A component that accepts a drop in the hierarchy and discards the node at
+ * render is silent data loss: the author sees the node in the tree, the
+ * published page does not have it, and nothing warns — so the work reads as
+ * *never done* rather than broken. Three /press screenshots shipped in a page
+ * payload for weeks that way (AGL-1388).
+ *
+ * That was found by reading all 82 registered schemas by hand, one at a time.
+ * This module is the repeatable half: the predicate the editor actually gates
+ * drops on, plus an audit that turns "someone added a component and never
+ * thought about children" into a red test.
+ *
+ * Deliberately NOT a render sweep. Rendering every schema with a sentinel
+ * child fails for components that legitimately hide children behind state
+ * (a collapsed Accordion, a closed Drawer, a `lazyPanels` TabPanel) and for
+ * every one needing a provider or the canvas singleton — so it would need an
+ * exemption list, and an exemption list that grows silently is worth less
+ * than no test. See {@link auditChildContract} for what is enforced instead.
+ */
+import { FEATURE_FLAG } from '../foundation/constants/shared';
+/**
+ * The slice of a component schema this contract reads. Structural on purpose:
+ * `ComponentSchema` (types/nodes) and `AglynComponentSchema` (foundation) are
+ * two spellings of the same thing and bundles are typed with both.
+ */
+export interface ChildContractSchema {
+    $id?: string;
+    displayName?: string;
+    restrictChildren?: unknown;
+    flags?: {
+        dropping?: FEATURE_FLAG;
+        selfClosing?: FEATURE_FLAG;
+        textEditable?: FEATURE_FLAG;
+    };
+}
+/** One registry entry — matches `MUI_BUNDLE` / `FeatureBundleEntry`. */
+export interface ChildContractEntry {
+    schema: ChildContractSchema;
+}
+/**
+ * True only when a feature flag is explicitly present and carries the ENABLED
+ * bit. An absent (undefined) flag reads as false: components that declare no
+ * flags at all (Stack, Section, the document root) must not be mistaken for
+ * self-closing leaves.
+ */
+export declare function isLeafFlagEnabled(flag?: FEATURE_FLAG): boolean;
+/**
+ * The mirror, for the flags whose interesting value is the switched-OFF one.
+ * An absent flag reads as false, so a component that declares no flags keeps
+ * the permissive default.
+ */
+export declare function isFlagDisabled(flag?: FEATURE_FLAG): boolean;
+/**
+ * Whether the editor will let a node be dropped into a node of this component
+ * — the ONE rule every author-facing entry point shares (the Insert menu and
+ * paste via `resolveInsertTarget`, canvas drag-and-drop via the dnd manager's
+ * `computedDrop`, and the drop indicator), read through
+ * `CanvasManager.nodeAcceptsChildren`.
+ *
+ * Four ways a schema declares it has nowhere to put a dropped node:
+ *
+ * - `flags.selfClosing` — an image, an icon, a divider.
+ * - `flags.textEditable` — the component renders `children` as editable text,
+ *   so an element dropped in would be destroyed by the next text edit.
+ * - `flags.dropping: DISABLED` — neither of the above, but still no slot
+ *   (AGL-1388): Markdown renders its parsed `content` prop and nothing else;
+ *   a Reusable Component instance has its child list REPLACED by the grafted
+ *   definition at compose time; List Item Text hands `children` to MUI, which
+ *   reads it only as a fallback for a missing `primary`.
+ * - an empty `restrictChildren` allowlist — see above.
+ *
+ * Anything else accepts children, which is why the audit below exists: the
+ * permissive answer is the DEFAULT, so a component nobody thought about is
+ * indistinguishable from a container until something asks.
+ *
+ * An unregistered / missing schema accepts children, matching the canvas.
+ */
+export declare function schemaAcceptsChildren(schema: ChildContractSchema | null | undefined): boolean;
+/**
+ * A bundle's declared containers: the component ids whose author has
+ * confirmed the component renders the nodes dropped into it.
+ *
+ * Not an exemption list — the inverse. Exemptions are the entries a guard
+ * agrees to skip, so they accumulate quietly and the guard shrinks. This list
+ * is the set the guard is ABOUT: a new component defaults to accepting
+ * children, so it lands here or the test is red, and the only way to make it
+ * green is to answer the question ("does it render `children`?") one way or
+ * the other. Nothing can be added by accident.
+ */
+export type DeclaredContainers = readonly string[];
+/**
+ * Every disagreement between a bundle's schemas and its declared container
+ * list, as reviewer-facing lines (empty = the contract holds).
+ *
+ * Both directions matter:
+ *
+ * - An undeclared container is the AGL-1388 shape arriving again — a
+ *   component the editor will accept a drop into that nobody has confirmed
+ *   renders one.
+ * - A declared id that no longer accepts a drop, or is no longer registered,
+ *   is a stale entry. Left alone the list would slowly become a wish, and a
+ *   guard checked against a wish passes over anything.
+ *
+ * Returns strings rather than throwing so the caller is a one-line
+ * `expect(...).toEqual([])` whose failure output names every offender at once
+ * — the whole point being that the next person does not repeat the 82-schema
+ * hand audit.
+ */
+export declare function auditChildContract(entries: readonly ChildContractEntry[], declared: DeclaredContainers): string[];
+/** The ids in a bundle the editor will accept a drop into, sorted. */
+export declare function listAcceptingComponentIds(entries: readonly ChildContractEntry[]): string[];

package/src/lib/app-utils/child-contract.js

@@ -0,0 +1,153 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * The drop/render agreement (AGL-1389).
+ *
+ * A component that accepts a drop in the hierarchy and discards the node at
+ * render is silent data loss: the author sees the node in the tree, the
+ * published page does not have it, and nothing warns — so the work reads as
+ * *never done* rather than broken. Three /press screenshots shipped in a page
+ * payload for weeks that way (AGL-1388).
+ *
+ * That was found by reading all 82 registered schemas by hand, one at a time.
+ * This module is the repeatable half: the predicate the editor actually gates
+ * drops on, plus an audit that turns "someone added a component and never
+ * thought about children" into a red test.
+ *
+ * Deliberately NOT a render sweep. Rendering every schema with a sentinel
+ * child fails for components that legitimately hide children behind state
+ * (a collapsed Accordion, a closed Drawer, a `lazyPanels` TabPanel) and for
+ * every one needing a provider or the canvas singleton — so it would need an
+ * exemption list, and an exemption list that grows silently is worth less
+ * than no test. See {@link auditChildContract} for what is enforced instead.
+ */ import { FEATURE_FLAG } from "../foundation/constants/shared.js";
+/**
+ * True only when a feature flag is explicitly present and carries the ENABLED
+ * bit. An absent (undefined) flag reads as false: components that declare no
+ * flags at all (Stack, Section, the document root) must not be mistaken for
+ * self-closing leaves.
+ */ export function isLeafFlagEnabled(flag) {
+    return typeof flag === 'number' && (flag & FEATURE_FLAG.ENABLED) !== 0;
+}
+/**
+ * The mirror, for the flags whose interesting value is the switched-OFF one.
+ * An absent flag reads as false, so a component that declares no flags keeps
+ * the permissive default.
+ */ export function isFlagDisabled(flag) {
+    return typeof flag === 'number' && (flag & FEATURE_FLAG.DISABLED) !== 0;
+}
+/**
+ * A `restrictChildren` that allows NOTHING — `[LIMIT_TO, { components: [] }]`,
+ * the Layout Slot's spelling of "my children come from somewhere else".
+ *
+ * Read here as a fourth way to say "no canvas child slot", alongside the three
+ * flags: the dnd manager's `confirmValidLinealRelationship` already refuses
+ * every candidate against an empty allowlist, so a schema that says this and
+ * nothing else was already unreachable by drop — the hierarchy just hadn't
+ * been told. Deliberately narrow: an empty DISALLOW list forbids nothing, and
+ * an allowlist naming plugins (rather than components) still admits those.
+ */ function restrictsChildrenToNothing(restrict) {
+    if (!Array.isArray(restrict) || restrict.length < 2) return false;
+    const [directive, definition] = restrict;
+    if (directive !== 'limitedTo') return false;
+    if (Array.isArray(definition)) return definition.length === 0;
+    if (!definition || typeof definition !== 'object') return false;
+    const { components, plugins } = definition;
+    if (Array.isArray(plugins) && plugins.length > 0) return false;
+    return Array.isArray(components) && components.length === 0;
+}
+/**
+ * Whether the editor will let a node be dropped into a node of this component
+ * — the ONE rule every author-facing entry point shares (the Insert menu and
+ * paste via `resolveInsertTarget`, canvas drag-and-drop via the dnd manager's
+ * `computedDrop`, and the drop indicator), read through
+ * `CanvasManager.nodeAcceptsChildren`.
+ *
+ * Four ways a schema declares it has nowhere to put a dropped node:
+ *
+ * - `flags.selfClosing` — an image, an icon, a divider.
+ * - `flags.textEditable` — the component renders `children` as editable text,
+ *   so an element dropped in would be destroyed by the next text edit.
+ * - `flags.dropping: DISABLED` — neither of the above, but still no slot
+ *   (AGL-1388): Markdown renders its parsed `content` prop and nothing else;
+ *   a Reusable Component instance has its child list REPLACED by the grafted
+ *   definition at compose time; List Item Text hands `children` to MUI, which
+ *   reads it only as a fallback for a missing `primary`.
+ * - an empty `restrictChildren` allowlist — see above.
+ *
+ * Anything else accepts children, which is why the audit below exists: the
+ * permissive answer is the DEFAULT, so a component nobody thought about is
+ * indistinguishable from a container until something asks.
+ *
+ * An unregistered / missing schema accepts children, matching the canvas.
+ */ export function schemaAcceptsChildren(schema) {
+    if (!schema) return true;
+    const flags = schema.flags;
+    if (isFlagDisabled(flags == null ? void 0 : flags.dropping)) return false;
+    if (isLeafFlagEnabled(flags == null ? void 0 : flags.selfClosing)) return false;
+    if (isLeafFlagEnabled(flags == null ? void 0 : flags.textEditable)) return false;
+    return !restrictsChildrenToNothing(schema.restrictChildren);
+}
+/**
+ * Every disagreement between a bundle's schemas and its declared container
+ * list, as reviewer-facing lines (empty = the contract holds).
+ *
+ * Both directions matter:
+ *
+ * - An undeclared container is the AGL-1388 shape arriving again — a
+ *   component the editor will accept a drop into that nobody has confirmed
+ *   renders one.
+ * - A declared id that no longer accepts a drop, or is no longer registered,
+ *   is a stale entry. Left alone the list would slowly become a wish, and a
+ *   guard checked against a wish passes over anything.
+ *
+ * Returns strings rather than throwing so the caller is a one-line
+ * `expect(...).toEqual([])` whose failure output names every offender at once
+ * — the whole point being that the next person does not repeat the 82-schema
+ * hand audit.
+ */ export function auditChildContract(entries, declared) {
+    const problems = [];
+    const declaredSet = new Set(declared);
+    const registered = new Set();
+    for (const entry of entries){
+        const schema = entry == null ? void 0 : entry.schema;
+        const id = schema == null ? void 0 : schema.$id;
+        if (!id) {
+            var _ref;
+            problems.push(`a schema in this bundle has no $id (${(_ref = schema == null ? void 0 : schema.displayName) != null ? _ref : 'unnamed'}) — it cannot be held to the drop/render agreement`);
+            continue;
+        }
+        registered.add(id);
+        const accepts = schemaAcceptsChildren(schema);
+        if (accepts && !declaredSet.has(id)) {
+            problems.push(`${id} accepts a drop but is not a declared container — either it ` + 'renders its children (add it to the list) or it does not, and ' + 'then it must SAY so: flags.selfClosing, flags.textEditable, ' + 'flags.dropping: FEATURE_FLAG.DISABLED, or an empty ' + 'restrictChildren allowlist (AGL-1389)');
+        }
+        if (!accepts && declaredSet.has(id)) {
+            problems.push(`${id} is a declared container but the editor now refuses drops ` + 'into it — drop it from the list, or remove whatever flag closed ' + 'it (AGL-1389)');
+        }
+    }
+    for (const id of declaredSet){
+        if (!registered.has(id)) {
+            problems.push(`${id} is a declared container but is not registered in this ` + 'bundle — remove the stale entry (AGL-1389)');
+        }
+    }
+    return problems.sort();
+}
+/** The ids in a bundle the editor will accept a drop into, sorted. */ export function listAcceptingComponentIds(entries) {
+    return entries.filter((entry)=>schemaAcceptsChildren(entry == null ? void 0 : entry.schema)).map((entry)=>entry.schema.$id).filter(Boolean).sort();
+}
+
+//# sourceMappingURL=child-contract.js.map

package/src/lib/app-utils/child-contract.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/child-contract.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The drop/render agreement (AGL-1389).\n *\n * A component that accepts a drop in the hierarchy and discards the node at\n * render is silent data loss: the author sees the node in the tree, the\n * published page does not have it, and nothing warns — so the work reads as\n * *never done* rather than broken. Three /press screenshots shipped in a page\n * payload for weeks that way (AGL-1388).\n *\n * That was found by reading all 82 registered schemas by hand, one at a time.\n * This module is the repeatable half: the predicate the editor actually gates\n * drops on, plus an audit that turns \"someone added a component and never\n * thought about children\" into a red test.\n *\n * Deliberately NOT a render sweep. Rendering every schema with a sentinel\n * child fails for components that legitimately hide children behind state\n * (a collapsed Accordion, a closed Drawer, a `lazyPanels` TabPanel) and for\n * every one needing a provider or the canvas singleton — so it would need an\n * exemption list, and an exemption list that grows silently is worth less\n * than no test. See {@link auditChildContract} for what is enforced instead.\n */\n\nimport { FEATURE_FLAG } from '../foundation/constants/shared'\n\n/**\n * The slice of a component schema this contract reads. Structural on purpose:\n * `ComponentSchema` (types/nodes) and `AglynComponentSchema` (foundation) are\n * two spellings of the same thing and bundles are typed with both.\n */\nexport interface ChildContractSchema {\n  $id?: string\n  displayName?: string\n  restrictChildren?: unknown\n  flags?: {\n    dropping?: FEATURE_FLAG\n    selfClosing?: FEATURE_FLAG\n    textEditable?: FEATURE_FLAG\n  }\n}\n\n/** One registry entry — matches `MUI_BUNDLE` / `FeatureBundleEntry`. */\nexport interface ChildContractEntry {\n  schema: ChildContractSchema\n}\n\n/**\n * True only when a feature flag is explicitly present and carries the ENABLED\n * bit. An absent (undefined) flag reads as false: components that declare no\n * flags at all (Stack, Section, the document root) must not be mistaken for\n * self-closing leaves.\n */\nexport function isLeafFlagEnabled(flag?: FEATURE_FLAG): boolean {\n  return typeof flag === 'number' && (flag & FEATURE_FLAG.ENABLED) !== 0\n}\n\n/**\n * The mirror, for the flags whose interesting value is the switched-OFF one.\n * An absent flag reads as false, so a component that declares no flags keeps\n * the permissive default.\n */\nexport function isFlagDisabled(flag?: FEATURE_FLAG): boolean {\n  return typeof flag === 'number' && (flag & FEATURE_FLAG.DISABLED) !== 0\n}\n\n/**\n * A `restrictChildren` that allows NOTHING — `[LIMIT_TO, { components: [] }]`,\n * the Layout Slot's spelling of \"my children come from somewhere else\".\n *\n * Read here as a fourth way to say \"no canvas child slot\", alongside the three\n * flags: the dnd manager's `confirmValidLinealRelationship` already refuses\n * every candidate against an empty allowlist, so a schema that says this and\n * nothing else was already unreachable by drop — the hierarchy just hadn't\n * been told. Deliberately narrow: an empty DISALLOW list forbids nothing, and\n * an allowlist naming plugins (rather than components) still admits those.\n */\nfunction restrictsChildrenToNothing(restrict: unknown): boolean {\n  if (!Array.isArray(restrict) || restrict.length < 2) return false\n  const [directive, definition] = restrict as [unknown, unknown]\n  if (directive !== 'limitedTo') return false\n  if (Array.isArray(definition)) return definition.length === 0\n  if (!definition || typeof definition !== 'object') return false\n  const { components, plugins } = definition as {\n    components?: unknown\n    plugins?: unknown\n  }\n  if (Array.isArray(plugins) && plugins.length > 0) return false\n  return Array.isArray(components) && components.length === 0\n}\n\n/**\n * Whether the editor will let a node be dropped into a node of this component\n * — the ONE rule every author-facing entry point shares (the Insert menu and\n * paste via `resolveInsertTarget`, canvas drag-and-drop via the dnd manager's\n * `computedDrop`, and the drop indicator), read through\n * `CanvasManager.nodeAcceptsChildren`.\n *\n * Four ways a schema declares it has nowhere to put a dropped node:\n *\n * - `flags.selfClosing` — an image, an icon, a divider.\n * - `flags.textEditable` — the component renders `children` as editable text,\n *   so an element dropped in would be destroyed by the next text edit.\n * - `flags.dropping: DISABLED` — neither of the above, but still no slot\n *   (AGL-1388): Markdown renders its parsed `content` prop and nothing else;\n *   a Reusable Component instance has its child list REPLACED by the grafted\n *   definition at compose time; List Item Text hands `children` to MUI, which\n *   reads it only as a fallback for a missing `primary`.\n * - an empty `restrictChildren` allowlist — see above.\n *\n * Anything else accepts children, which is why the audit below exists: the\n * permissive answer is the DEFAULT, so a component nobody thought about is\n * indistinguishable from a container until something asks.\n *\n * An unregistered / missing schema accepts children, matching the canvas.\n */\nexport function schemaAcceptsChildren(\n  schema: ChildContractSchema | null | undefined,\n): boolean {\n  if (!schema) return true\n  const flags = schema.flags\n  if (isFlagDisabled(flags?.dropping)) return false\n  if (isLeafFlagEnabled(flags?.selfClosing)) return false\n  if (isLeafFlagEnabled(flags?.textEditable)) return false\n  return !restrictsChildrenToNothing(schema.restrictChildren)\n}\n\n/**\n * A bundle's declared containers: the component ids whose author has\n * confirmed the component renders the nodes dropped into it.\n *\n * Not an exemption list — the inverse. Exemptions are the entries a guard\n * agrees to skip, so they accumulate quietly and the guard shrinks. This list\n * is the set the guard is ABOUT: a new component defaults to accepting\n * children, so it lands here or the test is red, and the only way to make it\n * green is to answer the question (\"does it render `children`?\") one way or\n * the other. Nothing can be added by accident.\n */\nexport type DeclaredContainers = readonly string[]\n\n/**\n * Every disagreement between a bundle's schemas and its declared container\n * list, as reviewer-facing lines (empty = the contract holds).\n *\n * Both directions matter:\n *\n * - An undeclared container is the AGL-1388 shape arriving again — a\n *   component the editor will accept a drop into that nobody has confirmed\n *   renders one.\n * - A declared id that no longer accepts a drop, or is no longer registered,\n *   is a stale entry. Left alone the list would slowly become a wish, and a\n *   guard checked against a wish passes over anything.\n *\n * Returns strings rather than throwing so the caller is a one-line\n * `expect(...).toEqual([])` whose failure output names every offender at once\n * — the whole point being that the next person does not repeat the 82-schema\n * hand audit.\n */\nexport function auditChildContract(\n  entries: readonly ChildContractEntry[],\n  declared: DeclaredContainers,\n): string[] {\n  const problems: string[] = []\n  const declaredSet = new Set(declared)\n  const registered = new Set<string>()\n\n  for (const entry of entries) {\n    const schema = entry?.schema\n    const id = schema?.$id\n    if (!id) {\n      problems.push(\n        `a schema in this bundle has no $id (${\n          schema?.displayName ?? 'unnamed'\n        }) — it cannot be held to the drop/render agreement`,\n      )\n      continue\n    }\n    registered.add(id)\n    const accepts = schemaAcceptsChildren(schema)\n    if (accepts && !declaredSet.has(id)) {\n      problems.push(\n        `${id} accepts a drop but is not a declared container — either it ` +\n          'renders its children (add it to the list) or it does not, and ' +\n          'then it must SAY so: flags.selfClosing, flags.textEditable, ' +\n          'flags.dropping: FEATURE_FLAG.DISABLED, or an empty ' +\n          'restrictChildren allowlist (AGL-1389)',\n      )\n    }\n    if (!accepts && declaredSet.has(id)) {\n      problems.push(\n        `${id} is a declared container but the editor now refuses drops ` +\n          'into it — drop it from the list, or remove whatever flag closed ' +\n          'it (AGL-1389)',\n      )\n    }\n  }\n\n  for (const id of declaredSet) {\n    if (!registered.has(id)) {\n      problems.push(\n        `${id} is a declared container but is not registered in this ` +\n          'bundle — remove the stale entry (AGL-1389)',\n      )\n    }\n  }\n\n  return problems.sort()\n}\n\n/** The ids in a bundle the editor will accept a drop into, sorted. */\nexport function listAcceptingComponentIds(\n  entries: readonly ChildContractEntry[],\n): string[] {\n  return entries\n    .filter((entry) => schemaAcceptsChildren(entry?.schema))\n    .map((entry) => entry.schema.$id as string)\n    .filter(Boolean)\n    .sort()\n}\n"],"names":["FEATURE_FLAG","isLeafFlagEnabled","flag","ENABLED","isFlagDisabled","DISABLED","restrictsChildrenToNothing","restrict","Array","isArray","length","directive","definition","components","plugins","schemaAcceptsChildren","schema","flags","dropping","selfClosing","textEditable","restrictChildren","auditChildContract","entries","declared","problems","declaredSet","Set","registered","entry","id","$id","push","displayName","add","accepts","has","sort","listAcceptingComponentIds","filter","map","Boolean"],"mappings":"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"}

package/src/lib/app-utils/collection-delete.d.ts

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Whether a collection may be deleted, and what to say when it may not
+ * (AGL-1324).
+ *
+ * A collection could be created and never deleted: "New collection" existed,
+ * no delete affordance did anywhere, so a mis-created collection was
+ * permanent — a one-way door in an ordinary authoring flow for a no-code
+ * product.
+ *
+ * The delete itself is the easy half; `/api/resources/erase` already
+ * recursiveDeletes a collection subtree for the commerce catalog card. This
+ * file is the hard half: deciding when it must NOT happen. It is pure and
+ * lives beside `collection-kind` / `collection-slug` for the same reason
+ * `eraseScopeDenial` lives beside its route — a destructive decision that
+ * cannot be unit-tested is the shape of control this project exists to
+ * avoid — and because BOTH sides need it: the console dialog to show the
+ * blockers before the button is armed, and the route to enforce them.
+ *
+ * ## Why blocking, not cascading
+ *
+ * Both blockers refuse. The alternative — delete the collection and take its
+ * entries and its published routes with it — makes destroying a live page a
+ * side effect of tidying up a list, and no consent given to the second act
+ * was given to the first. This repo already settled that argument for
+ * account erasure (`userErasureBlockers`): blocking is recoverable, a
+ * cascade is not. Emptying a collection is two clicks; un-deleting a
+ * published page is a restore from an export.
+ */
+/** What a template binding drives — which public route it publishes. */
+export type CollectionTemplateRole = 'list' | 'entry';
+/** A screen as far as this decision cares: does it exist, and what's it called. */
+export interface CollectionTemplateScreen {
+    displayName?: string;
+    /**
+     * Soft-deleted screens render nothing, so a binding to one is stale and
+     * must not block — otherwise deleting a screen makes its collection
+     * permanently undeletable, which is the bug this file exists to fix,
+     * one level up.
+     */
+    deletedAt?: unknown;
+}
+export interface CollectionTemplateBinding {
+    role: CollectionTemplateRole;
+    screenId: string;
+    /** The screen's name; falls back to the id when it has none. */
+    screenName: string;
+}
+/** The collection fields that point at a template screen. */
+export interface CollectionTemplateSource {
+    listScreenId?: unknown;
+    entryScreenId?: unknown;
+    /** Superseded AGL-105 pointer; still honoured as the entry fallback. */
+    templateScreenId?: unknown;
+}
+/**
+ * The LIVE template bindings on a collection — the screens that would be
+ * left publishing an empty route if it were deleted.
+ *
+ * `screens` is required rather than defaulted because the sole reason a
+ * binding is dropped here is that its screen is gone, and an empty map means
+ * "every screen is gone". Defaulting it would make the safe-looking call the
+ * one that silently answers "nothing depends on this". Callers pass the
+ * screens they read: the route fetches exactly the bound ids, the console
+ * already holds the host's screen list.
+ *
+ * Mirrors `resolveCollectionTemplateScreenId` in tenant-runtime: the list
+ * route uses `listScreenId` only, the entry route uses `entryScreenId` with
+ * `templateScreenId` as the legacy fallback. Deduped by screen id, because
+ * one screen serving both routes is one thing to detach, not two.
+ */
+export declare function collectionTemplateBindings(data: CollectionTemplateSource | undefined | null, screens: Readonly<Record<string, CollectionTemplateScreen | undefined>>): CollectionTemplateBinding[];
+/** Why a delete was refused, for callers that need more than the sentence. */
+export type CollectionDeleteBlocker = 'template-bound' | 'has-entries';
+export interface CollectionDeleteInput {
+    /** The collection's name, so the message names what it is refusing. */
+    displayName: string;
+    /** How many entries still live under it. */
+    entryCount: number;
+    /** Live template bindings — see {@link collectionTemplateBindings}. */
+    bindings: readonly CollectionTemplateBinding[];
+}
+export interface CollectionDeleteDenial {
+    error: string;
+    /** 409: the request is well-formed, the resource's state refuses it. */
+    status: 409;
+    blockers: CollectionDeleteBlocker[];
+}
+/**
+ * Null when the collection may be deleted; otherwise the response to return.
+ *
+ * Both blockers are reported at once. Fixing one and being told about the
+ * other is two trips through a destructive dialog to learn a fact that was
+ * knowable on the first — and the second refusal, arriving after the user
+ * has already detached a template, reads as the product changing its mind.
+ */
+export declare function collectionDeleteDenial(input: CollectionDeleteInput): CollectionDeleteDenial | null;
+export default collectionDeleteDenial;