@pascal-app/mcp 1.0.6 → 1.0.7

package/dist/bridge/scene-bridge.js

@@ -1,21 +1,32 @@
 // Side-effect import MUST come first: installs RAF polyfill before core loads.
 import './node-shims.js';
-import { adjacentLevelId, applyStructureReconciliation, assertDerivedNodeWrites, changedStairOpeningOwners, floorOpeningTargets, HIDDEN_SITE_NOTE, pauseSceneHistory, pauseSpaceDetection, planNodeDeletion, planOwnedFloorOpenings, planWallDeletion, resumeSceneHistory, resumeSpaceDetection, runAsSingleSceneHistoryStep, stairDeckLevelId, structureChangeBatch, } from '@pascal-app/core';
+import { applyStructureReconciliation, assertDerivedNodeWrites, HIDDEN_SITE_NOTE, pauseSceneHistory, pauseSpaceDetection, planNodeDeletion, planWallDeletion, resumeSceneHistory, resumeSpaceDetection, structureChangeBatch, } from '@pascal-app/core';
+import { declareActionDependencies, liveSceneRuntime, materialize, runAsSettledSceneStep, } from '@pascal-app/core/runtime';
 import { AnyNode as AnyNodeSchema, generateId, parseNode, SceneMaterial, } from '@pascal-app/core/schema';
