@aglyn/aglyn 1.0.0-beta.143

package/src/lib/canvas-manager/canvas-manager.js

@@ -0,0 +1,1311 @@
+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 { _isObj, _isStrT } from "@aglyn/shared-util-tools";
+import { arraySafe } from "@aglyn/shared-util-tools";
+import cloneDeep from "lodash-es/cloneDeep.js";
+import isEqual from "lodash-es/isEqual.js";
+import { action, computed, makeAutoObservable, makeObservable, observable, runInAction, toJS } from "mobx";
+// The leaf module, not the 68 KB package bundle — see the note there.
+import { computedFn } from "@aglyn/shared-util-vendor/mobx-computed-fn";
+import { schemaAcceptsChildren } from "../app-utils/child-contract.js";
+import { REUSABLE_INSTANCE_COMPONENT_ID } from "../app-utils/reusable-component-keys.js";
+import { stripUndefinedDeep } from "../app-utils/strip-undefined.js";
+import { createIdUrlSafe } from "../foundation/constants/app.js";
+import { NodeType } from "../types/nodes.js";
+export const NODE_ROOT_ID = '_@_';
+export const NODE_ROOT_LABEL = 'Document';
+export class AglynNode {
+    get parent() {
+        if (!this.parentId) return;
+        return this.store.getNode(this.parentId);
+    }
+    get index() {
+        return this.store.getNodeIndex(this);
+    }
+    get children() {
+        var _this_nodes;
+        const res = [];
+        // `?? []`, not `||= []` — a computed getter must not assign to observable
+        // state, and this only reads (AGL-763).
+        for (const $id of (_this_nodes = this.nodes) != null ? _this_nodes : []){
+            const node = this.store.getNode($id);
+            if (node) res.push(node);
+        }
+        return res;
+    }
+    get labelShort() {
+        return this.store.getNodeLabelShort(this);
+    }
+    get breadcrumbPath() {
+        return this.store.getNodeBreadcrumbPath(this);
+    }
+    get componentSchema() {
+        if (!this.componentId) return;
+        return this.store.aglyn.components.getSchema(this.componentId);
+    }
+    get hasNodes() {
+        return Array.isArray(this.nodes) && this.nodes.length > 0;
+    }
+    get resolvedProps() {
+        var _this_componentSchema;
+        const resolveProps = (_this_componentSchema = this.componentSchema) == null ? void 0 : _this_componentSchema.resolveProps;
+        if (typeof resolveProps === 'function') {
+            return resolveProps(this) || {};
+        }
+        return this.props;
+    }
+    get asJSON() {
+        return this.toJSON();
+    }
+    delete() {
+        this.store.deleteNode(this);
+    }
+    constructor(schema, store){
+        this.store = store;
+        this.toJSON = ()=>{
+            const json = {
+                $id: this.$id,
+                type: this.type
+            };
+            // Omit optional scalar fields when undefined — Firestore rejects undefined values
+            if (this.name !== undefined) json['name'] = this.name;
+            if (this.parentId !== undefined) json['parentId'] = this.parentId;
+            if (this.pluginId !== undefined) json['pluginId'] = this.pluginId;
+            if (this.componentId !== undefined) json['componentId'] = this.componentId;
+            if (this.className !== undefined) json['className'] = this.className;
+            // Omit collection fields when empty to save Firestore storage
+            const nodes = this.nodes ? [
+                ...this.nodes
+            ] : [];
+            if (nodes.length > 0) json['nodes'] = nodes;
+            // The scalar omissions above stopped at the top level, so an OWN key
+            // holding `undefined` inside these bags still reached storage (AGL-1334).
+            // An editor form writes the whole field set back, so a never-set or
+            // cleared optional attribute is such a key — and the two write paths then
+            // disagreed: a save msgpacked it to `null`, a publish handed `undefined`
+            // straight to `updateDoc()`, which rejects it. Stripping HERE is what
+            // makes save and publish agree: both serialize from this one method.
+            const props = stripUndefinedDeep(toJS(this.props));
+            if (props && Object.keys(props).length > 0) json['props'] = props;
+            const sx = stripUndefinedDeep(toJS(this.sx));
+            const sxEmpty = Array.isArray(sx) ? sx.length === 0 : !sx || Object.keys(sx).length === 0;
+            if (!sxEmpty) json['sx'] = sx;
+            // Instance style overrides (AGL-1306): emitted like sx — absent when
+            // empty — so the SAVED node map carries them into both storage forms
+            // (the plain map and the msgpack bytes both serialize this output).
+            const styleOverrides = stripUndefinedDeep(toJS(this.styleOverrides));
+            if (styleOverrides && Object.keys(styleOverrides).length > 0) {
+                json['styleOverrides'] = styleOverrides;
+            }
+            // Instance attribute overrides (AGL-1899): same treatment, same reason.
+            const attrOverrides = stripUndefinedDeep(toJS(this.attrOverrides));
+            if (attrOverrides && Object.keys(attrOverrides).length > 0) {
+                json['attrOverrides'] = attrOverrides;
+            }
+            // Element interactions: emitted like the bags above, absent
+            // when empty. This is the field that makes them versioned with the
+            // document at all — an interaction the canvas holds but this method
+            // does not write is one that never reaches a save.
+            const interactions = stripUndefinedDeep(toJS(this.interactions));
+            if (Array.isArray(interactions) && interactions.length > 0) {
+                json['interactions'] = interactions;
+            }
+            // Author visibility. Emitted only when TRUE: `false` and
+            // absent mean the same thing, and a field on every node in the document
+            // is bytes on every save and every page.
+            if (this.hidden) json['hidden'] = true;
+            return json;
+        };
+        this.$id = schema.$id;
+        this.name = schema.name;
+        this.type = schema.type || NodeType.NODE;
+        this.parentId = schema.parentId;
+        this.pluginId = schema.pluginId;
+        this.componentId = schema.componentId;
+        this.className = schema.className;
+        this.nodes = Array.isArray(schema.nodes) ? [
+            ...schema.nodes
+        ] : [];
+        this.props = _extends({}, schema.props);
+        this.sx = Array.isArray(schema.sx) ? [
+            ...schema.sx
+        ] : _extends({}, schema.sx);
+        this.styleOverrides = schema.styleOverrides ? _extends({}, schema.styleOverrides) : undefined;
+        this.attrOverrides = schema.attrOverrides ? _extends({}, schema.attrOverrides) : undefined;
+        this.interactions = Array.isArray(schema.interactions) ? [
+            ...schema.interactions
+        ] : undefined;
+        this.hidden = schema.hidden || undefined;
+        makeAutoObservable(this, {
+            store: false,
+            toJSON: false
+        });
+    }
+}
+let HistoryManager = class HistoryManager {
+    get [Symbol.toStringTag]() {
+        return 'HistoryManager';
+    }
+    toString() {
+        return '[object HistoryManager]';
+    }
+    toJSON() {
+        return {
+            past: toJS(this.past),
+            present: toJS(this.present),
+            future: toJS(this.future)
+        };
+    }
+    get canUndo() {
+        return this.past.length >= 1;
+    }
+    get canRedo() {
+        return this.future.length >= 1;
+    }
+    undo(epoch) {
+        if (!this.canUndo) throw new Error('No history to undo');
+        this.future.push({
+            nodes: toJS(this.present),
+            epoch
+        });
+        return this.past.pop();
+    }
+    redo(epoch) {
+        if (!this.canRedo) throw new Error('No history to redo');
+        this.past.push({
+            nodes: toJS(this.present),
+            epoch
+        });
+        return this.future.pop();
+    }
+    clearPast() {
+        this.past.clear();
+        return this;
+    }
+    clearFuture() {
+        this.future.clear();
+        return this;
+    }
+    clearHistory() {
+        this.clearPast();
+        this.clearFuture();
+        return this;
+    }
+    saveHistory(epoch) {
+        this.clearFuture();
+        this.past.push({
+            nodes: toJS(this.present),
+            epoch
+        });
+        return this;
+    }
+    constructor(){
+        this.present = observable.map({});
+        this.past = observable.array([], {
+            deep: false
+        });
+        this.future = observable.array([], {
+            deep: false
+        });
+        makeObservable(this, {
+            canUndo: computed,
+            canRedo: computed,
+            undo: action,
+            redo: action,
+            clearPast: action,
+            clearFuture: action,
+            clearHistory: action,
+            saveHistory: action
+        });
+    }
+};
+export class CanvasManager {
+    get nodes() {
+        return this._history.present;
+    }
+    get canRedo() {
+        return this._history.canRedo;
+    }
+    get canUndo() {
+        return this._history.canUndo;
+    }
+    /**
+   * True when the canvas matches the last state the store is known to hold —
+   * i.e. there is nothing to save.
+   *
+   * An UNCONFIRMED baseline (see {@link updateInitialNodes}) always reads as
+   * different. The editor is loaded, but nothing in it is known to be
+   * persisted, and "clean" here disables Save: claiming a state is saved on
+   * the strength of a snapshot the server never acknowledged is how unsaved
+   * work becomes unsavable work (AGL-1262).
+   */ get isInitialSame() {
+        if (!this._initial) return true;
+        if (!this._initialConfirmed) return false;
+        return isEqual(this._initial, this.serializeNodes());
+    }
+    get didSetInitial() {
+        return Boolean(this._initial);
+    }
+    /** Whether the recorded baseline is one the store confirmed. */ get isInitialConfirmed() {
+        return this._initialConfirmed;
+    }
+    get rootNode() {
+        return this.nodes.get(NODE_ROOT_ID);
+    }
+    get nestedNodes() {
+        const root = this.rootNode;
+        if (!root) throw new Error('Missing root node');
+        return this.makeNested(root);
+    }
+    /**
+   * Resolve where a newly inserted node should attach, given the node the
+   * user had selected (the Insert menu passes the current selection). A
+   * container target — including the document-root fallback for a missing,
+   * stale, or non-node target (AGL-537) — receives the node as an appended
+   * child. A leaf target has no child slot, so the node lands as the leaf's
+   * next sibling in its own container instead, mirroring how a
+   * drag-and-drop side-drop resolves rather than nesting the node where it
+   * can never render.
+   */ resolveInsertTarget(target) {
+        var _this_getNodeParent, _ref;
+        var _parent_nodes;
+        const root = this.getNode(NODE_ROOT_ID);
+        const requested = typeof (target == null ? void 0 : target.$id) === 'string' && this.getNode(target.$id) || root;
+        if (this.nodeAcceptsChildren(requested)) {
+            return {
+                parent: requested,
+                index: NaN
+            };
+        }
+        const parent = (_this_getNodeParent = this.getNodeParent(requested)) != null ? _this_getNodeParent : root;
+        const at = (_ref = (_parent_nodes = parent.nodes) == null ? void 0 : _parent_nodes.indexOf(requested.$id)) != null ? _ref : -1;
+        return {
+            parent,
+            index: at < 0 ? NaN : at + 1
+        };
+    }
+    serializeNodes() {
+        const nodes = {};
+        this.nodes.forEach((node, id)=>{
+            nodes[id] = node.toJSON();
+        });
+        return nodes;
+    }
+    toJSON() {
+        return {
+            nodes: this.serializeNodes()
+        };
+    }
+    redo() {
+        return this.restoreSnapshot(this._history.redo(this._epoch));
+    }
+    undo() {
+        return this.restoreSnapshot(this._history.undo(this._epoch));
+    }
+    saveHistory() {
+        // Inside a batch, the snapshot the batch took is the step every mutation
+        // folds into — see `batch`.
+        if (this._batchDepth > 0) return this;
+        this._history.saveHistory(this._epoch);
+        return this;
+    }
+    /**
+   * Records that a REMOTE session changed `nodeId`, so a later local undo
+   * does not roll that change back (AGL-1958).
+   *
+   * Call this from the co-editing apply path for every node a peer creates,
+   * changes or deletes — including the delete, whose absence is as much a
+   * remote state as a value is.
+   *
+   * ## Why this is needed at all
+   *
+   * Applying a remote change deliberately does NOT record local history
+   * (AGL-677 rule 1), which keeps a colleague's edit out of your undo
+   * stack. That is necessary and it is not sufficient. Every entry already
+   * in the stack is a snapshot of the WHOLE document taken before one of
+   * your edits, and a colleague's later edit is by definition not in it. So
+   * an undo that replays such a snapshot wholesale reverts their node too,
+   * and — because the reverted map is then diffed against the co-editing
+   * shadow like any other local edit — publishes that revert back to them
+   * under YOUR session id. Their work is destroyed on their screen, with no
+   * signal and nothing that restores it.
+   *
+   * Measured before this fix: a peer's edit came back reverted, and a node
+   * the peer had CREATED was deleted outright.
+   *
+   * ## An apply that changed nothing is not a peer edit (AGL-2486)
+   *
+   * `previousJson` is the node's serialization from BEFORE the apply. When
+   * the apply left it byte-for-byte identical, this records nothing: no
+   * mark, no epoch bump. That is not an optimisation, it is the difference
+   * between a peer edit and an ECHO, and getting it wrong broke undo
+   * outright.
+   *
+   * The mirror is per node and every session in the room republishes what it
+   * holds, so a value you wrote can come back to you from ANOTHER SESSION —
+   * your own second tab most of all, which is ordinary once same-account
+   * sessions count as co-editors. The room already drops your own tab's
+   * echoes by session id, but not another session's echo of your value.
+   *
+   * Marking that echo is fatal because the mark is what {@link
+   * restoreSnapshot} reads. It lands with a FRESH epoch, therefore newer
+   * than every snapshot already on your stack, so the overlay puts the live
+   * value back over each one of them. Undo then consumed its entry and
+   * changed nothing at all — measured on the running editor, one account,
+   * two tabs on one screen: `past: 0, future: 1, canUndo: false`, the node
+   * still holding the edit that had just been undone.
+   *
+   * Note what this deliberately does NOT do: it does not ask whose session
+   * or whose account the change came from. A genuinely different value from
+   * your other tab is a real concurrent edit with its own undo stack and is
+   * protected like any other. "Foreign" keeps its one meaning — a session
+   * other than this tab moved this node — and the defect was counting a
+   * non-change as a change.
+   */ markRemoteNode(nodeId, previousJson) {
+        if (!nodeId) return this;
+        if (previousJson !== undefined) {
+            const live = this.nodes.get(nodeId);
+            const nowJson = live ? JSON.stringify(live.toJSON()) : undefined;
+            if (nowJson === previousJson) return this;
+        }
+        this._foreignAt.set(nodeId, ++this._epoch);
+        return this;
+    }
+    /**
+   * A node's serialization as it stands right now, for handing back to
+   * {@link markRemoteNode} after an apply — the "before" half of the echo
+   * test. `undefined` when the node is not in the map.
+   */ serializeNode(nodeId) {
+        const node = this.nodes.get(nodeId);
+        return node ? JSON.stringify(node.toJSON()) : undefined;
+    }
+    /**
+   * Restores a history snapshot, keeping every node a remote session has
+   * touched SINCE that snapshot was taken (AGL-1958).
+   *
+   * The epoch comparison is the whole mechanism, and it is what keeps undo
+   * honest rather than merely safe:
+   *
+   * * `foreignAt > snapshot.epoch` — the peer's change landed *after* this
+   *   snapshot, so the snapshot predates it and would roll it back. Keep
+   *   what is live now: the current value, or the node's absence when the
+   *   peer deleted it.
+   * * `foreignAt <= snapshot.epoch` — the snapshot was taken after the
+   *   peer's change and therefore already contains it. Restore it normally,
+   *   or undo would stop rewinding your own edits to co-edited nodes.
+   *
+   * A node both you and a peer changed resolves to the peer's value, which
+   * is the same last-writer-wins rule the per-node mirror applies
+   * everywhere else (AGL-677) rather than a new one invented here.
+   *
+   * A peer that adds a child republishes the parent's child list, so the
+   * parent is marked too and its list survives with the child.
+   *
+   * ## Both directions, and why redo is not the special case it looks like
+   *
+   * This serves {@link redo} as well as {@link undo}, and the stamp is what
+   * makes that work rather than a second rule (AGL-2486). A `future` entry
+   * replays a state from before the undo, so the intuition is that it must
+   * predate any later peer change and roll it back. It does not:
+   * `HistoryManager.undo` captures the present and stamps it with the epoch
+   * AT THE TIME OF THE UNDO, so a peer change that lands between the undo
+   * and the redo is strictly newer than `snapshot.epoch` and is kept here —
+   * including a node the peer CREATED in that gap, which the `future` entry
+   * has no key for at all and a bare replace would broadcast as a delete.
+   */ restoreSnapshot(snapshot) {
+        const json = Object.fromEntries(snapshot.nodes.entries());
+        this.setNodes(this.withForeignNodes(json, snapshot.epoch));
+        return this;
+    }
+    /**
+   * Overlays the nodes a remote session has touched since `sinceEpoch` onto a
+   * map about to REPLACE the canvas — the current value, or the node's
+   * absence when the peer deleted it (AGL-1958).
+   *
+   * Shared by {@link restoreSnapshot} and {@link applyNodes} because it is
+   * one rule, not two: any wholesale replace composed without knowledge of a
+   * peer's change would otherwise roll that change back and — through the
+   * co-editing diff — publish the rollback to its author.
+   *
+   * Mutates and returns `json`; callers pass a map they own.
+   */ withForeignNodes(json, sinceEpoch) {
+        for (const [nodeId, at] of this._foreignAt){
+            if (at <= sinceEpoch) continue;
+            const live = this.nodes.get(nodeId);
+            if (live) json[nodeId] = live;
+            else delete json[nodeId];
+        }
+        return json;
+    }
+    /**
+   * Whether any REMOTE session has changed this canvas since it loaded
+   * (AGL-2486).
+   *
+   * The draft prompt reads it to decide whether offering a private
+   * per-browser snapshot back is still honest: once a colleague's live work
+   * is on the canvas, applying an older whole-document snapshot is not
+   * "restore my unsaved changes" but "roll the shared canvas back".
+   *
+   * `_epoch` only ever moves in {@link markRemoteNode}, so a non-zero epoch
+   * IS "a peer has touched this canvas", and {@link reset} returns it to zero
+   * with the rest of the session.
+   */ get hasRemoteEdits() {
+        return this._epoch > 0;
+    }
+    /**
+   * Runs `mutate` as one undoable step (AGL-1204).
+   *
+   * Every mutator on this class records history for itself, but a panel that
+   * writes `node.sx` directly does not go through any of them — the Styles and
+   * custom-CSS forms assign to the node, so an undo after a style change
+   * restored the last *recorded* snapshot instead, silently discarding
+   * everything done since. This is the seam those panels were missing.
+   *
+   * **`coalesceKey` is what makes it usable for a live-applying control.**
+   * Those forms fire on every change — one per character typed, one per drag
+   * tick of a slider — so recording unconditionally would replace "undo does
+   * not step back far enough" with "undo steps back one character", which is
+   * no better. Consecutive calls sharing a key inside {@link
+   * COALESCE_WINDOW_MS} record **once**, at the start of the burst, so the
+   * snapshot is the state *before* the adjustment began. Omit the key for a
+   * discrete commit (a toggle, an Apply button) that deserves its own step.
+   *
+   * The window is evaluated on call rather than by a timer: a burst ends
+   * because the next edit arrives late, not because something fired in the
+   * background. That keeps the canvas free of pending timers it would have to
+   * cancel on {@link reset}, and keeps this testable without fake clocks.
+   *
+   * The key should identify *what* is being adjusted, not just the node —
+   * moving from Gap to Padding is a second adjustment even if it happens
+   * within the window.
+   */ transact(mutate, coalesceKey) {
+        const now = Date.now();
+        const burst = this._coalescing;
+        const continues = coalesceKey !== undefined && (burst == null ? void 0 : burst.key) === coalesceKey && now - burst.at < CanvasManager.COALESCE_WINDOW_MS;
+        if (!continues) this.saveHistory();
+        this._coalescing = coalesceKey === undefined ? undefined : {
+            key: coalesceKey,
+            at: now
+        };
+        return mutate();
+    }
+    /**
+   * Runs several mutations as ONE undoable step, all or nothing.
+   *
+   * `transact` records one snapshot and then runs code that assigns to nodes
+   * directly. That is right for a panel writing `node.sx`, and wrong for a
+   * caller that composes the guarded mutators — `addNodeFromNested`,
+   * `updateNodeProps`, `reparentNode`, `deleteNode` — because each of those
+   * records its own step. A change made of five of them would take five
+   * undos to take back, and an undo that stops part-way leaves the document
+   * in a state nobody authored.
+   *
+   * So inside a batch the mutators keep every guard and record nothing: the
+   * batch's own snapshot, taken before `mutate` runs, is the step. A nested
+   * batch folds into the outer one.
+   *
+   * A mutation that throws — a guard refusing a stale parent, a move into
+   * the node's own subtree — rolls the whole batch back to that snapshot
+   * and removes the snapshot from both stacks before the error propagates.
+   * Half a batch is not an edit anyone asked for, and a refused batch must
+   * not leave an undo step that restores a state identical to the present.
+   */ batch(mutate) {
+        if (this._batchDepth > 0) return mutate();
+        this._history.saveHistory(this._epoch);
+        // Whatever burst was open described the state before this batch.
+        this._coalescing = undefined;
+        this._batchDepth += 1;
+        let completed = false;
+        try {
+            const result = mutate();
+            completed = true;
+            return result;
+        } finally{
+            this._batchDepth -= 1;
+            // `canUndo` is only false when `mutate` itself cleared the history,
+            // and then there is no snapshot left to roll back to.
+            if (!completed && this._history.canUndo) {
+                this.restoreSnapshot(this._history.undo(this._epoch));
+                this._history.clearFuture();
+            }
+        }
+    }
+    /**
+   * Drops BOTH history stacks and any open {@link transact} burst.
+   *
+   * Both, deliberately (AGL-2486). This used to clear `past` alone, which
+   * left a caller that had just "cleared history" holding a live redo stack
+   * — `canRedo` still true, still offering a snapshot of the state before
+   * the clear. `reset` was the only caller and compensated for it a line
+   * later, which is exactly how the next caller inherits the trap.
+   *
+   * A stale redo is worse than a stale undo in a co-editing session: redo
+   * replays a WHOLE-DOCUMENT snapshot, and the restored map is diffed
+   * against the co-editing shadow and published, so every node the snapshot
+   * does not have goes out as a delete under this session's id.
+   */ clearHistory() {
+        this._history.clearHistory();
+        this._coalescing = undefined;
+    }
+    createNodeId() {
+        return createIdUrlSafe();
+    }
+    createNode(schema) {
+        return new AglynNode(_extends({}, schema, {
+            $id: (schema == null ? void 0 : schema.$id) || this.createNodeId()
+        }), this);
+    }
+    clearNodes() {
+        this.nodes.clear();
+        return this;
+    }
+    /**
+   * Returns the canvas to its pristine state (no nodes, no history, no
+   * recorded initial snapshot). The canvas is an app-level singleton shared
+   * by every editing session — call this when a session ends so the next
+   * document doesn't inherit stale content.
+   */ reset() {
+        this.clearNodes();
+        this.clearHistory();
+        this._initial = undefined;
+        this._initialConfirmed = true;
+        // A new document gets a new epoch line. Stale marks would otherwise
+        // preserve node ids that mean something else here (AGL-1958).
+        this._foreignAt.clear();
+        this._epoch = 0;
+        return this;
+    }
+    /**
+   * Record the state the canvas should be considered saved against.
+   *
+   * `confirmed` is what makes this honest. Pass `false` when the map came
+   * from a source the STORE has not acknowledged — a Firestore snapshot
+   * carrying this client's own pending write is the case that motivated it
+   * (AGL-1262): the document is loaded and must be shown, but nothing in it
+   * is known to have reached the server, so it must not be adopted as
+   * "already saved". An unconfirmed baseline keeps {@link isInitialSame}
+   * false — the editor stays savable — until a real save records a
+   * confirmed one.
+   */ updateInitialNodes(nodes, options) {
+        var _ref;
+        this._initial = nodes ? toJS(nodes) : this.serializeNodes();
+        this._initialConfirmed = (_ref = options == null ? void 0 : options.confirmed) != null ? _ref : true;
+        return this;
+    }
+    /**
+   * Promote an UNCONFIRMED baseline to a confirmed one, once the store has
+   * acknowledged the write that made it unconfirmed (AGL-2486).
+   *
+   * Without this there is no way back. `_initialConfirmed` moves to true in
+   * only two other places — {@link reset} and {@link updateInitialNodes} —
+   * and the editor records its baseline exactly once, on the first snapshot
+   * that carries nodes. A document whose first snapshot happens to carry
+   * this client's own queued write therefore reads dirty for the rest of the
+   * session over content nobody has edited.
+   *
+   * Conditional on the canvas still MATCHING the baseline, which is what
+   * keeps AGL-1262 intact. The acknowledgement is for the write that was in
+   * flight, and says nothing about work the author has done since; adopting
+   * a canvas that has moved on would call that work saved and take away the
+   * only control that could still write it.
+   *
+   * @returns whether the baseline is confirmed as a result.
+   */ confirmInitialNodes() {
+        if (!this._initial) return false;
+        if (this._initialConfirmed) return true;
+        if (!isEqual(this._initial, this.serializeNodes())) return false;
+        this._initialConfirmed = true;
+        return true;
+    }
+    /**
+   * Registers a node in the map AND lists it on `parent`, in one action
+   * (AGL-1366).
+   *
+   * `parent` is required, and that is the whole point: this was the last way
+   * left to put an entry in `this.nodes` with no parent linkage at all. The
+   * besigner saves a flat map and renders a tree — `serializeNodes` dumps
+   * every entry in the map while the renderer walks child lists down from
+   * `NODE_ROOT_ID` — so a node the map holds and no parent lists is not a
+   * rendering glitch that a reload clears. It is saved on every save,
+   * shipped in every payload, counted against the 1 MiB ceiling, and never
+   * drawn. That is the mechanism behind the 61 unreachable nodes `/product`
+   * served, 26 of them carrying the only copy of two Hero sections' text
+   * (AGL-1363).
+   *
+   * An *optional* parent would not have closed it, because the caller who
+   * omits it is precisely the caller who creates the orphan. So the linkage
+   * is not a second step a caller may forget — it happens here, and the
+   * parent is resolved through `getNode($id)` and throws on a miss: the same
+   * guard `addNodeFromNested` has carried since AGL-537 and `reparentNode`
+   * took on in AGL-1363, rather than a second mechanism. A stale instance a
+   * panel closure kept across a co-editor's merge, or a parent a peer has
+   * since deleted, therefore fails loud instead of stranding the node.
+   *
+   * Linking is idempotent: re-setting a node its parent already lists
+   * replaces the map entry and leaves the child list untouched, so this
+   * stays usable as an update.
+   *
+   * The root is refused outright — it has no parent to be listed on, and
+   * seeding it belongs to `setNodes`, which alone keeps its canonical id.
+   */ setNode(node, parent, index = NaN, create = false) {
+        if (!node) throw new Error('Invalid node');
+        if (!create && !node.$id) throw new Error('Invalid node id');
+        if (this.isRootNode(node)) throw new Error('Cannot set root node');
+        // Resolve through the LIVE map BEFORE anything is inserted, so a refused
+        // call leaves the canvas exactly as it found it.
+        const parentId = typeof parent === 'string' ? parent : parent == null ? void 0 : parent.$id;
+        const target = parentId != null ? this.getNode(parentId) : undefined;
+        if (!target) throw new Error('Invalid parent node');
+        return runInAction(()=>{
+            const _node = create ? this.createNode(node) : node;
+            // Both directions of the link are set here; a `parentId` disagreeing
+            // with the list that holds the id is the same orphan by another route.
+            _node.parentId = target.$id;
+            this.nodes.set(_node.$id, _node);
+            // Read-back, not `(target.nodes ||= []).push()` — see reparentNode
+            // (AGL-763): the `||=` value is the detached plain array on an
+            // observable.
+            if (!target.nodes) target.nodes = [];
+            if (!target.nodes.includes(_node.$id)) {
+                if (isNaN(index)) target.nodes.push(_node.$id);
+                else target.nodes.splice(index, 0, _node.$id);
+            }
+            return this.nodes.get(_node.$id);
+        });
+    }
+    setNodes(schemas, merge = false) {
+        if (!schemas) throw new Error('Invalid schemas');
+        // Replacing the map ends any open {@link transact} burst (AGL-1204).
+        // This is the seam a co-editor's incoming change arrives through, and
+        // the one an undo restores through: in both cases the state the open
+        // burst snapshotted is no longer the state the next edit is adjusting,
+        // so the next edit must record its own step rather than fold into it.
+        this._coalescing = undefined;
+        const cloned = toJS(schemas);
+        const nodes = {};
+        for(const nodeId in cloned){
+            var _node_$id;
+            const node = cloned[nodeId];
+            if (!node) continue;
+            // Persisted maps key nodes by id. Early seeds omitted $id (which used
+            // to mint a random one), and the root must always keep the canonical
+            // id — the map key is authoritative.
+            const $id = nodeId === NODE_ROOT_ID ? NODE_ROOT_ID : (_node_$id = node.$id) != null ? _node_$id : nodeId;
+            nodes[nodeId] = this.createNode(_extends({}, node, {
+                $id
+            }));
+        }
+        if (merge) {
+            this.nodes.merge(nodes);
+        } else {
+            this.nodes.replace(nodes);
+        }
+        return this;
+    }
+    /**
+   * Replaces the whole node map with a map the USER supplied — the raw-JSON
+   * editor, and the local draft the crash net offers back (AGL-2486).
+   *
+   * Snapshots first, so the replacement is undoable — unlike `setNodes`,
+   * which also serves the history-restore and initial-load paths.
+   *
+   * **Every node a remote session has touched survives it**, on exactly the
+   * reasoning AGL-1958 established for undo. A wholesale replace is the same
+   * shape of write as a snapshot restore: the map being applied was composed
+   * without any knowledge of the peer's later changes, and the result is
+   * diffed against the co-editing shadow and published, so a node the map
+   * happens to lack is broadcast as a DELETE under this session's id.
+   * Measured on the running editor before this changed (AGL-2486): a peer
+   * created a node, the other session pressed Restore, and the node vanished
+   * from the peer's own canvas with an RTDB tombstone to show for it.
+   *
+   * Every mark counts, not only those newer than some epoch: unlike a
+   * snapshot, an applied map carries no epoch of its own, and a draft was by
+   * definition composed before this page joined the room.
+   */ applyNodes(value) {
+        this.saveHistory();
+        const parsed = this.processNodesToDenormalized(value);
+        return this.setNodes(this.withForeignNodes(_extends({}, parsed), 0));
+    }
+    deleteNode(node) {
+        const validateNode = (node)=>{
+            if (!node || !(node == null ? void 0 : node.$id) || !(node == null ? void 0 : node.parentId)) throw new Error('Invalid node');
+            if (this.isRootNode(node)) throw new Error('Cannot delete root node');
+        };
+        validateNode(node);
+        this.saveHistory();
+        const del = (node)=>{
+            var _ref;
+            var _parent_nodes, _parent_nodes1;
+            validateNode(node);
+            const parent = this.getNode(node.parentId);
+            if (!parent) throw new Error('Invalid parent node');
+            const index = (_ref = (_parent_nodes = parent.nodes) == null ? void 0 : _parent_nodes.indexOf(node.$id)) != null ? _ref : -1;
+            const nodes = toJS(node.nodes || []);
+            for (const childId of [
+                ...nodes
+            ]){
+                const child = this.getNode(childId);
+                if (child) del(child);
+            }
+            if (index > -1) (_parent_nodes1 = parent.nodes) == null ? void 0 : _parent_nodes1.splice(index, 1);
+            this.nodes.delete(node.$id);
+        };
+        del(node);
+        return this;
+    }
+    /**
+   * Moves a node under `newParent`, resolving BOTH ends through the live
+   * node map first (AGL-1363).
+   *
+   * The resolution is the guard, and it is the same one `addNodeFromNested`
+   * has carried since AGL-537. This method splices the node out of its
+   * *live* old parent and then attaches it to the object it was handed — so
+   * a `newParent` that is merely SHAPED like a node (a stale instance a
+   * panel closure kept across a co-editor's merge, a node a peer has since
+   * deleted, historically a click event) took the node out of the tree and
+   * pushed its id onto a detached array. Nothing put it back.
+   *
+   * That is not a recoverable glitch: `serializeNodes` dumps the whole map
+   * while the renderer walks the tree from `NODE_ROOT_ID`, so a node in the
+   * map that no live parent lists is saved on every save, shipped in every
+   * payload, counted against the 1 MiB ceiling — and never drawn. It is why
+   * `/product` served 61 unreachable nodes, 26 of them carrying the only
+   * copy of two Hero sections' text. Fail loud instead.
+   *
+   * `index` is the node's position in the resulting sibling list — i.e. it is
+   * read AFTER the node has been spliced out of wherever it was. A caller
+   * holding a drop marker ("put it before the sibling currently at 3") is
+   * describing the list BEFORE the removal and has to convert; the dnd
+   * manager does exactly that for same-parent drops.
+   */ reparentNode(node, newParent, index = NaN) {
+        var _ref;
+        var _oldParent_nodes, _oldParent_nodes1;
+        if (!node) throw new Error('Invalid node');
+        if (this.isRootNode(node)) throw new Error('Cannot move root node');
+        if (!newParent) throw new Error('Invalid parent node');
+        // Every refusal below runs before `saveHistory`: a move that never
+        // happened must not leave an undo step behind it.
+        const target = node.$id != null ? this.getNode(node.$id) : undefined;
+        if (!target) throw new Error('Invalid node');
+        const parent = newParent.$id != null ? this.getNode(newParent.$id) : undefined;
+        if (!parent) throw new Error('Invalid parent node');
+        const oldParent = this.getNodeParent(target);
+        const oldIndex = (_ref = oldParent == null ? void 0 : (_oldParent_nodes = oldParent.nodes) == null ? void 0 : _oldParent_nodes.indexOf(target.$id)) != null ? _ref : -1;
+        const sameParent = (oldParent == null ? void 0 : oldParent.$id) === parent.$id;
+        if (!sameParent) {
+            var _this_getNodeBreadcrumbPath;
+            // A node into its own subtree detaches that subtree from the document
+            // and hands the renderer a cycle. `breadcrumbPath` is the ancestor
+            // chain, so the target appearing in the new parent's is the whole test
+            // — and it covers `parent === target` on its own.
+            if ((_this_getNodeBreadcrumbPath = this.getNodeBreadcrumbPath(parent)) == null ? void 0 : _this_getNodeBreadcrumbPath.some((id)=>id === target.$id)) {
+                throw new Error('Cannot move an element inside itself');
+            }
+            /**
+       * The gate that was missing (AGL-1405). `nodeAcceptsChildren` guarded
+       * every path that CREATES a node — the Insert menu and paste through
+       * `resolveInsertTarget`, drag-and-drop through the dnd manager — but
+       * not the one that MOVES one. So a `markdown` block (or any component
+       * whose content is an attribute: a Reusable Component instance, a
+       * Layout Slot, a List Item Text) could still be handed a child, which
+       * it then renders nowhere. That is not a cosmetic mistake: the node is
+       * saved on every save and shipped in every payload while the page it
+       * belongs to shows nothing, so the work reads as never done rather
+       * than broken. Three /press screenshots are still sitting in exactly
+       * that hole, and the point of the click-path this guard protects is
+       * that it must not be able to dig another one.
+       *
+       * A same-parent reorder is deliberately NOT gated: the nodes already
+       * trapped by AGL-1388 have to stay shufflable, and `reorderNode`
+       * routes Shift up / Shift down straight through here.
+       */ // Deliberately label-free: `getNodeLabelShort` reaches into the
+            // component registry, and a refusal path that can itself throw is no
+            // refusal at all. Callers that want "Markdown can't hold elements"
+            // name the node themselves — `moveNodeOut`/`moveNodeIn` do.
+            if (!this.nodeAcceptsChildren(parent)) {
+                throw new Error('That element cannot hold other elements');
+            }
+        }
+        // Assign then read back, never `(x.nodes ||= []).push()` (AGL-763). A
+        // live node is a `makeAutoObservable` proxy: assigning a fresh `[]` stores
+        // an observable copy, but the `||=` expression evaluates to the plain
+        // array that was assigned — so pushing onto it writes to a detached array
+        // and the child silently orphans. `AglynNode`'s constructor seeds `nodes`
+        // so this never actually fires today, but relying on that invariant from
+        // here is how the same defect returned as AGL-759.
+        if (!parent.nodes) parent.nodes = [];
+        // Resolve the landing slot against the list as it will be AFTER the
+        // removal, and clamp it. `splice(-1, 0, id)` inserts before the LAST
+        // element, so an unclamped negative index moved a first child DOWN —
+        // `reorderNode(node, node.index - 1)` on index 0 did precisely that, and
+        // only the menu's `disabled` prop hid it.
+        const settled = parent.nodes.length - (sameParent && oldIndex > -1 ? 1 : 0);
+        const at = isNaN(index) ? settled : Math.min(Math.max(index, 0), settled);
+        // A move that resolves to the slot the node already occupies is not a
+        // move. It used to cost an undo step anyway — which is how a hierarchy
+        // drag came to "record an undo entry without moving anything" (AGL-1405),
+        // and worse, made the next Undo discard the author's PREVIOUS edit.
+        if (sameParent && at === oldIndex) return target;
+        this.saveHistory();
+        if (oldIndex > -1) oldParent == null ? void 0 : (_oldParent_nodes1 = oldParent.nodes) == null ? void 0 : _oldParent_nodes1.splice(oldIndex, 1);
+        if (!sameParent) target.parentId = parent.$id;
+        parent.nodes.splice(at, 0, target.$id);
+        return target;
+    }
+    reorderNode(node, index = NaN) {
+        if (!node) throw new Error('Invalid node');
+        // Resolve the node first, so the parent is read off the LIVE node's
+        // `parentId` rather than a stale copy's (AGL-1363).
+        const target = node.$id != null ? this.getNode(node.$id) : undefined;
+        if (!target) throw new Error('Invalid node');
+        const parent = this.getNodeParent(target);
+        if (!parent) throw new Error('Invalid parent node');
+        return this.reparentNode(target, parent, index);
+    }
+    duplicateNode(node) {
+        var _ref;
+        var _parent_nodes;
+        if (!node) throw new Error('Invalid node');
+        if (this.isRootNode(node)) throw new Error('Cannot duplicate root node');
+        const parent = this.getNodeParent(node);
+        if (!parent) throw new Error('Invalid parent node');
+        const duplicateNodeAndChildren = (node, parentId, index = NaN)=>{
+            if (!node) throw new Error('Invalid node');
+            const json = toJS(node);
+            // `setNode` registers the copy AND lists it on its parent, so no copy
+            // can be left in the map unreferenced — the linkage is no longer a
+            // separate step this recursion could get wrong (AGL-1366).
+            const newNode = this.setNode(this.createNode(_extends({}, json, {
+                $id: this.createNodeId(),
+                parentId,
+                nodes: []
+            })), parentId, index);
+            if (!json) return newNode;
+            for (const childId of arraySafe(json.nodes)){
+                const child = childId && this.getNode(childId);
+                if (child) duplicateNodeAndChildren(child, newNode.$id);
+            }
+            return newNode;
+        };
+        this.saveHistory();
+        const nodeIndex = this.getNodeIndex(node);
+        const index = nodeIndex === -1 ? (_ref = (_parent_nodes = parent.nodes) == null ? void 0 : _parent_nodes.length) != null ? _ref : 0 : nodeIndex + 1;
+        // One action, so observers never see the copy listed on its parent
+        // before its own subtree has been built under it.
+        return runInAction(()=>duplicateNodeAndChildren(node, node.parentId, index));
+    }
+    createDuplicateNode(node) {
+        const $id = this.createNodeId();
+        const cloned = toJS(node);
+        const nodes = Array.isArray(cloned == null ? void 0 : cloned.nodes) ? [
+            ...cloned.nodes
+        ] : [];
+        const res = _extends({}, cloned, {
+            $id,
+            nodes: []
+        });
+        for (const child of nodes){
+            const childDuplicate = this.createDuplicateNode(_extends({}, child, {
+                parentId: $id
+            }));
+            res.nodes.push(childDuplicate);
+        }
+        return res;
+    }
+    /**
+   * Insert a *detached* nested subtree as a child of `parent`, minting a
+   * fresh id for every node in it (AGL-1202).
+   *
+   * The subtree is plain JSON with no ties to this canvas, so the source can
+   * be anything — an element preset, the besigner clipboard, or a subtree
+   * copied out of a different document altogether. Callers are responsible
+   * for checking that the root's component is registered and that the
+   * lineal relationship with `parent` is allowed; this method only does the
+   * structural work.
+   */ addNodeFromNested(nested, parent, index = NaN) {
+        if (!nested) throw new Error('Invalid node');
+        // Attach to the live node in this canvas. A caller-supplied object
+        // that is not in the node map (a stale reference — or historically the
+        // console INSERT menu's click event) would otherwise get the child id
+        // pushed onto ITS `nodes` array while the child lands in the map as a
+        // detached node: absent from the hierarchy, the canvas, and saves
+        // (AGL-537). Fail loud instead of corrupting the tree.
+        const target = (parent == null ? void 0 : parent.$id) != null ? this.getNode(parent.$id) : undefined;
+        if (!target) throw new Error('Invalid parent node');
+        this.saveHistory();
+        const duplicate = this.createDuplicateNode(nested);
+        duplicate.parentId = target.$id;
+        const parsed = this.processNodesToDenormalized(duplicate);
+        // Register the subtree and append the child id in one action so
+        // observers never see the intermediate detached state.
+        runInAction(()=>{
+            this.setNodes(parsed, true);
+            // Read-back, not `(target.nodes ||= []).push()` — see reparentNode
+            // (AGL-763): the `||=` value is the detached plain array on an observable.
+            if (!target.nodes) target.nodes = [];
+            if (isNaN(index)) target.nodes.push(duplicate.$id);
+            else target.nodes.splice(index, 0, duplicate.$id);
+        });
+        return this.getNode(duplicate.$id);
+    }
+    addNodeFromPreset(preset, parent, index = NaN) {
+        if (!preset) throw new Error('Invalid preset');
+        return this.addNodeFromNested(toJS(preset).data, parent, index);
+    }
+    /**
+   * REPLACES a node's props — callers spread the current ones to merge.
+   *
+   * An editor form submits every field it renders, so keys the author left
+   * empty arrive as `undefined`. Those are dropped here rather than stored as
+   * own keys (AGL-1334): for a props bag that is REPLACED wholesale, absent IS
+   * cleared, and an `undefined` member is a value no storage layer accepts.
+   * `AglynNode.toJSON` strips again at the write boundary — this one keeps the
+   * live tree honest for everything that reads it before a save.
+   */ /**
+   * Writes top-level node FIELDS, with an undo step.
+   *
+   * The sibling of {@link updateNodeProps}, and it exists for the same two
+   * reasons that one documents. An edit with no `saveHistory` is an edit the
+   * author cannot take back — and every panel that assigned to a node
+   * directly was quietly in that state. And it re-resolves by `$id`: callers
+   * hold node objects across time (the focus store keeps the selection that
+   * way), while every wholesale replace of the map — `undo`, `redo`,
+   * `applyNodes`, a draft restore — builds fresh instances. Assigning to the
+   * caller's copy then mutates an orphan: no error, no dirty state, and the
+   * author's edit is simply gone.
+   *
+   * Only the keys the patch names are touched, and `undefined` clears one —
+   * which is how a cleared style or a shown element is stored, since `toJSON`
+   * omits what is undefined.
+   */ updateNodeFields(node, patch) {
+        var _this_getNode;
+        if (!node) throw new Error('Invalid node');
+        this.saveHistory();
+        const target = (_this_getNode = this.getNode(node.$id)) != null ? _this_getNode : node;
+        Object.assign(target, patch);
+    }
+    updateNodeProps(node, props) {
+        var _this_getNode;
+        if (!node) throw new Error('Invalid node');
+        this.saveHistory();
+        // Write to the node the MAP holds, not the reference the caller kept
+        // (AGL-2486). Callers hold node objects across time — the besigner's
+        // focus store keeps the selection that way — and every wholesale replace
+        // of the map (`undo`, `redo`, `applyNodes`, a draft restore) builds fresh
+        // instances. Assigning to the caller's copy then mutates an orphan: no
+        // error, no dirty state, and the author's edit is simply gone. Re-resolve
+        // by `$id` so the write always reaches the canvas.
+        //
+        // The fallback keeps a node that is genuinely not in the map — deleted,
+        // or never inserted — behaving as before rather than being resurrected.
+        const target = (_this_getNode = this.getNode(node.$id)) != null ? _this_getNode : node;
+        target.props = stripUndefinedDeep(_extends({}, props));
+    }
+    static nestDenormalizedNodes(nodes, rootId = NODE_ROOT_ID) {
+        var _rootNode_nodes;
+        const rootNode = nodes[rootId];
+        if (!rootNode) throw new Error('Invalid root node');
+        const response = _extends({}, rootNode);
+        const children = [];
+        // `?? []`, not `||= []` — a read-only walk should not mutate its input
+        // (AGL-763).
+        for (const id of (_rootNode_nodes = rootNode.nodes) != null ? _rootNode_nodes : []){
+            const child = _extends({}, nodes[id]);
+            const nestedChild = this.nestDenormalizedNodes(nodes, child.$id);
+            children.push(nestedChild);
+        }
+        response.nodes = children;
+        return response;
+    }
+    denormalizeNodes(nodes, parentId, accumulator = {}) {
+        return CanvasManager.denormalizeNodes(nodes, parentId, accumulator);
+    }
+    static denormalizeNodes(nodes, parentId, accumulator = {}) {
+        for (const childNode of Array.isArray(nodes) ? nodes : []){
+            const child = _isStrT(childNode) && accumulator[childNode] ? accumulator[childNode] : childNode;
+            if (!_isObj(child)) continue;
+            const node = cloneDeep(child);
+            // TODO: Remove after migration to nodes property
+            if (node['elements']) {
+                node.nodes = node['elements'];
+                delete node['elements'];
+            }
+            // TODO: Remove after migration to pluginId property
+            if (node['bundleId']) {
+                node.pluginId = node['bundleId'];
+                delete node['bundleId'];
+            }
+            const nodes = node == null ? void 0 : node.nodes;
+            const nodesArray = [
+                ...Array.isArray(nodes) ? nodes : []
+            ].filter(Boolean);
+            accumulator[node.$id] = _extends({}, node, {
+                parentId,
+                nodes: [
+                    ...nodesArray
+                ].map((i)=>{
+                    if (_isStrT(i)) return i;
+                    if (_isObj(i)) return i.$id;
+                    return null;
+                }).filter(Boolean)
+            });
+            this.denormalizeNodes(nodesArray, node.$id, accumulator);
+        }
+        return accumulator;
+    }
+    processNodesToDenormalized(value) {
+        return CanvasManager.processNodesToDenormalized(value);
+    }
+    static processNodesToDenormalized(value) {
+        let response = {};
+        const isArray = Array.isArray(value);
+        if (isArray && value.length === 1) {
+            const item = value[0];
+            if ((item == null ? void 0 : item.$id) === NODE_ROOT_ID) {
+                response = this.denormalizeNodes([
+                    _extends({}, item, {
+                        parentId: null
+                    })
+                ], NODE_ROOT_ID, response);
+            } else if ((item == null ? void 0 : item.parentId) === NODE_ROOT_ID || item && item.parentId) {
+                response = this.denormalizeNodes([
+                    {
+                        $id: NODE_ROOT_ID,
+                        componentId: 'div',
+                        nodes: [
+                            item
+                        ]
+                    }
+                ], NODE_ROOT_ID, response);
+            } else if (item == null ? void 0 : item.parentId) {
+                response = this.denormalizeNodes([
+                    {
+                        $id: item == null ? void 0 : item.parentId,
+                        componentId: 'div',
+                        nodes: [
+                            item
+                        ]
+                    }
+                ], item == null ? void 0 : item.parentId, response);
+            } else {
+                response = this.denormalizeNodes([
+                    {
+                        $id: NODE_ROOT_ID,
+                        componentId: 'div',
+                        nodes: []
+                    }
+                ], NODE_ROOT_ID, response);
+            }
+        } else if (isArray) {
+            response = this.denormalizeNodes([
+                {
+                    $id: NODE_ROOT_ID,
+                    componentId: 'div',
+                    nodes: [
+                        ...value
+                    ]
+                }
+            ], NODE_ROOT_ID, response);
+        } else if (_isObj(value) && Array.isArray(value == null ? void 0 : value.nodes) && typeof value.nodes[0] !== 'string') {
+            const _value = _extends({}, value);
+            response = this.denormalizeNodes([
+                _value
+            ], (_value == null ? void 0 : _value.parentId) || NODE_ROOT_ID, response);
+        } else {
+            response = value;
+        }
+        return response;
+    }
+    constructor(aglyn){
+        this.aglyn = aglyn;
+        this._initial = undefined;
+        /**
+   * Whether {@link _initial} is a state the STORE has confirmed, or merely
+   * one the client believes. See {@link updateInitialNodes}.
+   */ this._initialConfirmed = true;
+        /** The open {@link transact} burst, if any. See that method. */ this._coalescing = undefined;
+        /** How deep the running {@link batch} calls are nested; 0 outside one. */ this._batchDepth = 0;
+        /**
+   * Monotonic counter, bumped once per node a REMOTE session changes. See
+   * {@link markRemoteNode} and {@link restoreSnapshot} (AGL-1958).
+   */ this._epoch = 0;
+        /** Node id → the {@link _epoch} at which a remote session last touched it. */ this._foreignAt = new Map();
+        this.hasNode = computedFn(($id)=>{
+            return this.nodes.has($id);
+        });
+        this.getNode = computedFn(($id)=>{
+            if (!$id) return;
+            return this.nodes.get($id);
+        });
+        this.nodesAreEqual = computedFn((left, right)=>{
+            const _right = right ? right : this.nodes;
+            return isEqual(toJS(left), toJS(_right));
+        });
+        this.getNodeParent = computedFn((node)=>{
+            if (!node) throw new Error('Invalid node');
+            if (!node.parentId) return;
+            return this.getNode(node.parentId);
+        });
+        this.getNodeIndex = computedFn((node)=>{
+            var _ref;
+            var _parent_nodes;
+            if (!node || !node.$id) throw new Error('Invalid node');
+            const parent = this.getNodeParent(node);
+            if (!parent) throw new Error('Invalid parent node');
+            return (_ref = (_parent_nodes = parent.nodes) == null ? void 0 : _parent_nodes.indexOf(node.$id)) != null ? _ref : -1;
+        });
+        this.isRootNodeId = computedFn((id)=>{
+            return id === NODE_ROOT_ID;
+        });
+        this.isRootNode = computedFn((node)=>{
+            return (node == null ? void 0 : node.$id) === NODE_ROOT_ID;
+        });
+        this.getNodeBreadcrumbPath = computedFn((nodeOrId)=>{
+            const hierarchy = [
+                NODE_ROOT_ID
+            ];
+            // Visited ids, not just the root check: the root terminates the walk on
+            // a well-formed document, but two nodes that parent each other
+            // terminate nothing. An unbounded ancestor walk is a synchronous
+            // infinite loop on the renderer's main thread — the tab stops answering
+            // input entirely — so a malformed tree has to cost a truncated
+            // breadcrumb instead.
+            const seen = new Set();
+            let currentId = typeof nodeOrId !== 'string' ? nodeOrId == null ? void 0 : nodeOrId.$id : nodeOrId;
+            while(currentId && !this.isRootNodeId(currentId) && !seen.has(currentId)){
+                var _this_getNode;
+                seen.add(currentId);
+                hierarchy.splice(1, 0, currentId);
+                currentId = (_this_getNode = this.getNode(currentId)) == null ? void 0 : _this_getNode.parentId;
+            }
+            return hierarchy;
+        });
+        this.getNodeLabelShort = computedFn((node)=>{
+            var _node_props;
+            if (!node) throw new Error('Invalid node');
+            if (this.isRootNode(node)) return NODE_ROOT_LABEL;
+            // A reusable-component instance stands for one specific definition, and
+            // its component label is the same generic word for every one of them —
+            // a page built from promoted sections reads as a column of identical
+            // "Reusable Component" rows in the hierarchy and identical badges on the
+            // canvas. The definition's name rides on the instance for exactly this
+            // (`props.name`, AGL-1193), so prefer it. An explicit per-node `name`
+            // still wins, since that is someone deliberately renaming this instance.
+            const instanceName = node.componentId === REUSABLE_INSTANCE_COMPONENT_ID ? (_node_props = node.props) == null ? void 0 : _node_props.name : undefined;
+            const componentLabel = node.componentId && this.aglyn.components.getLabel(node.componentId);
+            return (node == null ? void 0 : node.name) || (_isStrT(instanceName) ? instanceName : undefined) || componentLabel || (node == null ? void 0 : node.$id);
+        });
+        /**
+   * Whether a node can host inserted child nodes. The document root and
+   * layout containers (Stack, Section, Container — anything with a real
+   * children slot) can; a leaf whose component is self-closing or renders
+   * its `children` as inline text (a screen link, button, icon, image) has
+   * no slot to receive them and can't. Components with no registered schema
+   * default to accepting children.
+   *
+   * `flags.dropping: DISABLED` is the third way to say "no canvas child
+   * slot" (AGL-1388), for components that are neither self-closing nor text
+   * leaves but still have nowhere to put a dropped node:
+   *
+   * - Markdown renders the parsed `content` prop and nothing else, so a
+   *   dropped element lands somewhere the markdown source cannot say.
+   * - A Reusable Component instance is opaque: compose REPLACES its child
+   *   list with the grafted definition subtree, so a canvas-dropped child is
+   *   destroyed before the page is rendered.
+   * - A Layout Slot's children come from screen composition.
+   *
+   * The flag was declared on all three, and until now nothing read it —
+   * which is exactly how three /press screenshots came to be parented under
+   * a Markdown node, shipped in the page payload, and never drawn. A
+   * container that accepts children in the hierarchy and discards them at
+   * render is silent data loss: the author sees the nodes in the tree and
+   * the published page does not have them.
+   *
+   * The rule itself lives in {@link schemaAcceptsChildren} (AGL-1389) so the
+   * registry audit that enforces it cannot be checking a *copy* of it — a
+   * second implementation would drift, and would then certify the editor's
+   * behaviour against a rule the editor no longer follows.
+   */ this.nodeAcceptsChildren = computedFn((node)=>{
+            var _this_aglyn_components, _this_aglyn;
+            if (!node) return false;
+            if (this.isRootNode(node)) return true;
+            return schemaAcceptsChildren((_this_aglyn = this.aglyn) == null ? void 0 : (_this_aglyn_components = _this_aglyn.components) == null ? void 0 : _this_aglyn_components.getSchema(node.componentId));
+        });
+        this.makeNested = computedFn((node)=>{
+            // Serialize to a plain schema object: a toJS copy would carry the node's
+            // own toJSON arrow (bound to the live instance), which JSON.stringify
+            // would then prefer over the nested structure built here.
+            const newNode = node instanceof AglynNode ? node.toJSON() : _extends({}, toJS(node));
+            const childNodes = [];
+            for (const childId of toJS(node.nodes) || []){
+                const child = this.getNode(childId);
+                if (child) {
+                    const nested = this.makeNested(child);
+                    childNodes.push(nested);
+                }
+            }
+            newNode.nodes = childNodes;
+            return newNode;
+        });
+        makeObservable(this, {
+            _initial: observable.ref,
+            _initialConfirmed: observable,
+            // Observable so {@link hasRemoteEdits} is a computed a React observer
+            // re-renders on: the draft prompt has to stop offering Restore the
+            // moment a peer's first change lands, not on the next unrelated
+            // render (AGL-2486).
+            _epoch: observable,
+            nodes: computed,
+            isInitialSame: computed,
+            didSetInitial: computed,
+            hasRemoteEdits: computed,
+            markRemoteNode: action,
+            undo: action,
+            redo: action,
+            saveHistory: action,
+            // An action so the snapshot and the mutation land in ONE mobx
+            // transaction — otherwise `saveHistory` alone notifies observers, and
+            // the canvas renders a frame between the two (AGL-1204).
+            transact: action,
+            // Same reason: several guarded mutators composed into one change are
+            // one render, not one per mutator.
+            batch: action,
+            clearHistory: action,
+            clearNodes: action,
+            reset: action,
+            updateInitialNodes: action,
+            confirmInitialNodes: action,
+            setNode: action,
+            setNodes: action,
+            applyNodes: action,
+            deleteNode: action,
+            reparentNode: action,
+            reorderNode: action,
+            updateNodeFields: action,
+            updateNodeProps: action
+        });
+        this._history = new HistoryManager();
+    }
+}
+/**
+   * How long a coalesced burst stays open. Comfortably above typing cadence
+   * and slider tick rate, well below the pause that means "a new adjustment".
+   */ CanvasManager.COALESCE_WINDOW_MS = 500;
+export default CanvasManager;
+
+//# sourceMappingURL=canvas-manager.js.map