@pascal-app/core 0.3.2 → 0.4.0

package/dist/schema/types.d.ts

@@ -175,7 +175,7 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>]>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>]>>>;
     level: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -579,6 +579,124 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     deckThickness: z.ZodDefault<z.ZodNumber>;
     overhang: z.ZodDefault<z.ZodNumber>;
     shingleThickness: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"stair">>;
+    material: z.ZodOptional<z.ZodObject<{
+        preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`sseg_${string}`>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`sseg_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"stair-segment">>;
+    material: z.ZodOptional<z.ZodObject<{
+        preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    segmentType: z.ZodDefault<z.ZodEnum<{
+        stair: "stair";
+        landing: "landing";
+    }>>;
+    width: z.ZodDefault<z.ZodNumber>;
+    length: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    stepCount: z.ZodDefault<z.ZodNumber>;
+    attachmentSide: z.ZodDefault<z.ZodEnum<{
+        front: "front";
+        left: "left";
+        right: "right";
+    }>>;
+    fillToFloor: z.ZodDefault<z.ZodBoolean>;
+    thickness: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;

package/dist/schema/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAgBnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAelB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAkBnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiBlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/types.js

@@ -10,6 +10,8 @@ import { RoofSegmentNode } from './nodes/roof-segment';
 import { ScanNode } from './nodes/scan';
 import { SiteNode } from './nodes/site';
 import { SlabNode } from './nodes/slab';
+import { StairNode } from './nodes/stair';
+import { StairSegmentNode } from './nodes/stair-segment';
 import { WallNode } from './nodes/wall';
 import { WindowNode } from './nodes/window';
 import { ZoneNode } from './nodes/zone';
@@ -24,6 +26,8 @@ export const AnyNode = z.discriminatedUnion('type', [
     CeilingNode,
     RoofNode,
     RoofSegmentNode,
+    StairNode,
+    StairSegmentNode,
     ScanNode,
     GuideNode,
     WindowNode,

package/dist/store/actions/node-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAQ9C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,EAAE,SA2C/C,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SAsErD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SA4EjB,CAAA"}
+{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAQ9C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,EAAE,SA4C/C,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SA+DrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAuEjB,CAAA"}

package/dist/store/actions/node-actions.js

@@ -2,6 +2,8 @@
 let pendingRafId = null;
 let pendingUpdates = new Set();
 export const createNodesAction = (set, get, ops) => {
+    if (get().readOnly)
+        return;
     set((state) => {
         const nextNodes = { ...state.nodes };
         const nextRootIds = [...state.rootNodeIds];
@@ -41,8 +43,9 @@ export const createNodesAction = (set, get, ops) => {
     });
 };
 export const updateNodesAction = (set, get, updates) => {
+    if (get().readOnly)
+        return;
     const parentsToUpdate = new Set();
-    const idsToMarkDirty = new Set();
     set((state) => {
         const nextNodes = { ...state.nodes };
         for (const { id, data } of updates) {
@@ -77,23 +80,17 @@ export const updateNodesAction = (set, get, updates) => {
         }
         return { nodes: nextNodes };
     });
-    // Collect all IDs that need to be marked dirty
+    // Batch dirty-marking into a single RAF to avoid redundant callbacks during rapid updates
     for (const u of updates) {
-        idsToMarkDirty.add(u.id);
+        pendingUpdates.add(u.id);
     }
     for (const pId of parentsToUpdate) {
-        idsToMarkDirty.add(pId);
+        pendingUpdates.add(pId);
     }
-    // Add to pending updates set
-    for (const id of idsToMarkDirty) {
-        pendingUpdates.add(id);
-    }
-    // Cancel any pending RAF and schedule a new one
     if (pendingRafId !== null) {
         cancelAnimationFrame(pendingRafId);
     }
     pendingRafId = requestAnimationFrame(() => {
-        // Mark all pending updates as dirty
         pendingUpdates.forEach((id) => {
             get().markDirty(id);
         });
@@ -102,36 +99,35 @@ export const updateNodesAction = (set, get, updates) => {
     });
 };
 export const deleteNodesAction = (set, get, ids) => {
+    if (get().readOnly)
+        return;
     const parentsToMarkDirty = new Set();
     set((state) => {
         const nextNodes = { ...state.nodes };
         const nextCollections = { ...state.collections };
         let nextRootIds = [...state.rootNodeIds];
-        // Collect all IDs to delete (including descendants) in a first pass
-        // This avoids issues with recursive calls during state mutation
-        const allIdsToDelete = new Set();
-        const collectDescendants = (id) => {
-            const node = nextNodes[id];
-            if (!node)
+        // Collect all ids to delete (the requested ids + all their descendants) before
+        // mutating anything, so the recursive walk reads consistent state.
+        const allIds = new Set();
+        const collect = (id) => {
+            if (allIds.has(id))
                 return;
-            allIdsToDelete.add(id);
-            if ('children' in node && node.children) {
-                for (const childId of node.children) {
-                    collectDescendants(childId);
-                }
+            allIds.add(id);
+            const node = nextNodes[id];
+            if (node && 'children' in node) {
+                for (const cid of node.children)
+                    collect(cid);
             }
         };
-        for (const id of ids) {
-            collectDescendants(id);
-        }
-        // Now process all nodes for deletion
-        for (const id of allIdsToDelete) {
+        for (const id of ids)
+            collect(id);
+        for (const id of allIds) {
             const node = nextNodes[id];
             if (!node)
                 continue;
-            // 1. Remove reference from Parent
+            // 1. Remove reference from parent — only if the parent itself is NOT also being deleted
             const parentId = node.parentId;
-            if (parentId && nextNodes[parentId]) {
+            if (parentId && nextNodes[parentId] && !allIds.has(parentId)) {
                 const parent = nextNodes[parentId];
                 if (parent.children) {
                     nextNodes[parent.id] = {
@@ -141,7 +137,7 @@ export const deleteNodesAction = (set, get, ids) => {
                     parentsToMarkDirty.add(parent.id);
                 }
             }
-            // 2. Remove from Root list
+            // 2. Remove from root list
             nextRootIds = nextRootIds.filter((rid) => rid !== id);
             // 3. Remove from any collections it belongs to
             if ('collectionIds' in node && node.collectionIds) {

package/dist/store/use-live-transforms.d.ts

@@ -0,0 +1,14 @@
+export type LiveTransform = {
+    position: [number, number, number];
+    rotation: number;
+};
+type LiveTransformState = {
+    transforms: Map<string, LiveTransform>;
+    set(nodeId: string, transform: LiveTransform): void;
+    get(nodeId: string): LiveTransform | undefined;
+    clear(nodeId: string): void;
+    clearAll(): void;
+};
+declare const useLiveTransforms: import("zustand").UseBoundStore<import("zustand").StoreApi<LiveTransformState>>;
+export default useLiveTransforms;
+//# sourceMappingURL=use-live-transforms.d.ts.map

package/dist/store/use-live-transforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-live-transforms.d.ts","sourceRoot":"","sources":["../../src/store/use-live-transforms.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,KAAK,kBAAkB,GAAG;IACxB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACtC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,IAAI,CAAA;IACnD,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAA;IAC9C,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,QAAQ,IAAI,IAAI,CAAA;CACjB,CAAA;AAED,QAAA,MAAM,iBAAiB,iFAgBpB,CAAA;AAEH,eAAe,iBAAiB,CAAA"}

package/dist/store/use-live-transforms.js

@@ -0,0 +1,20 @@
+// Ephemeral live transform state for nodes being actively dragged/moved.
+// This decouples 2D (floorplan) and 3D (viewer) so neither needs to peek
+// into the other's scene graph during drag operations.
+import { create } from 'zustand';
+const useLiveTransforms = create((set, get) => ({
+    transforms: new Map(),
+    set: (nodeId, transform) => set((state) => {
+        const next = new Map(state.transforms);
+        next.set(nodeId, transform);
+        return { transforms: next };
+    }),
+    get: (nodeId) => get().transforms.get(nodeId),
+    clear: (nodeId) => set((state) => {
+        const next = new Map(state.transforms);
+        next.delete(nodeId);
+        return { transforms: next };
+    }),
+    clearAll: () => set({ transforms: new Map() }),
+}));
+export default useLiveTransforms;

package/dist/store/use-scene.d.ts

@@ -7,6 +7,8 @@ export type SceneState = {
     rootNodeIds: AnyNodeId[];
     dirtyNodes: Set<AnyNodeId>;
     collections: Record<CollectionId, Collection>;
+    readOnly: boolean;
+    setReadOnly: (readOnly: boolean) => void;
     loadScene: () => void;
     clearScene: () => void;
     unloadScene: () => void;
@@ -36,10 +38,5 @@ type UseSceneStore = UseBoundStore<StoreApi<SceneState>> & {
 };
 declare const useScene: UseSceneStore;
 export default useScene;
-/**
- * Clears temporal history tracking variables to prevent memory leaks.
- * Should be called when unloading a scene to release node references.
- */
-export declare function clearTemporalTracking(): void;
 export declare function clearSceneHistory(): void;
 //# sourceMappingURL=use-scene.d.ts.map

package/dist/store/use-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-scene.d.ts","sourceRoot":"","sources":["../../src/store/use-scene.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAEnE,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAIrE,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AA8CzD,MAAM,MAAM,UAAU,GAAG;IAEvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IAGjC,WAAW,EAAE,SAAS,EAAE,CAAA;IAGxB,UAAU,EAAE,GAAG,CAAC,SAAS,CAAC,CAAA;IAG1B,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAG7C,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,IAAI,CAAA;IAE/E,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IAClC,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IAEnC,UAAU,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,IAAI,CAAA;IACzD,WAAW,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAE,EAAE,KAAK,IAAI,CAAA;IAErE,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;IAC3D,WAAW,EAAE,CAAC,OAAO,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,KAAK,IAAI,CAAA;IAE3E,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IACnC,WAAW,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,IAAI,CAAA;IAGvC,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,KAAK,YAAY,CAAA;IACvE,gBAAgB,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,IAAI,CAAA;IAC5C,gBAAgB,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,CAAA;IACnF,eAAe,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;IAC9D,oBAAoB,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;CACpE,CAAA;AAID,KAAK,aAAa,GAAG,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,GAAG;IACzD,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;CAC7F,CAAA;AAED,QAAA,MAAM,QAAQ,EAAE,aA2Mf,CAAA;AAED,eAAe,QAAQ,CAAA;AAOvB;;;GAGG;AACH,wBAAgB,qBAAqB,SAIpC;AAED,wBAAgB,iBAAiB,SAGhC"}
+{"version":3,"file":"use-scene.d.ts","sourceRoot":"","sources":["../../src/store/use-scene.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAEnE,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAIrE,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AA8CzD,MAAM,MAAM,UAAU,GAAG;IAEvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IAGjC,WAAW,EAAE,SAAS,EAAE,CAAA;IAGxB,UAAU,EAAE,GAAG,CAAC,SAAS,CAAC,CAAA;IAG1B,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAG7C,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAA;IAGxC,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,IAAI,CAAA;IAE/E,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IAClC,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IAEnC,UAAU,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,IAAI,CAAA;IACzD,WAAW,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAE,EAAE,KAAK,IAAI,CAAA;IAErE,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;IAC3D,WAAW,EAAE,CAAC,OAAO,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,KAAK,IAAI,CAAA;IAE3E,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IACnC,WAAW,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,IAAI,CAAA;IAGvC,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,KAAK,YAAY,CAAA;IACvE,gBAAgB,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,IAAI,CAAA;IAC5C,gBAAgB,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,CAAA;IACnF,eAAe,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;IAC9D,oBAAoB,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;CACpE,CAAA;AAID,KAAK,aAAa,GAAG,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,GAAG;IACzD,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;CAC7F,CAAA;AAED,QAAA,MAAM,QAAQ,EAAE,aA8Nf,CAAA;AAED,eAAe,QAAQ,CAAA;AAOvB,wBAAgB,iBAAiB,SAKhC"}

package/dist/store/use-scene.js

@@ -55,11 +55,10 @@ const useScene = create()(temporal((set, get) => ({
     dirtyNodes: new Set(),
     // 4. Collections
     collections: {},
+    // 5. Read-only lock
+    readOnly: false,
+    setReadOnly: (readOnly) => set({ readOnly }),
     unloadScene: () => {
-        // Clear temporal tracking to prevent memory leaks from stale node references
-        prevPastLength = 0;
-        prevFutureLength = 0;
-        prevNodesSnapshot = null;
         set({
             nodes: {},
             rootNodeIds: [],
@@ -74,14 +73,22 @@ const useScene = create()(temporal((set, get) => ({
     setScene: (nodes, rootNodeIds) => {
         // Apply backward compatibility migrations
         const patchedNodes = migrateNodes(nodes);
+        // Remove orphans: nodes whose parentId points to a non-existent node
+        const cleanedNodes = { ...patchedNodes };
+        for (const node of Object.values(cleanedNodes)) {
+            if (node.parentId && !cleanedNodes[node.parentId]) {
+                console.warn('[Scene] Removing orphan node', node.id, '(parentId', node.parentId, 'not found)');
+                delete cleanedNodes[node.id];
+            }
+        }
         set({
-            nodes: patchedNodes,
+            nodes: cleanedNodes,
             rootNodeIds,
             dirtyNodes: new Set(),
             collections: {},
         });
         // Mark all nodes as dirty to trigger re-validation
-        Object.values(patchedNodes).forEach((node) => {
+        Object.values(cleanedNodes).forEach((node) => {
             get().markDirty(node.id);
         });
     },
@@ -129,6 +136,8 @@ const useScene = create()(temporal((set, get) => ({
     deleteNode: (id) => nodeActions.deleteNodesAction(set, get, [id]),
     // --- COLLECTIONS ---
     createCollection: (name, nodeIds = []) => {
+        if (get().readOnly)
+            return '';
         const id = generateCollectionId();
         const collection = { id, name, nodeIds };
         set((state) => {
@@ -147,6 +156,8 @@ const useScene = create()(temporal((set, get) => ({
         return id;
     },
     deleteCollection: (id) => {
+        if (get().readOnly)
+            return;
         set((state) => {
             const col = state.collections[id];
             const nextCollections = { ...state.collections };
@@ -166,6 +177,8 @@ const useScene = create()(temporal((set, get) => ({
         });
     },
     updateCollection: (id, data) => {
+        if (get().readOnly)
+            return;
         set((state) => {
             const col = state.collections[id];
             if (!col)
@@ -174,6 +187,8 @@ const useScene = create()(temporal((set, get) => ({
         });
     },
     addToCollection: (id, nodeId) => {
+        if (get().readOnly)
+            return;
         set((state) => {
             const col = state.collections[id];
             if (!col || col.nodeIds.includes(nodeId))
@@ -194,6 +209,8 @@ const useScene = create()(temporal((set, get) => ({
         });
     },
     removeFromCollection: (id, nodeId) => {
+        if (get().readOnly)
+            return;
         set((state) => {
             const col = state.collections[id];
             if (!col)
@@ -227,19 +244,12 @@ export default useScene;
 let prevPastLength = 0;
 let prevFutureLength = 0;
 let prevNodesSnapshot = null;
-/**
- * Clears temporal history tracking variables to prevent memory leaks.
- * Should be called when unloading a scene to release node references.
- */
-export function clearTemporalTracking() {
+export function clearSceneHistory() {
+    useScene.temporal.getState().clear();
     prevPastLength = 0;
     prevFutureLength = 0;
     prevNodesSnapshot = null;
 }
-export function clearSceneHistory() {
-    useScene.temporal.getState().clear();
-    clearTemporalTracking();
-}
 // Subscribe to the temporal store (Undo/Redo events)
 useScene.temporal.subscribe((state) => {
     const currentPastLength = state.pastStates.length;

package/dist/systems/door/door-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"door-system.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-system.tsx"],"names":[],"mappings":"AA4BA,eAAO,MAAM,UAAU,YA2BtB,CAAA"}
+{"version":3,"file":"door-system.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-system.tsx"],"names":[],"mappings":"AAUA,eAAO,MAAM,UAAU,YA2BtB,CAAA"}

package/dist/systems/door/door-system.js

@@ -1,24 +1,8 @@
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
-import { DoubleSide, MeshStandardNodeMaterial } from 'three/webgpu';
 import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
+import { baseMaterial, glassMaterial } from '../../materials';
 import useScene from '../../store/use-scene';
-const baseMaterial = new MeshStandardNodeMaterial({
-    name: 'door-base',
-    color: '#f2f0ed',
-    roughness: 0.5,
-    metalness: 0,
-});
-const glassMaterial = new MeshStandardNodeMaterial({
-    name: 'door-glass',
-    color: 'lightblue',
-    roughness: 0.05,
-    metalness: 0.1,
-    transparent: true,
-    opacity: 0.35,
-    side: DoubleSide,
-    depthWrite: false,
-});
 // Invisible material for root mesh — used as selection hitbox only
 const hitboxMaterial = new THREE.MeshBasicMaterial({ visible: false });
 export const DoorSystem = () => {

package/dist/systems/roof/roof-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAGvE,OAAO,KAAK,EAAgC,eAAe,EAAE,MAAM,cAAc,CAAA;AAwBjF,eAAO,MAAM,UAAU,YAqFtB,CAAA;AAmLD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,GACpB;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CAkRlF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAoDvF"}
+{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAGvE,OAAO,KAAK,EAAgC,eAAe,EAAE,MAAM,cAAc,CAAA;AA+BjF,eAAO,MAAM,UAAU,YAuFtB,CAAA;AAuLD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,GACpB;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CAsRlF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAoDvF"}

package/dist/systems/roof/roof-system.js

@@ -7,7 +7,13 @@ import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
 import useScene from '../../store/use-scene';
 const csgEvaluator = new Evaluator();
 csgEvaluator.useGroups = true;
+csgEvaluator.consolidateGroups = false; // shared dummyMats across brushes causes consolidation to misalign groupIndices vs groupOrder indices → crash
 csgEvaluator.attributes = ['position', 'normal'];
+function prepareBrushForCSG(brush) {
+    brush.geometry.computeBoundsTree = computeBoundsTree;
+    brush.geometry.computeBoundsTree({ maxLeafSize: 10 });
+    brush.updateMatrixWorld();
+}
 // Pooled objects to avoid per-frame allocation in updateMergedRoofGeometry
 const _matrix = new THREE.Matrix4();
 const _position = new THREE.Vector3();
@@ -71,6 +77,9 @@ export const RoofSystem = () => {
                     }
                     clearDirty(id);
                 }
+                else {
+                    clearDirty(id);
+                }
                 // Queue the parent roof for a merged geometry update
                 if (node.parentId) {
                     pendingRoofUpdates.add(node.parentId);
@@ -151,6 +160,7 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
             const next = csgEvaluator.evaluate(totalShinSlab, brushes.shinSlab, ADDITION);
             totalShinSlab.geometry.dispose();
             brushes.shinSlab.geometry.dispose();
+            prepareBrushForCSG(next);
             totalShinSlab = next;
         }
         else {
@@ -160,6 +170,7 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
             const next = csgEvaluator.evaluate(totalDeckSlab, brushes.deckSlab, ADDITION);
             totalDeckSlab.geometry.dispose();
             brushes.deckSlab.geometry.dispose();
+            prepareBrushForCSG(next);
             totalDeckSlab = next;
         }
         else {
@@ -169,6 +180,7 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
             const next = csgEvaluator.evaluate(totalWall, brushes.wallBrush, ADDITION);
             totalWall.geometry.dispose();
             brushes.wallBrush.geometry.dispose();
+            prepareBrushForCSG(next);
             totalWall = next;
         }
         else {
@@ -178,6 +190,7 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
             const next = csgEvaluator.evaluate(totalInner, brushes.innerBrush, ADDITION);
             totalInner.geometry.dispose();
             brushes.innerBrush.geometry.dispose();
+            prepareBrushForCSG(next);
             totalInner = next;
         }
         else {
@@ -380,6 +393,11 @@ export function getRoofSegmentBrushes(node) {
             return null;
         if (!geo.index)
             return null;
+        // Strip zero-count groups — three-bvh-csg crashes with groupIndices[i] undefined
+        // when a group exists but covers no triangles (can happen after mergeVertices)
+        geo.groups = geo.groups.filter((g) => g.count > 0);
+        if (geo.groups.length === 0)
+            return null;
         geo.computeBoundsTree = computeBoundsTree;
         geo.computeBoundsTree({ maxLeafSize: 10 });
         const brush = new Brush(geo, dummyMats);

package/dist/systems/slab/slab-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAOvD,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAkED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAmD7E"}
+{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAOvD,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAuED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAG7E"}