@pascal-app/core 0.1.13 → 0.2.0

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

@@ -1,12 +1,15 @@
 import type { TemporalState } from 'zundo';
 import { type StoreApi, type UseBoundStore } from 'zustand';
+import type { Collection, CollectionId } from '../schema/collections';
 import type { AnyNode, AnyNodeId } from '../schema/types';
 export type SceneState = {
     nodes: Record<AnyNodeId, AnyNode>;
     rootNodeIds: AnyNodeId[];
     dirtyNodes: Set<AnyNodeId>;
+    collections: Record<CollectionId, Collection>;
     loadScene: () => void;
     clearScene: () => void;
+    unloadScene: () => void;
     setScene: (nodes: Record<AnyNodeId, AnyNode>, rootNodeIds: AnyNodeId[]) => void;
     markDirty: (id: AnyNodeId) => void;
     clearDirty: (id: AnyNodeId) => void;
@@ -22,10 +25,16 @@ export type SceneState = {
     }[]) => void;
     deleteNode: (id: AnyNodeId) => void;
     deleteNodes: (ids: AnyNodeId[]) => void;
+    createCollection: (name: string, nodeIds?: AnyNodeId[]) => CollectionId;
+    deleteCollection: (id: CollectionId) => void;
+    updateCollection: (id: CollectionId, data: Partial<Omit<Collection, 'id'>>) => void;
+    addToCollection: (id: CollectionId, nodeId: AnyNodeId) => void;
+    removeFromCollection: (id: CollectionId, nodeId: AnyNodeId) => void;
 };
 type UseSceneStore = UseBoundStore<StoreApi<SceneState>> & {
-    temporal: StoreApi<TemporalState<Pick<SceneState, 'nodes' | 'rootNodeIds'>>>;
+    temporal: StoreApi<TemporalState<Pick<SceneState, 'nodes' | 'rootNodeIds' | 'collections'>>>;
 };
 declare const useScene: UseSceneStore;
 export default useScene;
+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;AAKnE,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAIzD,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,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,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;CACxC,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,CAAC,CAAC,CAAC,CAAA;CAC7E,CAAA;AAED,QAAA,MAAM,QAAQ,EAAE,aA6Jf,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"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,aAqMf,CAAA;AAED,eAAe,QAAQ,CAAA;AAOvB,wBAAgB,iBAAiB,SAKhC"}

package/dist/store/use-scene.js

@@ -1,35 +1,82 @@
 'use client';
 import { temporal } from 'zundo';
 import { create } from 'zustand';
-import { persist } from 'zustand/middleware';
 import { BuildingNode } from '../schema';
+import { generateCollectionId } from '../schema/collections';
 import { LevelNode } from '../schema/nodes/level';
 import { SiteNode } from '../schema/nodes/site';
-import { isObject } from '../utils/types';
 import * as nodeActions from './actions/node-actions';
