@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/repair-canvas-nodes.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @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.
+ */
+type Nodes = Record<string, any>;
+/** What was wrong with one node, and what was done about it. */
+export interface CanvasRepairFinding {
+    /** The node the finding is about — a map key, or an id listed on a parent. */
+    nodeId: string;
+    /** Best available human label: the node's name, else its componentId. */
+    label?: string;
+    kind: 'not-a-node' | 'no-component' | 'unknown-component' | 'dangling-child' | 'orphaned' | 'cycle' | 'unreachable' | 'unlisted';
+    action: 'removed' | 'reparented' | 'relisted' | 'unlinked';
+    /** One sentence an author can read, written for the preview dialog. */
+    detail: string;
+}
+export interface CanvasRepairResult {
+    /** The repaired map. Reference-equal to nothing — always a fresh object. */
+    nodes: Nodes;
+    findings: CanvasRepairFinding[];
+    /** Node ids dropped from the document. */
+    removed: string[];
+    /** Node ids that kept their content but moved. */
+    reparented: string[];
+    /** How many nodes the repair KEPT, root excluded. */
+    kept: number;
+    /** True when the document was already sound and `nodes` is unchanged. */
+    healthy: boolean;
+}
+export interface CanvasRepairOptions {
+    /**
+     * Whether a `componentId` still resolves to a registered component.
+     *
+     * OPTIONAL on purpose, and skipped entirely when absent. A resolver that
+     * has not finished loading its plugins answers "no" for everything, and a
+     * repair that believes it would delete the whole document — the same shape
+     * of mistake as a stubbed resolver making every capacity ceiling read zero.
+     * Pass it only from a caller that knows the registry is populated.
+     */
+    isKnownComponent?: (componentId: string) => boolean;
+}
+/**
+ * Strip what a canvas cannot render, keep everything that still works
+ * (AGL-2555).
+ *
+ * ## Why this exists rather than "clear and start again"
+ *
+ * A besigner document corrupted while `/alternatives/webflow` was being
+ * built: the hierarchy rendered literal `'Invalid node'` rows, section order
+ * scrambled, two component instances stopped resolving — and the damage
+ * survived a reload, so it was persisted in the draft rather than client
+ * state. **Most of the document was still fine.** The prose, the FAQ
+ * accordions and the layout binding all rendered correctly. Only some nodes
+ * were broken, and the only way out of it was to delete the screen and
+ * rebuild every one of them.
+ *
+ * That is the whole case: an author in this position should lose the handful
+ * of nodes that are actually broken, not the hours of work around them.
+ *
+ * ## What counts as broken
+ *
+ * Every case here is one the canvas already fails on somewhere, not a rule
+ * invented for this function:
+ *
+ * - **not-a-node** — `canvas-manager` throws `Invalid node` on a null or
+ *   non-object entry.
+ * - **no-component** / **unknown-component** — nothing to render. The second
+ *   is only checked when the caller supplies a resolver it trusts.
+ * - **dangling-child** — an id listed on a parent that the map does not
+ *   hold. This is the one that renders `'Invalid node'`: `node-tree-view`
+ *   maps over the parent's child ids and prints that string for every id
+ *   that resolves to nothing. The PARENT is fine; the stale id is dropped.
+ * - **orphaned** — `parentId` names a node that is not in the map. Adopted
+ *   by the root, which is the rule `ensureCanvasRoot` already established:
+ *   recovering into an editable document beats discarding what is there.
+ * - **cycle** — a node that is its own ancestor. Walking `parent` upward is
+ *   what the hierarchy and the breadcrumb both do, so a loop does not
+ *   degrade the UI, it hangs the tab. A stored root that is its own parent
+ *   is the shape this was measured in.
+ * - **unreachable** — in the map, but no walk from the root reaches it.
+ *   These are invisible and still saved, still shipped, still counted
+ *   against the 1 MiB ceiling — AGL-1363 found 61 of them on `/product`,
+ *   26 carrying the only copy of two Hero sections' text. So they are
+ *   RE-PARENTED, never dropped: an author can see and delete a node that is
+ *   on the canvas, and cannot do either to one that is not.
+ * - **unlisted** — `parentId` agrees, the parent's child list does not. The
+ *   node is relisted rather than moved.
+ *
+ * ## What it will not do
+ *
+ * It removes nodes only for the first three, and every removal takes the
+ * subtree hanging off it — a child of an unrenderable node has nowhere to
+ * be. Everything else is a link repair that keeps the content, because a
+ * repair tool that deletes more than it has to is the corruption with
+ * better manners.
+ *
+ * ⚠️ Not an auto-heal. The result carries a full account of what it would
+ * do so a caller can put it in front of the author BEFORE anything is
+ * applied; a quiet repair that removes content is worse than the damage.
+ */
+export declare function repairCanvasNodes(nodes: Nodes | undefined, options?: CanvasRepairOptions): CanvasRepairResult;
+/**
+ * The document a newly created screen has: a root with nothing in it
+ * (AGL-2554).
+ *
+ * Built from `repairCanvasNodes` rather than `{}` so it works on the
+ * document that needs it most. Clearing is wanted precisely when the tree
+ * holds nodes the hierarchy cannot render — those rows are not selectable,
+ * so `Delete Element` cannot reach them and there is no click-path to empty
+ * the document at all. Running the repair first means the root that survives
+ * is a sound one whatever shape the map was in, including no root at all.
+ *
+ * The root's own fields are kept. It carries the document's own styling —
+ * background, padding, the page's own `sx` — and an author asking for a
+ * blank canvas is asking to remove the CONTENT, not to reset the page.
+ */
+export declare function clearCanvasNodes(nodes: Nodes | undefined): Nodes;
+export default repairCanvasNodes;