-// Per PLAN §0.6: `useScene` is the DEFAULT export from `@pascal-app/core/store`.
-import useScene from '@pascal-app/core/store';
 import { InMemoryAgentSession } from './agent-session.js';
 /**
- * Headless bridge to the `@pascal-app/core` Zustand store.
+ * Headless bridge to a `@pascal-app/core` scene store: the editor's own (the default), or a
+ * detached scene's (`@pascal-app/core/runtime`), whose host passes it as `runtime`.
  *
- * All mutation flows through the real core store so undo/redo works via Zundo.
- * No renderer is attached; `dirtyNodes` accumulates and can be drained via
- * `flushDirty()` for observability.
+ * All mutation flows through the real core store so undo/redo works via Zundo. Reads go through
+ * the runtime's reader (recorded on a detached scene), and writes run in its scope: its history
+ * environment, its id allocator, its disposal guard. No renderer is attached; `dirtyNodes`
+ * accumulates and can be drained via `flushDirty()` for observability.
  */
 export class SceneBridge {
     /** `applyPatch` takes `upsert_material` patches, in the patch's one history step. */
     supportsMaterialUpserts = true;
     activeScene = null;
+    runtime;
+    constructor(options = {}) {
+        this.runtime = options.runtime ?? liveSceneRuntime;
+    }
+    get store() {
+        return this.runtime.store;
+    }
+    write(run) {
+        return this.runtime.run(run);
+    }
     /** What the agent's session has kept: its named moments, and what it made. */
     agentSession = new InMemoryAgentSession();
     /**
@@ -42,24 +53,30 @@ export class SceneBridge {
     /** Load initial state; if empty, creates default Site → Building → Level. */
     loadDefault() {
         this.agentSession.replace();
-        useScene.getState().loadScene();
+        this.write(() => this.store.getState().loadScene());
     }
     /** Replace entire scene (undoable via Zundo). */
     setScene(nodes, rootNodeIds, extra) {
         this.agentSession.replace();
-        useScene.getState().setScene(nodes, rootNodeIds, extra);
+        // The store takes its own copy: a detached scene freezes what it holds.
+        const owned = structuredClone(materialize({ nodes, rootNodeIds, extra }));
+        this.write(() => this.store.getState().setScene(owned.nodes, owned.rootNodeIds, owned.extra));
     }
     /** Full snapshot for export, including collections and the material palette. */
     exportJSON() {
-        const state = useScene.getState();
+        const state = this.store.getState();
+        const reader = this.runtime.reader();
+        // Everything exported is read through the reader: materials and the plugin list included.
+        const materials = Object.fromEntries(reader.query({ entity: 'material' }).map((material) => [material.id, material]));
+        const installedPlugins = reader.installedPlugins();
         // Deep-clone so callers can't mutate store state directly.
         return JSON.parse(JSON.stringify({
-            nodes: state.nodes,
-            rootNodeIds: state.rootNodeIds,
-            collections: state.collections ?? {},
-            materials: state.materials ?? {},
-            ...(state.hasExplicitPluginInstallState || state.installedPlugins.length > 0
-                ? { installedPlugins: state.installedPlugins }
+            nodes: reader.nodes,
+            rootNodeIds: this.getRootNodeIds(),
+            collections: reader.collections ?? {},
+            materials,
+            ...(state.hasExplicitPluginInstallState || installedPlugins.length > 0
+                ? { installedPlugins }
                 : {}),
         }));
     }
@@ -120,27 +137,34 @@ export class SceneBridge {
     }
     /** Read a single node, or `null` if not present. */
     getNode(id) {
-        const node = useScene.getState().nodes[id];
-        return node ?? null;
+        return this.runtime.reader().get(id) ?? null;
     }
-    /** All nodes (live reference into the store — do NOT mutate). */
+    /** All nodes (a read-only view of the store's current nodes — do NOT mutate). */
     getNodes() {
-        return useScene.getState().nodes;
+        return this.runtime.reader().nodes;
     }
     getCollections() {
-        return useScene.getState().collections;
+        return this.runtime.reader().collections;
     }
     getMaterials() {
-        return useScene.getState().materials;
+        return Object.fromEntries(this.runtime
+            .reader()
+            .query({ entity: 'material' })
+            .map((material) => [material.id, material]));
     }
     setCollections(collections) {
-        if (useScene.getState().readOnly)
-            return;
-        useScene.setState({ collections });
+        this.write(() => {
+            if (this.store.getState().readOnly)
+                return;
+            this.store.setState({ collections: structuredClone(materialize(collections)) });
+        });
     }
     /** Root node IDs. */
     getRootNodeIds() {
-        return useScene.getState().rootNodeIds;
+        return this.runtime
+            .reader()
+            .query({ entity: 'root' })
+            .map((node) => node.id);
     }
     /**
      * Resolve children via the flat `nodes` dict. Uses THREE fallbacks because
@@ -158,7 +182,7 @@ export class SceneBridge {
      * Results are de-duplicated by id, in flat-dict iteration order.
      */
     getChildren(parentId) {
-        const nodes = useScene.getState().nodes;
+        const nodes = this.getNodes();
         const out = [];
         const seen = new Set();
         // Strategy 1: parentId scan.
@@ -201,7 +225,7 @@ export class SceneBridge {
      * unset (see the default-scene quirk documented on `getChildren`).
      */
     getAncestry(id) {
-        const nodes = useScene.getState().nodes;
+        const nodes = this.getNodes();
         const out = [];
         let current = nodes[id];
         const seen = new Set();
@@ -223,16 +247,16 @@ export class SceneBridge {
     }
     /** Find all nodes matching the given filters (all filters ANDed). */
     findNodes(filter) {
-        const nodes = useScene.getState().nodes;
+        // A query, so a detached scene records the selection rather than a read of every node.
+        const selected = this.runtime.reader().query({
+            entity: 'node',
+            where: {
+                ...(filter.type !== undefined && { type: filter.type }),
+                ...(filter.parentId !== undefined && { parentId: filter.parentId }),
+            },
+        });
         const out = [];
-        for (const node of Object.values(nodes)) {
-            if (filter.type !== undefined && node.type !== filter.type)
-                continue;
-            if (filter.parentId !== undefined) {
-                const np = (node.parentId ?? null);
-                if (np !== filter.parentId)
-                    continue;
-            }
+        for (const node of selected) {
             if (filter.levelId !== undefined) {
                 if (this.resolveLevelId(node.id) !== filter.levelId)
                     continue;
@@ -255,25 +279,36 @@ export class SceneBridge {
      * `id`, generated by the schema default if they did `XxxNode.parse({...})`).
      * Returns the generated id.
      */
-    createNode(node, parentId) {
-        const before = useScene.getState().nodes;
-        assertDerivedNodeWrites(before, { create: [{ node: parentId ? { ...node, parentId } : node }] });
-        runAsSingleSceneHistoryStep(useScene, () => {
-            useScene.getState().createNode(node, parentId);
-            this.reconcileDependentStructure(before);
+    createNode(input, parentId) {
+        // The store takes its own copy: a detached scene freezes what it holds.
+        const node = structuredClone(materialize(input));
+        this.write(() => {
+            const before = this.store.getState().nodes;
+            assertDerivedNodeWrites(this.getNodes(), {
+                create: [{ node: parentId ? { ...node, parentId } : node }],
+            });
+            runAsSettledSceneStep(this.store, () => {
+                this.store.getState().createNode(node, parentId);
+                declareActionDependencies(this.runtime, before, { create: [{ node, parentId }] });
+                this.runtime.reconcile(before);
+            });
         });
         return node.id;
     }
     /** Update node fields (shallow merge through the core store). */
-    updateNode(id, data) {
-        if (!useScene.getState().nodes[id]) {
+    updateNode(id, input) {
+        const data = structuredClone(materialize(input));
+        if (!this.getNode(id)) {
             throw new Error(`node not found: ${id}`);
         }
-        const before = useScene.getState().nodes;
-        assertDerivedNodeWrites(before, { update: [{ id, data }] });
-        runAsSingleSceneHistoryStep(useScene, () => {
-            useScene.getState().updateNode(id, data);
-            this.reconcileDependentStructure(before);
+        this.write(() => {
+            const before = this.store.getState().nodes;
+            assertDerivedNodeWrites(this.getNodes(), { update: [{ id, data }] });
+            runAsSettledSceneStep(this.store, () => {
+                this.store.getState().updateNode(id, data);
+                declareActionDependencies(this.runtime, before, { update: [{ id, data }] });
+                this.runtime.reconcile(before);
+            });
         });
     }
     /**
@@ -284,8 +319,8 @@ export class SceneBridge {
      * Returns the list of ids actually removed from the scene.
      */
     deleteNode(id, cascade = false) {
-        const state = useScene.getState();
-        const node = state.nodes[id];
+        const nodes = this.getNodes();
+        const node = nodes[id];
         if (!node) {
             throw new Error(`node not found: ${id}`);
         }
@@ -293,20 +328,14 @@ export class SceneBridge {
         if (!cascade && descendants.length > 1) {
             throw new Error(`node has ${descendants.length - 1} descendant(s); pass cascade: true to delete recursively`);
         }
-        const before = new Set(Object.keys(state.nodes));
-        const wallLevels = [
-            ...new Set(descendants.flatMap((nodeId) => {
-                const deleted = state.nodes[nodeId];
-                return deleted?.type === 'wall' && deleted.parentId ? [deleted.parentId] : [];
-            })),
-        ];
-        runAsSingleSceneHistoryStep(useScene, () => {
-            useScene.getState().deleteNode(id);
-            if (wallLevels.length)
-                this.deriveStructure(wallLevels);
-            this.reconcileDependentStructure(state.nodes);
-        });
-        const afterNodes = useScene.getState().nodes;
+        const beforeNodes = this.store.getState().nodes;
+        const before = new Set(Object.keys(beforeNodes));
+        this.write(() => runAsSettledSceneStep(this.store, () => {
+            this.store.getState().deleteNode(id);
+            declareActionDependencies(this.runtime, beforeNodes, { delete: [id] });
+            this.runtime.reconcile(beforeNodes);
+        }));
+        const afterNodes = this.store.getState().nodes;
         const removed = [];
         for (const prevId of before) {
             if (!(prevId in afterNodes))
@@ -320,14 +349,19 @@ export class SceneBridge {
      * validation failure without mutating state.
      */
     applyPatch(patches) {
-        const state = useScene.getState();
-        const nodes = state.nodes;
-        if (state.readOnly)
+        return this.write(() => this.applyPatchInScope(structuredClone(materialize(patches))));
+    }
+    applyPatchInScope(patches) {
+        const nodes = this.getNodes();
+        const beforeNodes = this.store.getState().nodes;
+        if (this.store.getState().readOnly)
             throw new Error('scene_read_only');
         // Track synthesized state as we dry-run so later ops can reference
-        // earlier-created ids and reflect earlier-deleted ids.
-        const simAvailable = new Set(Object.keys(nodes));
+        // earlier-created ids and reflect earlier-deleted ids. Existence is read
+        // id by id: enumerating the scene would read every node of a detached one.
+        const simCreated = new Set();
         const simDeleted = new Set();
+        const simAvailable = (id) => simCreated.has(id) || (!simDeleted.has(id) && nodes[id] !== undefined);
         // Parsed create nodes keyed by patch index — so the apply phase can use the
         // Zod-normalised copy (which has a generated id if the caller omitted one)
         // instead of the unparsed input.
@@ -348,14 +382,14 @@ export class SceneBridge {
                 if (!res.success) {
                     throw new Error(`invalid patch: patches[${i}] create node failed schema: ${res.error.message}`);
                 }
-                if (p.parentId !== undefined && !simAvailable.has(p.parentId)) {
+                if (p.parentId !== undefined && !simAvailable(p.parentId)) {
                     throw new Error(`invalid patch: patches[${i}] create parentId "${p.parentId}" not found`);
                 }
                 parsedCreateNodes.set(i, p.parentId ? { ...res.data, parentId: p.parentId } : res.data);
-                simAvailable.add(res.data.id);
+                simCreated.add(res.data.id);
             }
             else if (p.op === 'update') {
-                if (!simAvailable.has(p.id) || simDeleted.has(p.id)) {
+                if (!simAvailable(p.id) || simDeleted.has(p.id)) {
                     throw new Error(`invalid patch: patches[${i}] update id "${p.id}" not found`);
                 }
                 if (!p.data || typeof p.data !== 'object') {
@@ -363,7 +397,7 @@ export class SceneBridge {
                 }
             }
             else if (p.op === 'delete') {
-                if (!simAvailable.has(p.id) || simDeleted.has(p.id)) {
+                if (!simAvailable(p.id) || simDeleted.has(p.id)) {
                     throw new Error(`invalid patch: patches[${i}] delete id "${p.id}" not found`);
                 }
                 if (p.cascade === false) {
@@ -376,7 +410,7 @@ export class SceneBridge {
                         throw new Error(`invalid patch: patches[${i}] delete "${p.id}" has descendants; pass cascade: true`);
                     }
                 }
-                simAvailable.delete(p.id);
+                simCreated.delete(p.id);
                 simDeleted.add(p.id);
             }
             else {
@@ -393,20 +427,17 @@ export class SceneBridge {
         const createOps = new Map();
         const updateOps = new Map();
         const deleteIds = new Set();
-        const nextNodes = { ...nodes };
         for (const [index, patch] of patches.entries()) {
             if (patch.op === 'create') {
                 const parsed = parsedCreateNodes.get(index);
                 const node = { ...parsed, parentId: patch.parentId ?? parsed.parentId };
                 createOps.set(node.id, { node, parentId: patch.parentId });
                 deleteIds.delete(node.id);
-                nextNodes[node.id] = node;
             }
             else if (patch.op === 'update') {
-                nextNodes[patch.id] = { ...nextNodes[patch.id], ...patch.data };
                 const created = createOps.get(patch.id);
                 if (created) {
-                    created.node = nextNodes[patch.id];
+                    created.node = { ...created.node, ...patch.data };
                     if (patch.data.parentId !== undefined)
                         created.parentId = patch.data.parentId;
                 }
@@ -417,45 +448,47 @@ export class SceneBridge {
                 deleteIds.add(patch.id);
                 createOps.delete(patch.id);
                 updateOps.delete(patch.id);
-                delete nextNodes[patch.id];
             }
         }
         // Plan the entire deletion selection before applying anything. Interleaved
         // update operations must not turn an all-boundaries deletion into balconies.
-        const planned = structureChangeBatch(planWallDeletion(nodes, {
-            nodeIds: [...deleteIds],
-            nextNodes,
-            mintId: generateId,
-        }).changes);
+        // Only a deletion plans: the planner reads the whole scene for what the
+        // deleted nodes hold.
+        const planned = structureChangeBatch(deleteIds.size
+            ? planWallDeletion(nodes, {
+                nodeIds: [...deleteIds],
+                nextNodes: patchedNodes(nodes, createOps, updateOps, deleteIds),
+                mintId: generateId,
+            }).changes
+            : []);
+        // What was asked for, before the deletion planner adds its own writes.
+        const requested = {
+            create: [...createOps.values()],
+            update: [...updateOps].map(([id, data]) => ({ id, data })),
+            delete: [...deleteIds],
+        };
         for (const { id, data } of planned.update)
             updateOps.set(id, { ...updateOps.get(id), ...data });
-        const wallLevels = [
-            ...new Set(planned.delete.flatMap((id) => {
-                const node = nodes[id];
-                return node?.type === 'wall' && node.parentId ? [node.parentId] : [];
-            })),
-        ];
-        runAsSingleSceneHistoryStep(useScene, () => {
+        runAsSettledSceneStep(this.store, () => {
             pauseSpaceDetection();
             try {
                 for (const material of materialUpserts.values())
-                    useScene.getState().addSceneMaterial(material);
-                useScene.getState().createNodes([...createOps.values(), ...planned.create]);
-                useScene.getState().updateNodes([...updateOps].map(([id, data]) => ({ id, data })));
-                useScene.getState().deleteNodes(planned.delete);
+                    this.store.getState().addSceneMaterial(material);
+                this.store.getState().createNodes([...createOps.values(), ...planned.create]);
+                this.store.getState().updateNodes([...updateOps].map(([id, data]) => ({ id, data })));
+                this.store.getState().deleteNodes(planned.delete);
             }
             finally {
                 resumeSpaceDetection();
             }
-            if (wallLevels.length)
-                this.deriveStructure(wallLevels);
-            this.reconcileDependentStructure(nodes);
+            declareActionDependencies(this.runtime, beforeNodes, requested);
+            this.runtime.reconcile(beforeNodes);
         });
-        const createdIds = Object.keys(useScene.getState().nodes).filter((id) => !nodes[id]);
+        const postNodes = this.store.getState().nodes;
+        const createdIds = Object.keys(postNodes).filter((id) => !beforeNodes[id]);
         // Compute actual deleted ids by diffing pre/post snapshots.
-        const postNodes = useScene.getState().nodes;
         const deletedIds = [];
-        for (const prevId of Object.keys(nodes)) {
+        for (const prevId of Object.keys(beforeNodes)) {
             if (!(prevId in postNodes))
                 deletedIds.push(prevId);
         }
@@ -484,9 +517,16 @@ export class SceneBridge {
      * before the triggering tool call rather than stranding derived nodes.
      */
     deriveStructure(levelIds) {
-        pauseSceneHistory(useScene);
+        return this.write(() => runAsSettledSceneStep(this.store, () => this.deriveStructureInScope(levelIds)));
+    }
+    deriveStructureInScope(levelIds) {
+        pauseSceneHistory(this.store);
         try {
-            const patches = applyStructureReconciliation(useScene, {
+            // The kernel reads through the runtime's reader; its writes go to the store.
+            const reading = {
+                getState: () => ({ ...this.store.getState(), nodes: this.getNodes() }),
+            };
+            const patches = applyStructureReconciliation(reading, {
                 levelIds,
                 mintId: (kind) => generateId(kind),
             });
@@ -496,22 +536,24 @@ export class SceneBridge {
             };
         }
         finally {
-            resumeSceneHistory(useScene);
+            resumeSceneHistory(this.store);
         }
     }
     /** Undo. Returns the number of steps actually undone. */
     undo(steps = 1) {
-        const before = useScene.temporal.getState().pastStates.length;
-        useScene.temporal.getState().undo(steps);
-        const after = useScene.temporal.getState().pastStates.length;
-        return Math.max(0, before - after);
+        return this.write(() => {
+            const before = this.store.temporal.getState().pastStates.length;
+            this.store.temporal.getState().undo(steps);
+            return Math.max(0, before - this.store.temporal.getState().pastStates.length);
+        });
     }
     /** Redo. Returns the number of steps actually redone. */
     redo(steps = 1) {
-        const before = useScene.temporal.getState().futureStates.length;
-        useScene.temporal.getState().redo(steps);
-        const after = useScene.temporal.getState().futureStates.length;
-        return Math.max(0, before - after);
+        return this.write(() => {
+            const before = this.store.temporal.getState().futureStates.length;
+            this.store.temporal.getState().redo(steps);
+            return Math.max(0, before - this.store.temporal.getState().futureStates.length);
+        });
     }
     /**
      * Zod-validate every node in the scene. Reports one error per failed node,
@@ -520,7 +562,7 @@ export class SceneBridge {
     validateScene() {
         const errors = [];
         const warnings = [];
-        const nodes = useScene.getState().nodes;
+        const nodes = this.getNodes();
         for (const [id, node] of Object.entries(nodes)) {
             if (node.type === 'site' && node.visible === false) {
                 warnings.push({ nodeId: id, path: 'visible', message: HIDDEN_SITE_NOTE });
@@ -543,7 +585,7 @@ export class SceneBridge {
      * renderer (there is no renderer in MCP mode); useful for observability.
      */
     flushDirty() {
-        const state = useScene.getState();
+        const state = this.store.getState();
         const ids = Array.from(state.dirtyNodes);
         for (const id of ids) {
             state.clearDirty(id);
@@ -552,7 +594,7 @@ export class SceneBridge {
     }
     /** Current temporal history pointers. */
     getHistory() {
-        const t = useScene.temporal.getState();
+        const t = this.store.temporal.getState();
         return {
             pastCount: t.pastStates.length,
             futureCount: t.futureStates.length,
@@ -560,83 +602,14 @@ export class SceneBridge {
     }
     /** Clear the temporal undo/redo history. */
     clearHistory() {
-        useScene.temporal.getState().clear();
+        this.store.temporal.getState().clear();
+    }
+    /** Runs `run` in the scene's scope: an operation planned here mints the runtime's ids. */
+    runInScene(run) {
+        return this.write(run);
     }
     runAsSingleHistoryStep(run) {
-        return runAsSingleSceneHistoryStep(useScene, run);
-    }
-    reconcileDependentStructure(before) {
-        const currentNodes = this.getNodes();
-        const authoredInputChanged = [
-            ...new Set([...Object.keys(before), ...Object.keys(currentNodes)]),
-        ].some((id) => {
-            if (before[id] === currentNodes[id])
-                return false;
-            const type = (currentNodes[id] ?? before[id])?.type;
-            return (type === 'stair' ||
-                type === 'stair-segment' ||
-                type === 'elevator' ||
-                type === 'level' ||
-                type === 'building' ||
-                type === 'slab' ||
-                type === 'ceiling');
-        });
-        if (authoredInputChanged) {
-            const ownerIds = changedStairOpeningOwners(before, currentNodes);
-            for (const node of [...Object.values(before), ...Object.values(currentNodes)]) {
-                if (node.type === 'elevator' &&
-                    (before[node.id] !== currentNodes[node.id] ||
-                        Object.values(currentNodes).some((level) => level.type === 'level' && before[level.id] !== level)))
-                    ownerIds.add(node.id);
-            }
-            const owned = planOwnedFloorOpenings(currentNodes, { ownerIds });
-            if (owned.length) {
-                pauseSpaceDetection();
-                try {
-                    useScene.getState().applyNodeChanges(structureChangeBatch(owned));
-                }
-                finally {
-                    resumeSpaceDetection();
-                }
-            }
-        }
-        const current = this.getNodes();
-        const levels = new Set();
-        for (const id of new Set([...Object.keys(before), ...Object.keys(current)])) {
-            if (before[id] === current[id])
-                continue;
-            for (const nodes of [before, current]) {
-                const level = stairDeckLevelId(nodes, nodes[id]);
-                if (level)
-                    levels.add(level);
-                const node = nodes[id];
-                if (node?.type === 'level') {
-                    levels.add(node.id);
-                    const lower = adjacentLevelId(nodes, node.id, -1);
-                    if (lower)
-                        levels.add(lower);
-                }
-                if (node?.type === 'stair')
-                    for (const opening of Object.values(nodes))
-                        if (opening.type === 'floor-opening' && opening.ownerId === node.id)
-                            for (const target of floorOpeningTargets(nodes, opening))
-                                levels.add(target.levelId);
-                if (node?.type === 'floor-opening')
-                    for (const target of floorOpeningTargets(nodes, node))
-                        levels.add(target.levelId);
-                if (node?.type === 'door' || node?.type === 'window') {
-                    const wall = nodes[node.parentId];
-                    if (wall?.type === 'wall' && wall.parentId)
-                        levels.add(wall.parentId);
-                }
-                else if ((node?.type === 'zone' || node?.type === 'slab' || node?.type === 'wall') &&
-                    node.parentId) {
-                    levels.add(node.parentId);
-                }
-            }
-        }
-        if (levels.size)
-            this.deriveStructure([...levels]);
+        return this.write(() => runAsSettledSceneStep(this.store, run));
     }
     // ---- internal helpers ----
     /**
@@ -645,7 +618,7 @@ export class SceneBridge {
      * missing on a node.
      */
     _findParentByChildrenScan(id) {
-        const nodes = useScene.getState().nodes;
+        const nodes = this.getNodes();
         for (const candidate of Object.values(nodes)) {
             if (!('children' in candidate && Array.isArray(candidate.children)))
                 continue;
@@ -671,7 +644,7 @@ export class SceneBridge {
      * the SiteNode quirk and the default-scene parentId-unset case both work.
      */
     _collectDescendants(id) {
-        const nodes = useScene.getState().nodes;
+        const nodes = this.getNodes();
         if (!nodes[id])
             return [];
         const out = [];
@@ -692,3 +665,14 @@ export class SceneBridge {
         return out;
     }
 }
+/** The scene as a patch leaves it, for the deletion planner. */
+function patchedNodes(nodes, creates, updates, deletes) {
+    const next = { ...nodes };
+    for (const [id, data] of updates)
+        next[id] = { ...next[id], ...data };
+    for (const [id, { node }] of creates)
+        next[id] = node;
+    for (const id of deletes)
+        delete next[id];
+    return next;
+}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { SceneBridge } from './bridge/scene-bridge.js';
 export { createSceneOperations, type SceneOperations } from './operations/index.js';
 export { type CreatePascalMcpServerOptions, createPascalMcpServer } from './server.js';
-export type { GeometryScriptHost, ScriptedKind } from './tools/add-object.js';
+export type { GeometryScriptHost, ObjectMakerHost, PieceState, ScriptedKind, } from './tools/add-object.js';
 export { type AssetCatalog, builtInCatalog } from './tools/asset-catalog.js';
 export type { SceneViewCapture, SceneViewHost } from './tools/view-scene.js';
 export { version } from './version.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,qBAAqB,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAA;AAC1E,OAAO,EAAE,KAAK,4BAA4B,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AACnF,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAC1E,OAAO,EAAE,KAAK,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACzE,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,qBAAqB,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAA;AAC1E,OAAO,EAAE,KAAK,4BAA4B,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AACnF,YAAY,EACV,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,YAAY,GACb,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,KAAK,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACzE,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA"}

package/dist/lib/safe-fetch.d.ts

@@ -3,6 +3,12 @@ import { type IncomingMessage } from 'node:http';
 import { type LookupFunction } from 'node:net';
 /** True for any address a server-side fetch must not reach. Unparseable input is blocked. */
 export declare function isBlockedAddress(address: string): boolean;
+/**
+ * Scheme, host and a truncated path only: query strings can carry presigned
+ * tokens, userinfo carries credentials. Non-http(s) URLs (`data:`,
+ * `javascript:`) carry their payload in the path, so they log scheme and host.
+ */
+export declare function loggableUrl(url: URL): string;
 export type Resolver = (hostname: string) => Promise<LookupAddress[]>;
 /** A socket `lookup` that only ever answers with the given, already-checked addresses. */
 export declare function pinnedLookup(addresses: LookupAddress[]): LookupFunction;

package/dist/lib/safe-fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safe-fetch.d.ts","sourceRoot":"","sources":["../../src/lib/safe-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,WAAW,CAAA;AAExE,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AA2GpD,6FAA6F;AAC7F,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAYzD;AAkDD,MAAM,MAAM,QAAQ,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,EAAE,CAAC,CAAA;AA2BrE,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,cAAc,CAcvE;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,MAAM,EAAE,cAAc,CAAA;IACtB,MAAM,EAAE,WAAW,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;AAqBvF,MAAM,MAAM,aAAa,GAAG;IAAE,OAAO,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAE,CAAA;AAOrE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,EAAE,CAAA;CACf,CAAA;AAOD;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,gBAAqB,EAC3B,IAAI,GAAE,aAA2B,GAChC,OAAO,CAAC,eAAe,CAAC,CAwE1B"}
+{"version":3,"file":"safe-fetch.d.ts","sourceRoot":"","sources":["../../src/lib/safe-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,OAAO,EAA0B,KAAK,eAAe,EAAgB,MAAM,WAAW,CAAA;AAEtF,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AAoIpD,6FAA6F;AAC7F,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAYzD;AAgBD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAS5C;AAiDD,MAAM,MAAM,QAAQ,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,EAAE,CAAC,CAAA;AAsDrE,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,cAAc,CAcvE;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,MAAM,EAAE,cAAc,CAAA;IACtB,MAAM,EAAE,WAAW,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;AAqBvF,MAAM,MAAM,aAAa,GAAG;IAAE,OAAO,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAE,CAAA;AAOrE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,EAAE,CAAA;CACf,CAAA;AAOD;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,gBAAqB,EAC3B,IAAI,GAAE,aAA2B,GAChC,OAAO,CAAC,eAAe,CAAC,CAsF1B"}