-const useScene = create()(persist(temporal((set, get) => ({
+function migrateNodes(nodes) {
+    const patchedNodes = { ...nodes };
+    for (const [id, node] of Object.entries(patchedNodes)) {
+        // 1. Item scale migration
+        if (node.type === 'item' && !('scale' in node)) {
+            patchedNodes[id] = { ...node, scale: [1, 1, 1] };
+        }
+        // 2. Old roof to new roof + segment migration
+        if (node.type === 'roof' && !('children' in node)) {
+            const oldRoof = node;
+            const suffix = id.includes('_') ? id.split('_')[1] : Math.random().toString(36).slice(2);
+            const segmentId = `rseg_${suffix}`;
+            const segment = {
+                object: 'node',
+                id: segmentId,
+                type: 'roof-segment',
+                parentId: id,
+                visible: oldRoof.visible ?? true,
+                metadata: {},
+                position: [0, 0, 0],
+                rotation: 0,
+                roofType: 'gable',
+                width: oldRoof.length ?? 8,
+                depth: (oldRoof.leftWidth ?? 2.2) + (oldRoof.rightWidth ?? 2.2),
+                wallHeight: 0,
+                roofHeight: oldRoof.height ?? 2.5,
+                wallThickness: 0.1,
+                deckThickness: 0.1,
+                overhang: 0.3,
+                shingleThickness: 0.05,
+            };
+            patchedNodes[segmentId] = segment;
+            patchedNodes[id] = {
+                ...oldRoof,
+                children: [segmentId],
+            };
+        }
+    }
+    return patchedNodes;
+}
+const useScene = create()(temporal((set, get) => ({
     // 1. Flat dictionary of all nodes
     nodes: {},
     // 2. Root node IDs
     rootNodeIds: [],
     // 3. Dirty set
     dirtyNodes: new Set(),
-    clearScene: () => {
+    // 4. Collections
+    collections: {},
+    unloadScene: () => {
         set({
             nodes: {},
             rootNodeIds: [],
             dirtyNodes: new Set(),
+            collections: {},
         });
+    },
+    clearScene: () => {
+        get().unloadScene();
         get().loadScene(); // Default scene
     },
     setScene: (nodes, rootNodeIds) => {
+        // Apply backward compatibility migrations
+        const patchedNodes = migrateNodes(nodes);
         set({
-            nodes,
+            nodes: patchedNodes,
             rootNodeIds,
             dirtyNodes: new Set(),
         });
         // Mark all nodes as dirty to trigger re-validation
-        Object.values(nodes).forEach((node) => {
+        Object.values(patchedNodes).forEach((node) => {
             get().markDirty(node.id);
         });
     },
@@ -75,60 +122,112 @@ const useScene = create()(persist(temporal((set, get) => ({
     // --- DELETE ---
     deleteNodes: (ids) => nodeActions.deleteNodesAction(set, get, ids),
     deleteNode: (id) => nodeActions.deleteNodesAction(set, get, [id]),
+    // --- COLLECTIONS ---
+    createCollection: (name, nodeIds = []) => {
+        const id = generateCollectionId();
+        const collection = { id, name, nodeIds };
+        set((state) => {
+            const nextCollections = { ...state.collections, [id]: collection };
+            // Denormalize: stamp collectionId onto each node
+            const nextNodes = { ...state.nodes };
+            for (const nodeId of nodeIds) {
+                const node = nextNodes[nodeId];
+                if (!node)
+                    continue;
+                const existing = ('collectionIds' in node ? node.collectionIds : undefined) ?? [];
+                nextNodes[nodeId] = { ...node, collectionIds: [...existing, id] };
+            }
+            return { collections: nextCollections, nodes: nextNodes };
+        });
+        return id;
+    },
+    deleteCollection: (id) => {
+        set((state) => {
+            const col = state.collections[id];
+            const nextCollections = { ...state.collections };
+            delete nextCollections[id];
+            // Remove collectionId from all member nodes
+            const nextNodes = { ...state.nodes };
+            for (const nodeId of col?.nodeIds ?? []) {
+                const node = nextNodes[nodeId];
+                if (!(node && 'collectionIds' in node))
+                    continue;
+                nextNodes[nodeId] = {
+                    ...node,
+                    collectionIds: node.collectionIds.filter((cid) => cid !== id),
+                };
+            }
+            return { collections: nextCollections, nodes: nextNodes };
+        });
+    },
+    updateCollection: (id, data) => {
+        set((state) => {
+            const col = state.collections[id];
+            if (!col)
+                return state;
+            return { collections: { ...state.collections, [id]: { ...col, ...data } } };
+        });
+    },
+    addToCollection: (id, nodeId) => {
+        set((state) => {
+            const col = state.collections[id];
+            if (!col || col.nodeIds.includes(nodeId))
+                return state;
+            const nextCollections = {
+                ...state.collections,
+                [id]: { ...col, nodeIds: [...col.nodeIds, nodeId] },
+            };
+            const node = state.nodes[nodeId];
+            if (!node)
+                return { collections: nextCollections };
+            const existing = ('collectionIds' in node ? node.collectionIds : undefined) ?? [];
+            const nextNodes = {
+                ...state.nodes,
+                [nodeId]: { ...node, collectionIds: [...existing, id] },
+            };
+            return { collections: nextCollections, nodes: nextNodes };
+        });
+    },
+    removeFromCollection: (id, nodeId) => {
+        set((state) => {
+            const col = state.collections[id];
+            if (!col)
+                return state;
+            const nextCollections = {
+                ...state.collections,
+                [id]: { ...col, nodeIds: col.nodeIds.filter((n) => n !== nodeId) },
+            };
+            const node = state.nodes[nodeId];
+            if (!(node && 'collectionIds' in node))
+                return { collections: nextCollections };
+            const nextNodes = {
+                ...state.nodes,
+                [nodeId]: {
+                    ...node,
+                    collectionIds: node.collectionIds.filter((cid) => cid !== id),
+                },
+            };
+            return { collections: nextCollections, nodes: nextNodes };
+        });
+    },
 }), {
     partialize: (state) => {
-        const { nodes, rootNodeIds } = state; // Only track nodes and rootNodeIds in history
-        return { nodes, rootNodeIds };
+        const { nodes, rootNodeIds, collections } = state;
+        return { nodes, rootNodeIds, collections };
     },
     limit: 50, // Limit to last 50 actions
-}), {
-    name: 'editor-storage',
-    partialize: (state) => ({
-        nodes: Object.fromEntries(Object.entries(state.nodes).filter(([_, node]) => {
-            const meta = node.metadata;
-            const isTransient = isObject(meta) && 'isTransient' in meta && meta.isTransient === true;
-            return !isTransient;
-        })),
-        rootNodeIds: state.rootNodeIds,
-    }),
-    onRehydrateStorage: (state) => {
-        console.log('hydrating...');
-        return (state, error) => {
-            if (error) {
-                console.log('an error happened during hydration', error);
-                return;
-            }
-            if (!state) {
-                console.log('hydration finished - no state');
-                return;
-            }
-            // Migration: Wrap old scenes (where root is not a SiteNode) in a SiteNode
-            const rootId = state.rootNodeIds?.[0];
-            const rootNode = rootId ? state.nodes[rootId] : null;
-            if (rootNode && rootNode.type !== 'site') {
-                console.log('Migrating old scene: wrapping in SiteNode');
-                // Collect existing root nodes (should be BuildingNode or ItemNode)
-                const existingRoots = (state.rootNodeIds || [])
-                    .map(id => state.nodes[id])
-                    .filter(node => node?.type === 'building' || node?.type === 'item');
-                // Create a new SiteNode with existing roots as children
-                const site = SiteNode.parse({
-                    children: existingRoots,
-                });
-                // Add site to nodes
-                state.nodes[site.id] = site;
-                // Update root to be the site
-                state.rootNodeIds = [site.id];
-                console.log('Migration complete: scene now has SiteNode as root');
-            }
-            console.log('hydration finished');
-        };
-    },
 }));
 export default useScene;
-// Track previous temporal state lengths
+// Track previous temporal state lengths and node snapshot for diffing
 let prevPastLength = 0;
 let prevFutureLength = 0;
+let prevNodesSnapshot = null;
+export function clearSceneHistory() {
+    useScene.temporal.getState().clear();
+    prevPastLength = 0;
+    prevFutureLength = 0;
+    prevNodesSnapshot = null;
+}
 // Subscribe to the temporal store (Undo/Redo events)
 useScene.temporal.subscribe((state) => {
     const currentPastLength = state.pastStates.length;
@@ -138,16 +237,40 @@ useScene.temporal.subscribe((state) => {
     const didUndo = currentFutureLength > prevFutureLength;
     const didRedo = currentPastLength > prevPastLength && currentFutureLength < prevFutureLength;
     if (didUndo || didRedo) {
+        // Capture the previous snapshot before RAF fires
+        const snapshotBefore = prevNodesSnapshot;
         // Use RAF to ensure all middleware and store updates are complete
         requestAnimationFrame(() => {
             const currentNodes = useScene.getState().nodes;
-            // Trigger a full scene re-validation after undo/redo
-            Object.values(currentNodes).forEach((node) => {
-                useScene.getState().markDirty(node.id);
-            });
+            const { markDirty } = useScene.getState();
+            if (snapshotBefore) {
+                // Diff: only mark nodes that actually changed
+                for (const [id, node] of Object.entries(currentNodes)) {
+                    if (snapshotBefore[id] !== node) {
+                        markDirty(id);
+                        // Also mark parent so merged geometries update
+                        if (node.parentId)
+                            markDirty(node.parentId);
+                    }
+                }
+                // Nodes that were deleted (exist in prev but not current)
+                for (const [id, node] of Object.entries(snapshotBefore)) {
+                    if (!currentNodes[id]) {
+                        if (node.parentId)
+                            markDirty(node.parentId);
+                    }
+                }
+            }
+            else {
+                // No snapshot to diff against — fall back to marking all
+                for (const node of Object.values(currentNodes)) {
+                    markDirty(node.id);
+                }
+            }
         });
     }
-    // Update tracked lengths
+    // Update tracked lengths and snapshot
     prevPastLength = currentPastLength;
     prevFutureLength = currentFutureLength;
+    prevNodesSnapshot = useScene.getState().nodes;
 });

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

@@ -1 +1 @@
-{"version":3,"file":"ceiling-system.d.ts","sourceRoot":"","sources":["../../../src/systems/ceiling/ceiling-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,cAAc,CAAA;AAO1D,eAAO,MAAM,aAAa,YAuBzB,CAAA;AAeD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,KAAK,CAAC,cAAc,CA+CtF"}
+{"version":3,"file":"ceiling-system.d.ts","sourceRoot":"","sources":["../../../src/systems/ceiling/ceiling-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,cAAc,CAAA;AAO1D,eAAO,MAAM,aAAa,YAuBzB,CAAA;AAqBD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,KAAK,CAAC,cAAc,CA+CtF"}

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

@@ -34,6 +34,11 @@ function updateCeilingGeometry(node, mesh) {
     const newGeo = generateCeilingGeometry(node);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
+    const gridMesh = mesh.getObjectByName('ceiling-grid');
+    if (gridMesh) {
+        gridMesh.geometry.dispose();
+        gridMesh.geometry = newGeo;
+    }
     // Position at the ceiling height
     mesh.position.y = (node.height ?? 2.5) - 0.01; // Slight offset to avoid z-fighting with upper-level slabs
 }

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

@@ -0,0 +1,2 @@
+export declare const DoorSystem: () => null;
+//# sourceMappingURL=door-system.d.ts.map

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

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

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

@@ -0,0 +1,211 @@
+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 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 = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'door')
+                return;
+            const mesh = sceneRegistry.nodes.get(id);
+            if (!mesh)
+                return; // Keep dirty until mesh mounts
+            updateDoorMesh(node, mesh);
+            clearDirty(id);
+            // Rebuild the parent wall so its cutout reflects the updated door geometry
+            if (node.parentId) {
+                useScene.getState().dirtyNodes.add(node.parentId);
+            }
+        });
+    }, 3);
+    return null;
+};
+function addBox(parent, material, w, h, d, x, y, z) {
+    const m = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), material);
+    m.position.set(x, y, z);
+    parent.add(m);
+}
+function updateDoorMesh(node, mesh) {
+    // Root mesh is an invisible hitbox; all visuals live in child meshes
+    mesh.geometry.dispose();
+    mesh.geometry = new THREE.BoxGeometry(node.width, node.height, node.frameDepth);
+    mesh.material = hitboxMaterial;
+    // Sync transform from node (React may lag behind the system by a frame during drag)
+    mesh.position.set(node.position[0], node.position[1], node.position[2]);
+    mesh.rotation.set(node.rotation[0], node.rotation[1], node.rotation[2]);
+    // Dispose and remove all old visual children; preserve 'cutout'
+    for (const child of [...mesh.children]) {
+        if (child.name === 'cutout')
+            continue;
+        if (child instanceof THREE.Mesh)
+            child.geometry.dispose();
+        mesh.remove(child);
+    }
+    const { width, height, frameThickness, frameDepth, threshold, thresholdHeight, segments, handle, handleHeight, handleSide, doorCloser, panicBar, panicBarHeight, contentPadding, hingesSide, } = node;
+    // Leaf occupies the full opening (no bottom frame bar — door opens to floor)
+    const leafW = width - 2 * frameThickness;
+    const leafH = height - frameThickness; // only top frame
+    const leafDepth = 0.04;
+    // Leaf center is shifted down from door center by half the top frame
+    const leafCenterY = -frameThickness / 2;
+    // ── Frame members ──
+    // Left post — full height
+    addBox(mesh, baseMaterial, frameThickness, height, frameDepth, -width / 2 + frameThickness / 2, 0, 0);
+    // Right post — full height
+    addBox(mesh, baseMaterial, frameThickness, height, frameDepth, width / 2 - frameThickness / 2, 0, 0);
+    // Head (top bar) — full width
+    addBox(mesh, baseMaterial, width, frameThickness, frameDepth, 0, height / 2 - frameThickness / 2, 0);
+    // ── Threshold (inside the frame) ──
+    if (threshold) {
+        addBox(mesh, baseMaterial, leafW, thresholdHeight, frameDepth, 0, -height / 2 + thresholdHeight / 2, 0);
+    }
+    // ── Leaf — contentPadding border strips (no full backing; glass areas are open) ──
+    const cpX = contentPadding[0];
+    const cpY = contentPadding[1];
+    if (cpY > 0) {
+        // Top strip
+        addBox(mesh, baseMaterial, leafW, cpY, leafDepth, 0, leafCenterY + leafH / 2 - cpY / 2, 0);
+        // Bottom strip
+        addBox(mesh, baseMaterial, leafW, cpY, leafDepth, 0, leafCenterY - leafH / 2 + cpY / 2, 0);
+    }
+    if (cpX > 0) {
+        const innerH = leafH - 2 * cpY;
+        // Left strip
+        addBox(mesh, baseMaterial, cpX, innerH, leafDepth, -leafW / 2 + cpX / 2, leafCenterY, 0);
+        // Right strip
+        addBox(mesh, baseMaterial, cpX, innerH, leafDepth, leafW / 2 - cpX / 2, leafCenterY, 0);
+    }
+    // Content area inside padding
+    const contentW = leafW - 2 * cpX;
+    const contentH = leafH - 2 * cpY;
+    // ── Segments (stacked top to bottom within content area) ──
+    const totalRatio = segments.reduce((sum, s) => sum + s.heightRatio, 0);
+    const contentTop = leafCenterY + contentH / 2;
+    let segY = contentTop;
+    for (const seg of segments) {
+        const segH = (seg.heightRatio / totalRatio) * contentH;
+        const segCenterY = segY - segH / 2;
+        const numCols = seg.columnRatios.length;
+        const colSum = seg.columnRatios.reduce((a, b) => a + b, 0);
+        const usableW = contentW - (numCols - 1) * seg.dividerThickness;
+        const colWidths = seg.columnRatios.map((r) => (r / colSum) * usableW);
+        // Column x-centers (relative to mesh center)
+        const colXCenters = [];
+        let cx = -contentW / 2;
+        for (let c = 0; c < numCols; c++) {
+            colXCenters.push(cx + colWidths[c] / 2);
+            cx += colWidths[c];
+            if (c < numCols - 1)
+                cx += seg.dividerThickness;
+        }
+        // Column dividers within this segment
+        cx = -contentW / 2;
+        for (let c = 0; c < numCols - 1; c++) {
+            cx += colWidths[c];
+            addBox(mesh, baseMaterial, seg.dividerThickness, segH, leafDepth + 0.001, cx + seg.dividerThickness / 2, segCenterY, 0);
+            cx += seg.dividerThickness;
+        }
+        // Segment content per column
+        for (let c = 0; c < numCols; c++) {
+            const colW = colWidths[c];
+            const colX = colXCenters[c];
+            if (seg.type === 'glass') {
+                // Glass only — no opaque backing so it's truly transparent
+                const glassDepth = Math.max(0.004, leafDepth * 0.15);
+                addBox(mesh, glassMaterial, colW, segH, glassDepth, colX, segCenterY, 0);
+            }
+            else if (seg.type === 'panel') {
+                // Opaque leaf backing for this column
+                addBox(mesh, baseMaterial, colW, segH, leafDepth, colX, segCenterY, 0);
+                // Raised panel detail
+                const panelW = colW - 2 * seg.panelInset;
+                const panelH = segH - 2 * seg.panelInset;
+                if (panelW > 0.01 && panelH > 0.01) {
+                    const effectiveDepth = Math.abs(seg.panelDepth) < 0.002 ? 0.005 : Math.abs(seg.panelDepth);
+                    const panelZ = leafDepth / 2 + effectiveDepth / 2;
+                    addBox(mesh, baseMaterial, panelW, panelH, effectiveDepth, colX, segCenterY, panelZ);
+                }
+            }
+            else {
+                // 'empty' — opaque backing, no detail
+                addBox(mesh, baseMaterial, colW, segH, leafDepth, colX, segCenterY, 0);
+            }
+        }
+        segY -= segH;
+    }
+    // ── Handle ──
+    if (handle) {
+        // Convert from floor-based height to mesh-center-based Y
+        const handleY = handleHeight - height / 2;
+        // Handle grip sits on the front face (+Z) of the leaf
+        const faceZ = leafDepth / 2;
+        // X position: handleSide refers to which side the grip is on
+        const handleX = handleSide === 'right' ? leafW / 2 - 0.045 : -leafW / 2 + 0.045;
+        // Backplate
+        addBox(mesh, baseMaterial, 0.028, 0.14, 0.01, handleX, handleY, faceZ + 0.005);
+        // Grip lever
+        addBox(mesh, baseMaterial, 0.022, 0.1, 0.035, handleX, handleY, faceZ + 0.025);
+    }
+    // ── Door closer (commercial hardware at top) ──
+    if (doorCloser) {
+        const closerY = leafCenterY + leafH / 2 - 0.04;
+        // Body
+        addBox(mesh, baseMaterial, 0.28, 0.055, 0.055, 0, closerY, leafDepth / 2 + 0.03);
+        // Arm (simplified as thin bar to frame side)
+        addBox(mesh, baseMaterial, 0.14, 0.015, 0.015, leafW / 4, closerY + 0.025, leafDepth / 2 + 0.015);
+    }
+    // ── Panic bar ──
+    if (panicBar) {
+        const barY = panicBarHeight - height / 2;
+        addBox(mesh, baseMaterial, leafW * 0.72, 0.04, 0.055, 0, barY, leafDepth / 2 + 0.03);
+    }
+    // ── Hinges (3 knuckle-style hinges on the hinge side) ──
+    {
+        const hingeX = hingesSide === 'right' ? leafW / 2 - 0.012 : -leafW / 2 + 0.012;
+        const hingeZ = 0; // centered in leaf depth
+        const hingeH = 0.1;
+        const hingeW = 0.024;
+        const hingeD = leafDepth + 0.016;
+        // Bottom hinge ~0.25m from floor, middle hinge, top hinge ~0.25m from top
+        const leafBottom = leafCenterY - leafH / 2;
+        const leafTop = leafCenterY + leafH / 2;
+        addBox(mesh, baseMaterial, hingeW, hingeH, hingeD, hingeX, leafBottom + 0.25, hingeZ);
+        addBox(mesh, baseMaterial, hingeW, hingeH, hingeD, hingeX, (leafBottom + leafTop) / 2, hingeZ);
+        addBox(mesh, baseMaterial, hingeW, hingeH, hingeD, hingeX, leafTop - 0.25, hingeZ);
+    }
+    // ── Cutout (for wall CSG) — always full door dimensions, 1m deep ──
+    let cutout = mesh.getObjectByName('cutout');
+    if (!cutout) {
+        cutout = new THREE.Mesh();
+        cutout.name = 'cutout';
+        mesh.add(cutout);
+    }
+    cutout.geometry.dispose();
+    cutout.geometry = new THREE.BoxGeometry(node.width, node.height, 1.0);
+    cutout.visible = false;
+}

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

@@ -2,6 +2,7 @@ import { useFrame } from '@react-three/fiber';
 import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
 import { spatialGridManager } from '../../hooks/spatial-grid/spatial-grid-manager';
 import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
+import { getScaledDimensions } from '../../schema';
 import useScene from '../../store/use-scene';
 // ============================================================================
 // ITEM SYSTEM
@@ -36,12 +37,12 @@ export const ItemSystem = () => {
                 if (parentNode?.type !== 'item') {
                     // Floor item: elevate by slab height (using full footprint overlap)
                     const levelId = resolveLevelId(item, nodes);
-                    const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, item.position, item.asset.dimensions, item.rotation);
+                    const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, item.position, getScaledDimensions(item), item.rotation);
                     mesh.position.y = slabElevation + item.position[1];
                 }
             }
             clearDirty(id);
         });
-    });
+    }, 2);
     return null;
 };

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

@@ -1,8 +1,16 @@
 import * as THREE from 'three';
-import type { RoofNode } from '../../schema';
+import { Brush } from 'three-bvh-csg';
+import type { RoofSegmentNode } from '../../schema';
 export declare const RoofSystem: () => null;
 /**
- * Generates detailed gable roof geometry with layers, walls, and overhangs
+ * Generate complete hollow-shell geometry for a roof segment.
+ * Ports the prototype's CSG approach using three-bvh-csg.
  */
-export declare function generateRoofGeometry(roofNode: RoofNode): THREE.BufferGeometry;
+export declare function getRoofSegmentBrushes(node: RoofSegmentNode): {
+    deckSlab: Brush;
+    shinSlab: Brush;
+    wallBrush: Brush;
+    innerBrush: Brush;
+} | null;
+export declare function generateRoofSegmentGeometry(node: RoofSegmentNode): THREE.BufferGeometry;
 //# sourceMappingURL=roof-system.d.ts.map

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,KAAK,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAmBvD,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAqJD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAsH7E"}
+{"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"}