package/src/lib/app-utils/repair-canvas-nodes.js

@@ -0,0 +1,298 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @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.
+ */ import { CANVAS_ROOT_ELEMENT_ID } from "../foundation/constants/canvas.js";
+import { ensureCanvasRoot } from "./ensure-canvas-root.js";
+function labelOf(node) {
+    if (!node || typeof node !== 'object') return undefined;
+    const name = typeof node.name === 'string' ? node.name.trim() : '';
+    if (name) return name;
+    return typeof node.componentId === 'string' ? node.componentId : undefined;
+}
+/**
+ * Strip what a canvas cannot render, keep everything that still works
+ * (AGL-2555).
+ *
+ * ## Why this exists rather than "clear and start again"
+ *
+ * A besigner document corrupted while `/alternatives/webflow` was being
+ * built: the hierarchy rendered literal `'Invalid node'` rows, section order
+ * scrambled, two component instances stopped resolving — and the damage
+ * survived a reload, so it was persisted in the draft rather than client
+ * state. **Most of the document was still fine.** The prose, the FAQ
+ * accordions and the layout binding all rendered correctly. Only some nodes
+ * were broken, and the only way out of it was to delete the screen and
+ * rebuild every one of them.
+ *
+ * That is the whole case: an author in this position should lose the handful
+ * of nodes that are actually broken, not the hours of work around them.
+ *
+ * ## What counts as broken
+ *
+ * Every case here is one the canvas already fails on somewhere, not a rule
+ * invented for this function:
+ *
+ * - **not-a-node** — `canvas-manager` throws `Invalid node` on a null or
+ *   non-object entry.
+ * - **no-component** / **unknown-component** — nothing to render. The second
+ *   is only checked when the caller supplies a resolver it trusts.
+ * - **dangling-child** — an id listed on a parent that the map does not
+ *   hold. This is the one that renders `'Invalid node'`: `node-tree-view`
+ *   maps over the parent's child ids and prints that string for every id
+ *   that resolves to nothing. The PARENT is fine; the stale id is dropped.
+ * - **orphaned** — `parentId` names a node that is not in the map. Adopted
+ *   by the root, which is the rule `ensureCanvasRoot` already established:
+ *   recovering into an editable document beats discarding what is there.
+ * - **cycle** — a node that is its own ancestor. Walking `parent` upward is
+ *   what the hierarchy and the breadcrumb both do, so a loop does not
+ *   degrade the UI, it hangs the tab. A stored root that is its own parent
+ *   is the shape this was measured in.
+ * - **unreachable** — in the map, but no walk from the root reaches it.
+ *   These are invisible and still saved, still shipped, still counted
+ *   against the 1 MiB ceiling — AGL-1363 found 61 of them on `/product`,
+ *   26 carrying the only copy of two Hero sections' text. So they are
+ *   RE-PARENTED, never dropped: an author can see and delete a node that is
+ *   on the canvas, and cannot do either to one that is not.
+ * - **unlisted** — `parentId` agrees, the parent's child list does not. The
+ *   node is relisted rather than moved.
+ *
+ * ## What it will not do
+ *
+ * It removes nodes only for the first three, and every removal takes the
+ * subtree hanging off it — a child of an unrenderable node has nowhere to
+ * be. Everything else is a link repair that keeps the content, because a
+ * repair tool that deletes more than it has to is the corruption with
+ * better manners.
+ *
+ * ⚠️ Not an auto-heal. The result carries a full account of what it would
+ * do so a caller can put it in front of the author BEFORE anything is
+ * applied; a quiet repair that removes content is worse than the damage.
+ */ export function repairCanvasNodes(nodes, options = {}) {
+    const { isKnownComponent } = options;
+    // A rootless map is its own defect, and it has an owner already. Doing it
+    // first means every walk below has a root to start from.
+    const source = ensureCanvasRoot(nodes);
+    const findings = [];
+    const removed = [];
+    const reparented = [];
+    // ── 1. Entries that are not renderable nodes ────────────────────────────
+    const map = {};
+    for (const [id, node] of Object.entries(source)){
+        if (!node || typeof node !== 'object') {
+            removed.push(id);
+            findings.push({
+                nodeId: id,
+                kind: 'not-a-node',
+                action: 'removed',
+                detail: 'Not an element — the canvas cannot render this entry.'
+            });
+            continue;
+        }
+        if (id !== CANVAS_ROOT_ELEMENT_ID) {
+            const componentId = node.componentId;
+            if (typeof componentId !== 'string' || !componentId) {
+                removed.push(id);
+                findings.push({
+                    nodeId: id,
+                    label: labelOf(node),
+                    kind: 'no-component',
+                    action: 'removed',
+                    detail: 'No element type — there is nothing to draw.'
+                });
+                continue;
+            }
+            if (isKnownComponent && !isKnownComponent(componentId)) {
+                removed.push(id);
+                findings.push({
+                    nodeId: id,
+                    label: labelOf(node),
+                    kind: 'unknown-component',
+                    action: 'removed',
+                    detail: `"${componentId}" is not an element this site has — it may come from a plugin that is switched off.`
+                });
+                continue;
+            }
+        }
+        map[id] = _extends({}, node, {
+            nodes: Array.isArray(node.nodes) ? [
+                ...node.nodes
+            ] : []
+        });
+    }
+    // A removed node takes its subtree: a child of something unrenderable has
+    // nowhere to be, and re-parenting it to the root would strand a fragment
+    // the author never authored at the top of the document.
+    let grew = true;
+    while(grew){
+        grew = false;
+        for (const [id, node] of Object.entries(map)){
+            if (id === CANVAS_ROOT_ELEMENT_ID) continue;
+            const parentId = node.parentId;
+            if (typeof parentId === 'string' && removed.includes(parentId)) {
+                delete map[id];
+                removed.push(id);
+                findings.push({
+                    nodeId: id,
+                    label: labelOf(node),
+                    kind: 'not-a-node',
+                    action: 'removed',
+                    detail: 'Sat inside an element that had to be removed.'
+                });
+                grew = true;
+            }
+        }
+    }
+    // ── 2. Child ids that resolve to nothing — the 'Invalid node' rows ──────
+    for (const [id, node] of Object.entries(map)){
+        const kept = [];
+        for (const childId of node.nodes){
+            var _labelOf;
+            if (typeof childId === 'string' && map[childId]) {
+                kept.push(childId);
+                continue;
+            }
+            findings.push({
+                nodeId: typeof childId === 'string' ? childId : String(childId),
+                kind: 'dangling-child',
+                action: 'unlinked',
+                detail: `Listed inside "${(_labelOf = labelOf(node)) != null ? _labelOf : id}" but not present — this is what shows as "Invalid node".`
+            });
+        }
+        node.nodes = kept;
+    }
+    // ── 3. Parents that do not exist, and loops ─────────────────────────────
+    const adopt = (id, kind, detail)=>{
+        const node = map[id];
+        const previous = node.parentId;
+        node.parentId = CANVAS_ROOT_ELEMENT_ID;
+        if (typeof previous === 'string' && map[previous]) {
+            map[previous].nodes = map[previous].nodes.filter((child)=>child !== id);
+        }
+        if (!map[CANVAS_ROOT_ELEMENT_ID].nodes.includes(id)) {
+            ;
+            map[CANVAS_ROOT_ELEMENT_ID].nodes.push(id);
+        }
+        reparented.push(id);
+        findings.push({
+            nodeId: id,
+            label: labelOf(node),
+            kind,
+            action: 'reparented',
+            detail
+        });
+    };
+    for (const id of Object.keys(map)){
+        if (id === CANVAS_ROOT_ELEMENT_ID) continue;
+        const parentId = map[id].parentId;
+        if (typeof parentId !== 'string' || !map[parentId]) {
+            adopt(id, 'orphaned', 'Its container is gone — moved to the top level so you can put it back.');
+        }
+    }
+    for (const id of Object.keys(map)){
+        if (id === CANVAS_ROOT_ELEMENT_ID) continue;
+        // Bounded by the map size, so a loop ends rather than hanging the way
+        // the hierarchy's own upward walk does.
+        const seen = new Set([
+            id
+        ]);
+        let cursor = map[id].parentId;
+        let looped = false;
+        while(typeof cursor === 'string' && map[cursor]){
+            if (seen.has(cursor)) {
+                looped = true;
+                break;
+            }
+            seen.add(cursor);
+            if (cursor === CANVAS_ROOT_ELEMENT_ID) break;
+            cursor = map[cursor].parentId;
+        }
+        if (looped) {
+            adopt(id, 'cycle', 'Was inside itself — a loop the hierarchy cannot walk out of. Moved to the top level.');
+        }
+    }
+    // ── 4. Reachability, and links that disagree with themselves ───────────
+    for (const id of Object.keys(map)){
+        if (id === CANVAS_ROOT_ELEMENT_ID) continue;
+        const parent = map[map[id].parentId];
+        if (!parent) continue;
+        if (!parent.nodes.includes(id)) {
+            var _labelOf1;
+            ;
+            parent.nodes.push(id);
+            findings.push({
+                nodeId: id,
+                label: labelOf(map[id]),
+                kind: 'unlisted',
+                action: 'relisted',
+                detail: `Belonged to "${(_labelOf1 = labelOf(parent)) != null ? _labelOf1 : map[id].parentId}" but was not listed in it — put back in place.`
+            });
+        }
+    }
+    const reachable = new Set();
+    const queue = [
+        CANVAS_ROOT_ELEMENT_ID
+    ];
+    while(queue.length){
+        var _ref;
+        var _map_id;
+        const id = queue.shift();
+        if (reachable.has(id)) continue;
+        reachable.add(id);
+        for (const childId of (_ref = (_map_id = map[id]) == null ? void 0 : _map_id.nodes) != null ? _ref : []){
+            if (map[childId]) queue.push(childId);
+        }
+    }
+    for (const id of Object.keys(map)){
+        if (reachable.has(id)) continue;
+        adopt(id, 'unreachable', 'Saved with the document but never drawn — moved to the top level so you can see it and decide.');
+    }
+    const kept = Object.keys(map).length - 1;
+    return {
+        nodes: map,
+        findings,
+        removed,
+        reparented,
+        kept,
+        healthy: findings.length === 0
+    };
+}
+/**
+ * The document a newly created screen has: a root with nothing in it
+ * (AGL-2554).
+ *
+ * Built from `repairCanvasNodes` rather than `{}` so it works on the
+ * document that needs it most. Clearing is wanted precisely when the tree
+ * holds nodes the hierarchy cannot render — those rows are not selectable,
+ * so `Delete Element` cannot reach them and there is no click-path to empty
+ * the document at all. Running the repair first means the root that survives
+ * is a sound one whatever shape the map was in, including no root at all.
+ *
+ * The root's own fields are kept. It carries the document's own styling —
+ * background, padding, the page's own `sx` — and an author asking for a
+ * blank canvas is asking to remove the CONTENT, not to reset the page.
+ */ export function clearCanvasNodes(nodes) {
+    const { nodes: repaired } = repairCanvasNodes(nodes);
+    return {
+        [CANVAS_ROOT_ELEMENT_ID]: _extends({}, repaired[CANVAS_ROOT_ELEMENT_ID], {
+            $id: CANVAS_ROOT_ELEMENT_ID,
+            parentId: null,
+            nodes: []
+        })
+    };
+}
+export default repairCanvasNodes;
+
+//# sourceMappingURL=repair-canvas-nodes.js.map

package/src/lib/app-utils/repair-canvas-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/repair-canvas-nodes.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\nimport { CANVAS_ROOT_ELEMENT_ID } from '../foundation/constants/canvas'\nimport { ensureCanvasRoot } from './ensure-canvas-root'\n\ntype Nodes = Record<string, any>\n\n/** What was wrong with one node, and what was done about it. */\nexport interface CanvasRepairFinding {\n  /** The node the finding is about — a map key, or an id listed on a parent. */\n  nodeId: string\n  /** Best available human label: the node's name, else its componentId. */\n  label?: string\n  kind:\n    | 'not-a-node'\n    | 'no-component'\n    | 'unknown-component'\n    | 'dangling-child'\n    | 'orphaned'\n    | 'cycle'\n    | 'unreachable'\n    | 'unlisted'\n  action: 'removed' | 'reparented' | 'relisted' | 'unlinked'\n  /** One sentence an author can read, written for the preview dialog. */\n  detail: string\n}\n\nexport interface CanvasRepairResult {\n  /** The repaired map. Reference-equal to nothing — always a fresh object. */\n  nodes: Nodes\n  findings: CanvasRepairFinding[]\n  /** Node ids dropped from the document. */\n  removed: string[]\n  /** Node ids that kept their content but moved. */\n  reparented: string[]\n  /** How many nodes the repair KEPT, root excluded. */\n  kept: number\n  /** True when the document was already sound and `nodes` is unchanged. */\n  healthy: boolean\n}\n\nexport interface CanvasRepairOptions {\n  /**\n   * Whether a `componentId` still resolves to a registered component.\n   *\n   * OPTIONAL on purpose, and skipped entirely when absent. A resolver that\n   * has not finished loading its plugins answers \"no\" for everything, and a\n   * repair that believes it would delete the whole document — the same shape\n   * of mistake as a stubbed resolver making every capacity ceiling read zero.\n   * Pass it only from a caller that knows the registry is populated.\n   */\n  isKnownComponent?: (componentId: string) => boolean\n}\n\nfunction labelOf(node: any): string | undefined {\n  if (!node || typeof node !== 'object') return undefined\n  const name = typeof node.name === 'string' ? node.name.trim() : ''\n  if (name) return name\n  return typeof node.componentId === 'string' ? node.componentId : undefined\n}\n\n/**\n * Strip what a canvas cannot render, keep everything that still works\n * (AGL-2555).\n *\n * ## Why this exists rather than \"clear and start again\"\n *\n * A besigner document corrupted while `/alternatives/webflow` was being\n * built: the hierarchy rendered literal `'Invalid node'` rows, section order\n * scrambled, two component instances stopped resolving — and the damage\n * survived a reload, so it was persisted in the draft rather than client\n * state. **Most of the document was still fine.** The prose, the FAQ\n * accordions and the layout binding all rendered correctly. Only some nodes\n * were broken, and the only way out of it was to delete the screen and\n * rebuild every one of them.\n *\n * That is the whole case: an author in this position should lose the handful\n * of nodes that are actually broken, not the hours of work around them.\n *\n * ## What counts as broken\n *\n * Every case here is one the canvas already fails on somewhere, not a rule\n * invented for this function:\n *\n * - **not-a-node** — `canvas-manager` throws `Invalid node` on a null or\n *   non-object entry.\n * - **no-component** / **unknown-component** — nothing to render. The second\n *   is only checked when the caller supplies a resolver it trusts.\n * - **dangling-child** — an id listed on a parent that the map does not\n *   hold. This is the one that renders `'Invalid node'`: `node-tree-view`\n *   maps over the parent's child ids and prints that string for every id\n *   that resolves to nothing. The PARENT is fine; the stale id is dropped.\n * - **orphaned** — `parentId` names a node that is not in the map. Adopted\n *   by the root, which is the rule `ensureCanvasRoot` already established:\n *   recovering into an editable document beats discarding what is there.\n * - **cycle** — a node that is its own ancestor. Walking `parent` upward is\n *   what the hierarchy and the breadcrumb both do, so a loop does not\n *   degrade the UI, it hangs the tab. A stored root that is its own parent\n *   is the shape this was measured in.\n * - **unreachable** — in the map, but no walk from the root reaches it.\n *   These are invisible and still saved, still shipped, still counted\n *   against the 1 MiB ceiling — AGL-1363 found 61 of them on `/product`,\n *   26 carrying the only copy of two Hero sections' text. So they are\n *   RE-PARENTED, never dropped: an author can see and delete a node that is\n *   on the canvas, and cannot do either to one that is not.\n * - **unlisted** — `parentId` agrees, the parent's child list does not. The\n *   node is relisted rather than moved.\n *\n * ## What it will not do\n *\n * It removes nodes only for the first three, and every removal takes the\n * subtree hanging off it — a child of an unrenderable node has nowhere to\n * be. Everything else is a link repair that keeps the content, because a\n * repair tool that deletes more than it has to is the corruption with\n * better manners.\n *\n * ⚠️ Not an auto-heal. The result carries a full account of what it would\n * do so a caller can put it in front of the author BEFORE anything is\n * applied; a quiet repair that removes content is worse than the damage.\n */\nexport function repairCanvasNodes(\n  nodes: Nodes | undefined,\n  options: CanvasRepairOptions = {},\n): CanvasRepairResult {\n  const { isKnownComponent } = options\n  // A rootless map is its own defect, and it has an owner already. Doing it\n  // first means every walk below has a root to start from.\n  const source = ensureCanvasRoot(nodes)\n  const findings: CanvasRepairFinding[] = []\n  const removed: string[] = []\n  const reparented: string[] = []\n\n  // ── 1. Entries that are not renderable nodes ────────────────────────────\n  const map: Nodes = {}\n  for (const [id, node] of Object.entries(source)) {\n    if (!node || typeof node !== 'object') {\n      removed.push(id)\n      findings.push({\n        nodeId: id,\n        kind: 'not-a-node',\n        action: 'removed',\n        detail: 'Not an element — the canvas cannot render this entry.',\n      })\n      continue\n    }\n    if (id !== CANVAS_ROOT_ELEMENT_ID) {\n      const componentId = node.componentId\n      if (typeof componentId !== 'string' || !componentId) {\n        removed.push(id)\n        findings.push({\n          nodeId: id,\n          label: labelOf(node),\n          kind: 'no-component',\n          action: 'removed',\n          detail: 'No element type — there is nothing to draw.',\n        })\n        continue\n      }\n      if (isKnownComponent && !isKnownComponent(componentId)) {\n        removed.push(id)\n        findings.push({\n          nodeId: id,\n          label: labelOf(node),\n          kind: 'unknown-component',\n          action: 'removed',\n          detail: `\"${componentId}\" is not an element this site has — it may come from a plugin that is switched off.`,\n        })\n        continue\n      }\n    }\n    map[id] = { ...node, nodes: Array.isArray(node.nodes) ? [...node.nodes] : [] }\n  }\n\n  // A removed node takes its subtree: a child of something unrenderable has\n  // nowhere to be, and re-parenting it to the root would strand a fragment\n  // the author never authored at the top of the document.\n  let grew = true\n  while (grew) {\n    grew = false\n    for (const [id, node] of Object.entries(map)) {\n      if (id === CANVAS_ROOT_ELEMENT_ID) continue\n      const parentId = node.parentId\n      if (typeof parentId === 'string' && removed.includes(parentId)) {\n        delete map[id]\n        removed.push(id)\n        findings.push({\n          nodeId: id,\n          label: labelOf(node),\n          kind: 'not-a-node',\n          action: 'removed',\n          detail: 'Sat inside an element that had to be removed.',\n        })\n        grew = true\n      }\n    }\n  }\n\n  // ── 2. Child ids that resolve to nothing — the 'Invalid node' rows ──────\n  for (const [id, node] of Object.entries(map)) {\n    const kept: string[] = []\n    for (const childId of node.nodes as string[]) {\n      if (typeof childId === 'string' && map[childId]) {\n        kept.push(childId)\n        continue\n      }\n      findings.push({\n        nodeId: typeof childId === 'string' ? childId : String(childId),\n        kind: 'dangling-child',\n        action: 'unlinked',\n        detail: `Listed inside \"${labelOf(node) ?? id}\" but not present — this is what shows as \"Invalid node\".`,\n      })\n    }\n    node.nodes = kept\n  }\n\n  // ── 3. Parents that do not exist, and loops ─────────────────────────────\n  const adopt = (\n    id: string,\n    kind: CanvasRepairFinding['kind'],\n    detail: string,\n  ) => {\n    const node = map[id]\n    const previous = node.parentId\n    node.parentId = CANVAS_ROOT_ELEMENT_ID\n    if (typeof previous === 'string' && map[previous]) {\n      map[previous].nodes = (map[previous].nodes as string[]).filter(\n        (child) => child !== id,\n      )\n    }\n    if (!(map[CANVAS_ROOT_ELEMENT_ID].nodes as string[]).includes(id)) {\n      ;(map[CANVAS_ROOT_ELEMENT_ID].nodes as string[]).push(id)\n    }\n    reparented.push(id)\n    findings.push({ nodeId: id, label: labelOf(node), kind, action: 'reparented', detail })\n  }\n\n  for (const id of Object.keys(map)) {\n    if (id === CANVAS_ROOT_ELEMENT_ID) continue\n    const parentId = map[id].parentId\n    if (typeof parentId !== 'string' || !map[parentId]) {\n      adopt(\n        id,\n        'orphaned',\n        'Its container is gone — moved to the top level so you can put it back.',\n      )\n    }\n  }\n\n  for (const id of Object.keys(map)) {\n    if (id === CANVAS_ROOT_ELEMENT_ID) continue\n    // Bounded by the map size, so a loop ends rather than hanging the way\n    // the hierarchy's own upward walk does.\n    const seen = new Set<string>([id])\n    let cursor: string | undefined = map[id].parentId\n    let looped = false\n    while (typeof cursor === 'string' && map[cursor]) {\n      if (seen.has(cursor)) {\n        looped = true\n        break\n      }\n      seen.add(cursor)\n      if (cursor === CANVAS_ROOT_ELEMENT_ID) break\n      cursor = map[cursor].parentId\n    }\n    if (looped) {\n      adopt(\n        id,\n        'cycle',\n        'Was inside itself — a loop the hierarchy cannot walk out of. Moved to the top level.',\n      )\n    }\n  }\n\n  // ── 4. Reachability, and links that disagree with themselves ───────────\n  for (const id of Object.keys(map)) {\n    if (id === CANVAS_ROOT_ELEMENT_ID) continue\n    const parent = map[map[id].parentId]\n    if (!parent) continue\n    if (!(parent.nodes as string[]).includes(id)) {\n      ;(parent.nodes as string[]).push(id)\n      findings.push({\n        nodeId: id,\n        label: labelOf(map[id]),\n        kind: 'unlisted',\n        action: 'relisted',\n        detail: `Belonged to \"${labelOf(parent) ?? map[id].parentId}\" but was not listed in it — put back in place.`,\n      })\n    }\n  }\n\n  const reachable = new Set<string>()\n  const queue = [CANVAS_ROOT_ELEMENT_ID]\n  while (queue.length) {\n    const id = queue.shift()!\n    if (reachable.has(id)) continue\n    reachable.add(id)\n    for (const childId of map[id]?.nodes ?? []) {\n      if (map[childId]) queue.push(childId)\n    }\n  }\n  for (const id of Object.keys(map)) {\n    if (reachable.has(id)) continue\n    adopt(\n      id,\n      'unreachable',\n      'Saved with the document but never drawn — moved to the top level so you can see it and decide.',\n    )\n  }\n\n  const kept = Object.keys(map).length - 1\n  return {\n    nodes: map,\n    findings,\n    removed,\n    reparented,\n    kept,\n    healthy: findings.length === 0,\n  }\n}\n\n/**\n * The document a newly created screen has: a root with nothing in it\n * (AGL-2554).\n *\n * Built from `repairCanvasNodes` rather than `{}` so it works on the\n * document that needs it most. Clearing is wanted precisely when the tree\n * holds nodes the hierarchy cannot render — those rows are not selectable,\n * so `Delete Element` cannot reach them and there is no click-path to empty\n * the document at all. Running the repair first means the root that survives\n * is a sound one whatever shape the map was in, including no root at all.\n *\n * The root's own fields are kept. It carries the document's own styling —\n * background, padding, the page's own `sx` — and an author asking for a\n * blank canvas is asking to remove the CONTENT, not to reset the page.\n */\nexport function clearCanvasNodes(nodes: Nodes | undefined): Nodes {\n  const { nodes: repaired } = repairCanvasNodes(nodes)\n  return {\n    [CANVAS_ROOT_ELEMENT_ID]: {\n      ...repaired[CANVAS_ROOT_ELEMENT_ID],\n      $id: CANVAS_ROOT_ELEMENT_ID,\n      parentId: null,\n      nodes: [],\n    },\n  }\n}\n\nexport default repairCanvasNodes\n"],"names":["CANVAS_ROOT_ELEMENT_ID","ensureCanvasRoot","labelOf","node","undefined","name","trim","componentId","repairCanvasNodes","nodes","options","isKnownComponent","source","findings","removed","reparented","map","id","Object","entries","push","nodeId","kind","action","detail","label","Array","isArray","grew","parentId","includes","kept","childId","String","adopt","previous","filter","child","keys","seen","Set","cursor","looped","has","add","parent","reachable","queue","length","shift","healthy","clearCanvasNodes","repaired","$id"],"mappings":"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"}

package/src/lib/app-utils/repeat-infringer.d.ts

@@ -0,0 +1,166 @@
+/**
+ * @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.
+ */
+/**
+ * REPEAT-INFRINGER POLICY — the §512(i) condition, with a counter behind it
+ * (AGL-1983).
+ *
+ * §512(i)(1)(A) conditions the ENTIRE safe harbour — every limitation in
+ * §512, not just the hosting one — on a provider having "adopted and
+ * reasonably implemented" a policy for terminating repeat infringers, and on
+ * informing subscribers of it. This is the condition providers most often
+ * lose on, and they lose on the second half: courts have declined to credit a
+ * policy that existed as prose while nothing in the product counted anything.
+ * A policy page alone would not close AGL-1983 and the issue says so.
+ *
+ * So this module is the counting. It answers three questions and nothing else:
+ * what is a strike, when does one go away, and what happens at the threshold.
+ *
+ * ## A strike is an ACTIONED notice, counted against the ACCOUNT
+ *
+ * Not a received notice — anyone can send one, and counting receipts would
+ * let a competitor terminate a customer by filing three complaints. A strike
+ * is recorded when staff action a DMCA report: the point at which a human
+ * looked and took content down.
+ *
+ * Counted against the **org**, not the site. A repeat infringer who loses one
+ * site and opens another inside the same workspace has not been terminated in
+ * any sense the statute would recognise, and the org is the account we bill,
+ * suspend and close. {@link STRIKE_LEDGER_SUBCOLLECTION} therefore hangs off
+ * `orgs/{orgId}`.
+ *
+ * ## A strike is keyed by its report, which is what makes withdrawal work
+ *
+ * One ledger document per actioned report, with the report's id AS the
+ * document id. Two properties fall out of that and both are load-bearing:
+ *
+ *  - **Idempotence.** Staff re-actioning a report they already actioned — or
+ *    a route retried — cannot inflate the count. A counter that can be pumped
+ *    by clicking twice is not one anybody should terminate an account on.
+ *  - **Exact withdrawal.** When a notice is withdrawn, or a counter-notice
+ *    leads to a restoration, the strike it created has to come off — and only
+ *    that one. §512(g) restoration means the takedown is being reversed; a
+ *    strike surviving it would count an infringement the process just
+ *    declined to affirm, which is the shape of unfairness that makes a policy
+ *    look unreasonable rather than reasonable. Deleting by report id removes
+ *    exactly the right strike without recomputing anything.
+ *
+ * {@link strikeWithdrawalReason} names the three ways a strike comes off, so
+ * the ledger records WHY rather than silently shrinking.
+ *
+ * ## The threshold has to do something
+ *
+ * "Reasonably implemented" is the whole fight, so the escalation is defined
+ * here as data rather than left to whoever reads the queue:
+ * {@link repeatInfringerVerdict} maps a count onto a level, and each level
+ * names the consequence in terms of levers this product actually has. At
+ * `terminate` the staff queue refuses to close a DMCA report without an
+ * explicit recorded decision — see the admin route — so the threshold cannot
+ * be passed silently. That refusal is the difference between a counter and a
+ * policy.
+ *
+ * What this module deliberately does NOT do is suspend anything by itself. An
+ * automatic termination on a third strike would be a product that closes a
+ * paying customer's account on three unverified assertions by strangers, with
+ * no human in the loop — and §512 nowhere asks for that. The policy is
+ * "terminate in appropriate circumstances", and judging the circumstances is
+ * exactly the part a person must do. The counter makes the decision
+ * unavoidable and recorded; it does not make it automatically.
+ */
+/** Per-org strike ledger. One document per actioned DMCA report. */
+export declare const STRIKE_LEDGER_SUBCOLLECTION = "dmcaStrikes";
+/**
+ * Strikes at which each consequence begins.
+ *
+ * Three is the termination threshold, which is the number the phrase "repeat
+ * infringer" is conventionally read against and the number the operator's own
+ * published repeat-infringer policy has to state — §512(i)(1)(A) conditions the
+ * whole safe harbour on subscribers having been *informed* of the policy, so a
+ * threshold this ledger enforces silently earns nothing (AGL-2044, AGL-2007).
+ * On a self-host install that policy is the operator's document, not ours: they
+ * inherit a working ledger and owe their own text. The two below it exist so
+ * termination is never the first
+ * thing a customer hears about a problem: a subscriber who does not know they
+ * are on a strike cannot correct their behaviour, and a policy that only
+ * speaks at the end is one a court can call unreasonable in its
+ * implementation.
+ */
+export declare const STRIKE_WARN_AT = 1;
+export declare const STRIKE_FINAL_AT = 2;
+export declare const STRIKE_TERMINATE_AT = 3;
+export type RepeatInfringerLevel = 'none' | 'warn' | 'final' | 'terminate';
+export interface RepeatInfringerVerdict {
+    /** Strikes currently standing against the account. */
+    strikes: number;
+    level: RepeatInfringerLevel;
+    /**
+     * Does the account-level consequence require a recorded human decision
+     * before any further DMCA report on this org can be closed?
+     */
+    decisionRequired: boolean;
+    /** One line naming the consequence, shown to staff and quoted to the org. */
+    consequence: string;
+}
+/**
+ * Strikes → verdict.
+ *
+ * A pure function of the count, so the staff surface, the admin route and the
+ * docs cannot disagree about where the line is. Anything at or above
+ * {@link STRIKE_TERMINATE_AT} is `terminate`, including a count that somehow
+ * ran past it — a fourth strike must not read as less serious than the third.
+ */
+export declare function repeatInfringerVerdict(strikes: unknown): RepeatInfringerVerdict;
+/** Why a strike came off the ledger. Recorded, never silent. */
+export declare const STRIKE_WITHDRAWAL_REASONS: readonly ["noticeWithdrawn", "counterNoticeRestored", "staffReversed"];
+export type StrikeWithdrawalReason = (typeof STRIKE_WITHDRAWAL_REASONS)[number];
+export declare function isStrikeWithdrawalReason(value: unknown): value is StrikeWithdrawalReason;
+/**
+ * Does moving a DMCA report to `status` earn a strike?
+ *
+ * `actioned` only. `dismissed` is staff saying the notice did not hold up, so
+ * it must not count — and neither must `open` or `reviewing`, which are a
+ * report nobody has adjudicated yet. Counting anything but `actioned` would
+ * make the ledger a record of accusations rather than of upheld ones.
+ *
+ * The category gate matters as much as the status: the queue carries phishing
+ * and malware reports too, and a phishing takedown is not a copyright
+ * infringement. §512(i) is about infringement, so only `dmca` reports reach
+ * the ledger.
+ */
+export declare function strikeEarnedBy(category: unknown, status: unknown): boolean;
+/**
+ * Does moving a DMCA report to `status` REMOVE a strike it previously earned?
+ *
+ * The mirror of {@link strikeEarnedBy}, and the reason the pair is written as
+ * two functions rather than one: a report that goes `actioned` → `dismissed`
+ * has to give its strike back, and a naive "recount the actioned ones"
+ * implementation would get that right by accident while getting the
+ * counter-notice case wrong, because a restored counter-notice leaves the
+ * report `actioned` and reverses it by a different route.
+ */
+export declare function strikeRemovedBy(category: unknown, status: unknown): boolean;
+/**
+ * Count the strikes standing, given ledger rows.
+ *
+ * Rows carry a `withdrawnAt` when they have been reversed rather than being
+ * deleted, so the ledger stays a complete history — "did we know, and when"
+ * is the question the abuse queue exists to answer, and a strike that was
+ * lifted is part of that answer. Only rows without one count.
+ */
+export declare function countStandingStrikes(rows: readonly {
+    withdrawnAt?: unknown;
+}[] | null | undefined): number;
+export default repeatInfringerVerdict;