@pascal-app/core 0.3.2 → 0.4.0

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

@@ -34,6 +34,10 @@ function updateSlabGeometry(node, mesh) {
     const newGeo = generateSlabGeometry(node);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
+    // For negative elevation, shift the mesh down so the top face sits at Y=elevation
+    // rather than at Y=0. Positive elevation stays at Y=0 (slab sits at floor level).
+    const elevation = node.elevation ?? 0.05;
+    mesh.position.y = elevation < 0 ? elevation : 0;
 }
 /** Half of default wall thickness — used to extend slab geometry under walls */
 const SLAB_OUTSET = 0.05;
@@ -89,44 +93,85 @@ function outsetPolygon(polygon, amount) {
  * Generates extruded slab geometry from polygon
  */
 export function generateSlabGeometry(slabNode) {
+    const elevation = slabNode.elevation ?? 0.05;
+    return elevation < 0 ? generatePoolGeometry(slabNode) : generatePositiveSlabGeometry(slabNode);
+}
+/**
+ * Standard slab: flat extrusion upward from Y=0 by elevation thickness.
+ */
+function generatePositiveSlabGeometry(slabNode) {
     const polygon = outsetPolygon(slabNode.polygon, SLAB_OUTSET);
     const elevation = slabNode.elevation ?? 0.05;
-    if (polygon.length < 3) {
+    if (polygon.length < 3)
         return new THREE.BufferGeometry();
-    }
-    // Create shape from polygon
-    // Shape is in X-Y plane, we'll rotate to X-Z plane after extrusion
     const shape = new THREE.Shape();
-    const firstPt = polygon[0];
-    // Negate Y (which becomes Z) to get correct orientation after rotation
-    shape.moveTo(firstPt[0], -firstPt[1]);
-    for (let i = 1; i < polygon.length; i++) {
-        const pt = polygon[i];
-        shape.lineTo(pt[0], -pt[1]);
-    }
+    shape.moveTo(polygon[0][0], -polygon[0][1]);
+    for (let i = 1; i < polygon.length; i++)
+        shape.lineTo(polygon[i][0], -polygon[i][1]);
     shape.closePath();
-    // Add holes to the shape
-    const holes = slabNode.holes || [];
-    for (const holePolygon of holes) {
+    for (const holePolygon of slabNode.holes ?? []) {
         if (holePolygon.length < 3)
             continue;
         const holePath = new THREE.Path();
-        const holeFirstPt = holePolygon[0];
-        holePath.moveTo(holeFirstPt[0], -holeFirstPt[1]);
-        for (let i = 1; i < holePolygon.length; i++) {
-            const pt = holePolygon[i];
-            holePath.lineTo(pt[0], -pt[1]);
-        }
+        holePath.moveTo(holePolygon[0][0], -holePolygon[0][1]);
+        for (let i = 1; i < holePolygon.length; i++)
+            holePath.lineTo(holePolygon[i][0], -holePolygon[i][1]);
         holePath.closePath();
         shape.holes.push(holePath);
     }
-    // Extrude the shape by elevation
-    const geometry = new THREE.ExtrudeGeometry(shape, {
-        depth: elevation,
-        bevelEnabled: false,
-    });
-    // Rotate so extrusion direction (Z) becomes height direction (Y)
+    const geometry = new THREE.ExtrudeGeometry(shape, { depth: elevation, bevelEnabled: false });
     geometry.rotateX(-Math.PI / 2);
     geometry.computeVertexNormals();
     return geometry;
 }
+/**
+ * Pool / recessed slab: floor cap at Y=0 (local) + inner walls up to Y=|elevation|.
+ * No top cap — the opening at ground level is handled by the ground occluder hole.
+ * mesh.position.y must be set to elevation so the floor sits at the correct world Y.
+ *
+ * Geometry is built directly in 3D (Y-up) to avoid rotation confusion:
+ *   - floor in XZ plane at Y=0, normals pointing +Y (visible when looking down into pool)
+ *   - walls from Y=0 to Y=depth, inward-facing normals (visible from inside pool)
+ */
+function generatePoolGeometry(slabNode) {
+    const polygon = outsetPolygon(slabNode.polygon, SLAB_OUTSET);
+    const depth = Math.abs(slabNode.elevation ?? 0.05);
+    if (polygon.length < 3)
+        return new THREE.BufferGeometry();
+    const positions = [];
+    const indices = [];
+    const n = polygon.length;
+    // --- Floor at Y=0 ---
+    for (const [x, z] of polygon)
+        positions.push(x, 0, z);
+    const pts2d = polygon.map(([x, z]) => new THREE.Vector2(x, z));
+    const holesPts2d = (slabNode.holes ?? []).map((h) => h.map(([x, z]) => new THREE.Vector2(x, z)));
+    for (const hole of slabNode.holes ?? []) {
+        for (const [x, z] of hole)
+            positions.push(x, 0, z);
+    }
+    const floorTris = THREE.ShapeUtils.triangulateShape(pts2d, holesPts2d);
+    for (const tri of floorTris) {
+        // Reversed winding → normals point +Y (upward) in XZ plane
+        indices.push(tri[0], tri[2], tri[1]);
+    }
+    // --- Inner walls (no top cap at Y=depth) ---
+    // Standard winding on a CCW polygon in XZ gives inward-facing normals.
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const [x0, z0] = polygon[i];
+        const [x1, z1] = polygon[j];
+        const vBase = positions.length / 3;
+        positions.push(x0, 0, z0); // v0 — floor level
+        positions.push(x1, 0, z1); // v1 — floor level
+        positions.push(x1, depth, z1); // v2 — ground level
+        positions.push(x0, depth, z0); // v3 — ground level
+        indices.push(vBase, vBase + 1, vBase + 2);
+        indices.push(vBase, vBase + 2, vBase + 3);
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    geo.setIndex(indices);
+    geo.computeVertexNormals();
+    return geo;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"stair-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-system.tsx"],"names":[],"mappings":"AAiBA,eAAO,MAAM,WAAW,YA4FvB,CAAA"}

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

@@ -0,0 +1,354 @@
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+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 useScene from '../../store/use-scene';
+const pendingStairUpdates = new Set();
+const MAX_STAIRS_PER_FRAME = 2;
+const MAX_SEGMENTS_PER_FRAME = 4;
+// ============================================================================
+// STAIR SYSTEM
+// ============================================================================
+export const StairSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    const rootNodeIds = useScene((state) => state.rootNodeIds);
+    useFrame(() => {
+        if (rootNodeIds.length === 0) {
+            pendingStairUpdates.clear();
+            return;
+        }
+        if (dirtyNodes.size === 0 && pendingStairUpdates.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        // --- Pass 1: Process dirty stair-segments (throttled) ---
+        // Collect parent stair IDs that need segment transform recomputation
+        const parentsNeedingSegmentSync = new Set();
+        let segmentsProcessed = 0;
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node)
+                return;
+            if (node.type === 'stair-segment') {
+                const mesh = sceneRegistry.nodes.get(id);
+                if (mesh) {
+                    const isVisible = mesh.parent?.visible !== false;
+                    if (isVisible && segmentsProcessed < MAX_SEGMENTS_PER_FRAME) {
+                        // Geometry will be updated; chained position is applied in the parent sync pass below
+                        updateStairSegmentGeometry(node, mesh);
+                        if (node.parentId)
+                            parentsNeedingSegmentSync.add(node.parentId);
+                        segmentsProcessed++;
+                    }
+                    else if (isVisible) {
+                        return; // Over budget — keep dirty, process next frame
+                    }
+                    else if (mesh.geometry.type === 'BoxGeometry') {
+                        // Replace BoxGeometry placeholder with empty geometry
+                        mesh.geometry.dispose();
+                        const placeholder = new THREE.BufferGeometry();
+                        placeholder.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+                        mesh.geometry = placeholder;
+                    }
+                    clearDirty(id);
+                }
+                else {
+                    clearDirty(id);
+                }
+                // Queue the parent stair for a merged geometry update
+                if (node.parentId) {
+                    pendingStairUpdates.add(node.parentId);
+                }
+            }
+            else if (node.type === 'stair') {
+                pendingStairUpdates.add(id);
+                // Also sync individual segment positions when in edit mode
+                parentsNeedingSegmentSync.add(id);
+                clearDirty(id);
+            }
+        });
+        // --- Pass 1b: Sync chained transforms to individual segment meshes (edit mode) ---
+        for (const stairId of parentsNeedingSegmentSync) {
+            const stairNode = nodes[stairId];
+            if (!stairNode || stairNode.type !== 'stair')
+                continue;
+            const group = sceneRegistry.nodes.get(stairId);
+            if (group) {
+                syncStairGroupElevation(stairNode, group, nodes);
+            }
+            syncSegmentMeshTransforms(stairNode, nodes);
+        }
+        // --- Pass 2: Process pending merged-stair updates (throttled) ---
+        let stairsProcessed = 0;
+        for (const id of pendingStairUpdates) {
+            if (stairsProcessed >= MAX_STAIRS_PER_FRAME)
+                break;
+            const node = nodes[id];
+            if (!node || node.type !== 'stair') {
+                pendingStairUpdates.delete(id);
+                continue;
+            }
+            const group = sceneRegistry.nodes.get(id);
+            if (group) {
+                const mergedMesh = group.getObjectByName('merged-stair');
+                if (mergedMesh?.visible !== false) {
+                    updateMergedStairGeometry(node, group, nodes);
+                    stairsProcessed++;
+                }
+            }
+            pendingStairUpdates.delete(id);
+        }
+    }, 5);
+    return null;
+};
+// ============================================================================
+// SEGMENT GEOMETRY
+// ============================================================================
+/**
+ * Generates the step/landing profile as a THREE.Shape (in the XY plane),
+ * then extrudes along Z for the segment width.
+ */
+function generateStairSegmentGeometry(segment, absoluteHeight) {
+    const { width, length, height, stepCount, segmentType, fillToFloor, thickness } = segment;
+    const shape = new THREE.Shape();
+    if (segmentType === 'landing') {
+        shape.moveTo(0, 0);
+        shape.lineTo(length, 0);
+        if (fillToFloor) {
+            shape.lineTo(length, -absoluteHeight);
+            shape.lineTo(0, -absoluteHeight);
+        }
+        else {
+            shape.lineTo(length, -thickness);
+            shape.lineTo(0, -thickness);
+        }
+    }
+    else {
+        const riserHeight = height / stepCount;
+        const treadDepth = length / stepCount;
+        shape.moveTo(0, 0);
+        // Draw step profile
+        for (let i = 0; i < stepCount; i++) {
+            shape.lineTo(i * treadDepth, (i + 1) * riserHeight);
+            shape.lineTo((i + 1) * treadDepth, (i + 1) * riserHeight);
+        }
+        if (fillToFloor) {
+            shape.lineTo(length, -absoluteHeight);
+            shape.lineTo(0, -absoluteHeight);
+        }
+        else {
+            // Sloped bottom with consistent thickness
+            const angle = Math.atan(riserHeight / treadDepth);
+            const vOff = thickness / Math.cos(angle);
+            // Bottom-back corner
+            shape.lineTo(length, height - vOff);
+            if (absoluteHeight === 0) {
+                // Ground floor: slope hits the ground (y=0)
+                const m = riserHeight / treadDepth;
+                const xGround = length - (height - vOff) / m;
+                if (xGround > 0) {
+                    shape.lineTo(xGround, 0);
+                }
+            }
+            else {
+                // Floating: parallel slope
+                shape.lineTo(0, -vOff);
+            }
+        }
+    }
+    shape.lineTo(0, 0);
+    const geometry = new THREE.ExtrudeGeometry(shape, {
+        steps: 1,
+        depth: width,
+        bevelEnabled: false,
+    });
+    // Rotate so extrusion is along X (width), and the shape is in the XZ plane
+    // Shape is drawn in XY, extruded along Z → rotate -90° around Y then offset
+    const matrix = new THREE.Matrix4();
+    matrix.makeRotationY(-Math.PI / 2);
+    matrix.setPosition(width / 2, 0, 0);
+    geometry.applyMatrix4(matrix);
+    return geometry;
+}
+function updateStairSegmentGeometry(node, mesh) {
+    // Compute absolute height from parent chain
+    const absoluteHeight = computeAbsoluteHeight(node);
+    const newGeometry = generateStairSegmentGeometry(node, absoluteHeight);
+    mesh.geometry.dispose();
+    mesh.geometry = newGeometry;
+    // NOTE: position/rotation are NOT set here — they're set by syncSegmentMeshTransforms
+    // which computes the chained position based on segment order and attachmentSide.
+}
+/**
+ * Applies chained transforms to individual segment meshes (edit mode).
+ * Each segment's world position is determined by the chain of previous segments,
+ * not by the node's stored position field.
+ */
+function syncSegmentMeshTransforms(stairNode, nodes) {
+    const segments = (stairNode.children ?? [])
+        .map((childId) => nodes[childId])
+        .filter((n) => n?.type === 'stair-segment');
+    if (segments.length === 0)
+        return;
+    const transforms = computeSegmentTransforms(segments);
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const transform = transforms[i];
+        const mesh = sceneRegistry.nodes.get(segment.id);
+        if (mesh) {
+            mesh.position.set(transform.position[0], transform.position[1], transform.position[2]);
+            mesh.rotation.y = transform.rotation;
+        }
+    }
+}
+function syncStairGroupElevation(stairNode, group, nodes) {
+    const levelId = resolveLevelId(stairNode, nodes);
+    const slabElevation = getStairSlabElevation(levelId, stairNode, nodes);
+    group.position.y = stairNode.position[1] + slabElevation;
+}
+function getStairSlabElevation(levelId, stairNode, nodes) {
+    const segments = (stairNode.children ?? [])
+        .map((childId) => nodes[childId])
+        .filter((n) => n?.type === 'stair-segment');
+    if (segments.length === 0)
+        return 0;
+    const transforms = computeSegmentTransforms(segments);
+    let maxElevation = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const transform = transforms[i];
+        const [centerOffsetX, centerOffsetZ] = rotateXZ(0, segment.length / 2, transform.rotation);
+        const centerInGroupX = transform.position[0] + centerOffsetX;
+        const centerInGroupZ = transform.position[2] + centerOffsetZ;
+        const [centerOffsetWorldX, centerOffsetWorldZ] = rotateXZ(centerInGroupX, centerInGroupZ, stairNode.rotation);
+        const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, [
+            stairNode.position[0] + centerOffsetWorldX,
+            stairNode.position[1] + transform.position[1],
+            stairNode.position[2] + centerOffsetWorldZ,
+        ], [segment.width, Math.max(segment.height, segment.thickness, 0.01), segment.length], [0, stairNode.rotation + transform.rotation, 0]);
+        if (slabElevation > maxElevation) {
+            maxElevation = slabElevation;
+        }
+    }
+    return maxElevation === Number.NEGATIVE_INFINITY ? 0 : maxElevation;
+}
+// ============================================================================
+// MERGED STAIR GEOMETRY
+// ============================================================================
+const _matrix = new THREE.Matrix4();
+const _position = new THREE.Vector3();
+const _quaternion = new THREE.Quaternion();
+const _scale = new THREE.Vector3(1, 1, 1);
+const _yAxis = new THREE.Vector3(0, 1, 0);
+function updateMergedStairGeometry(stairNode, group, nodes) {
+    const mergedMesh = group.getObjectByName('merged-stair');
+    if (!mergedMesh)
+        return;
+    const children = stairNode.children ?? [];
+    const segments = children
+        .map((childId) => nodes[childId])
+        .filter((n) => n?.type === 'stair-segment');
+    if (segments.length === 0) {
+        mergedMesh.geometry.dispose();
+        mergedMesh.geometry = new THREE.BufferGeometry();
+        mergedMesh.geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+        return;
+    }
+    // Compute chained transforms for segments
+    const transforms = computeSegmentTransforms(segments);
+    const geometries = [];
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const transform = transforms[i];
+        const absoluteHeight = transform.position[1];
+        const geo = generateStairSegmentGeometry(segment, absoluteHeight);
+        // Apply segment transform (position + rotation) relative to parent stair
+        _position.set(transform.position[0], transform.position[1], transform.position[2]);
+        _quaternion.setFromAxisAngle(_yAxis, transform.rotation);
+        _matrix.compose(_position, _quaternion, _scale);
+        geo.applyMatrix4(_matrix);
+        geometries.push(geo);
+    }
+    const merged = mergeGeometries(geometries, false);
+    if (merged) {
+        mergedMesh.geometry.dispose();
+        mergedMesh.geometry = merged;
+    }
+    // Dispose individual geometries
+    for (const geo of geometries) {
+        geo.dispose();
+    }
+}
+/**
+ * Computes world-relative transforms for each segment by chaining
+ * based on attachmentSide. This mirrors the prototype's StairSystem logic.
+ */
+function computeSegmentTransforms(segments) {
+    const transforms = [];
+    let currentPos = new THREE.Vector3(0, 0, 0);
+    let currentRot = 0;
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (i === 0) {
+            transforms.push({
+                position: [currentPos.x, currentPos.y, currentPos.z],
+                rotation: currentRot,
+            });
+        }
+        else {
+            const prev = segments[i - 1];
+            const localAttachPos = new THREE.Vector3();
+            let rotChange = 0;
+            switch (segment.attachmentSide) {
+                case 'front':
+                    localAttachPos.set(0, prev.height, prev.length);
+                    rotChange = 0;
+                    break;
+                case 'left':
+                    localAttachPos.set(prev.width / 2, prev.height, prev.length / 2);
+                    rotChange = Math.PI / 2;
+                    break;
+                case 'right':
+                    localAttachPos.set(-prev.width / 2, prev.height, prev.length / 2);
+                    rotChange = -Math.PI / 2;
+                    break;
+            }
+            // Rotate local attachment point by previous global rotation
+            localAttachPos.applyAxisAngle(new THREE.Vector3(0, 1, 0), currentRot);
+            currentPos = currentPos.clone().add(localAttachPos);
+            currentRot += rotChange;
+            transforms.push({
+                position: [currentPos.x, currentPos.y, currentPos.z],
+                rotation: currentRot,
+            });
+        }
+    }
+    return transforms;
+}
+function rotateXZ(x, z, angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return [x * cos + z * sin, -x * sin + z * cos];
+}
+/**
+ * Computes the absolute Y height of a segment by traversing the stair's segment chain.
+ */
+function computeAbsoluteHeight(node) {
+    const nodes = useScene.getState().nodes;
+    if (!node.parentId)
+        return 0;
+    const parent = nodes[node.parentId];
+    if (!parent || parent.type !== 'stair')
+        return 0;
+    const stair = parent;
+    const segments = (stair.children ?? [])
+        .map((childId) => nodes[childId])
+        .filter((n) => n?.type === 'stair-segment');
+    const transforms = computeSegmentTransforms(segments);
+    const index = segments.findIndex((s) => s.id === node.id);
+    if (index < 0)
+        return 0;
+    return transforms[index]?.position[1] ?? 0;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,OAAO,KAAK,EAAE,OAAO,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGhE,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AASxB,eAAO,MAAM,UAAU,YAsDtB,CAAA;AA0DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,oFA+FlB"}
+{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,OAAO,KAAK,EAAE,OAAO,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGhE,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAUxB,eAAO,MAAM,UAAU,YAuDtB,CAAA;AA0DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,oFA+FlB"}

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

@@ -13,6 +13,7 @@ const csgEvaluator = new Evaluator();
 // ============================================================================
 // WALL SYSTEM
 // ============================================================================
+let useFrameNb = 0;
 export const WallSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
@@ -22,6 +23,7 @@ export const WallSystem = () => {
         const nodes = useScene.getState().nodes;
         // Collect dirty walls and their levels
         const dirtyWallsByLevel = new Map();
+        useFrameNb += 1;
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
             if (!node || node.type !== 'wall')

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

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

package/dist/systems/window/window-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 glassMaterial = new MeshStandardNodeMaterial({
-    name: 'glass',
-    color: 'lightblue',
-    roughness: 0.05,
-    metalness: 0.1,
-    transparent: true,
-    opacity: 0.3,
-    side: DoubleSide,
-    depthWrite: false,
-});
-const frameMaterial = new MeshStandardNodeMaterial({
-    name: 'window-frame',
-    color: '#e8e8e8',
-    roughness: 0.6,
-    metalness: 0,
-});
 // Invisible material for root mesh — used as selection hitbox only
 const hitboxMaterial = new THREE.MeshBasicMaterial({ visible: false });
 export const WindowSystem = () => {
@@ -71,11 +55,11 @@ function updateWindowMesh(node, mesh) {
     const innerH = height - 2 * frameThickness;
     // ── Frame members ──
     // Top / bottom — full width
-    addBox(mesh, frameMaterial, width, frameThickness, frameDepth, 0, height / 2 - frameThickness / 2, 0);
-    addBox(mesh, frameMaterial, width, frameThickness, frameDepth, 0, -height / 2 + frameThickness / 2, 0);
+    addBox(mesh, baseMaterial, width, frameThickness, frameDepth, 0, height / 2 - frameThickness / 2, 0);
+    addBox(mesh, baseMaterial, width, frameThickness, frameDepth, 0, -height / 2 + frameThickness / 2, 0);
     // Left / right — inner height to avoid corner overlap
-    addBox(mesh, frameMaterial, frameThickness, innerH, frameDepth, -width / 2 + frameThickness / 2, 0, 0);
-    addBox(mesh, frameMaterial, frameThickness, innerH, frameDepth, width / 2 - frameThickness / 2, 0, 0);
+    addBox(mesh, baseMaterial, frameThickness, innerH, frameDepth, -width / 2 + frameThickness / 2, 0, 0);
+    addBox(mesh, baseMaterial, frameThickness, innerH, frameDepth, width / 2 - frameThickness / 2, 0, 0);
     // ── Pane grid ──
     const numCols = columnRatios.length;
     const numRows = rowRatios.length;
@@ -107,7 +91,7 @@ function updateWindowMesh(node, mesh) {
     cx = -innerW / 2;
     for (let c = 0; c < numCols - 1; c++) {
         cx += colWidths[c];
-        addBox(mesh, frameMaterial, columnDividerThickness, innerH, frameDepth, cx + columnDividerThickness / 2, 0, 0);
+        addBox(mesh, baseMaterial, columnDividerThickness, innerH, frameDepth, cx + columnDividerThickness / 2, 0, 0);
         cx += columnDividerThickness;
     }
     // Row dividers — per column width, so they don't overlap column dividers (top to bottom)
@@ -116,7 +100,7 @@ function updateWindowMesh(node, mesh) {
         cy -= rowHeights[r];
         const divY = cy - rowDividerThickness / 2;
         for (let c = 0; c < numCols; c++) {
-            addBox(mesh, frameMaterial, colWidths[c], rowDividerThickness, frameDepth, colXCenters[c], divY, 0);
+            addBox(mesh, baseMaterial, colWidths[c], rowDividerThickness, frameDepth, colXCenters[c], divY, 0);
         }
         cy -= rowDividerThickness;
     }
@@ -132,7 +116,7 @@ function updateWindowMesh(node, mesh) {
         const sillW = width + sillDepth * 0.4; // slightly wider than frame
         // Protrudes from the front face of the frame (+Z)
         const sillZ = frameDepth / 2 + sillDepth / 2;
-        addBox(mesh, frameMaterial, sillW, sillThickness, sillDepth, 0, -height / 2 - sillThickness / 2, sillZ);
+        addBox(mesh, baseMaterial, sillW, sillThickness, sillDepth, 0, -height / 2 - sillThickness / 2, sillZ);
     }
     // ── Cutout (for wall CSG) — always full window dimensions, 1m deep ──
     let cutout = mesh.getObjectByName('cutout');

package/dist/utils/clone-scene-graph.d.ts

@@ -10,9 +10,33 @@ export type SceneGraph = {
  * parent-child relationships and other internal references.
  *
  * This is useful for:
+ * - Duplicating a project (host app creates a new project record, then loads the cloned scene)
  * - Copying nodes between different projects
- * - Duplicating a subset of a scene within the same project
  * - Multi-scene in-memory scenarios
  */
 export declare function cloneSceneGraph(sceneGraph: SceneGraph): SceneGraph;
+/**
+ * Deep clones a level node and all its descendants with fresh IDs.
+ * All internal references (parentId, children, wallId) are remapped to the new IDs.
+ * The cloned level node's parentId is preserved (building ID) — not remapped.
+ *
+ * Unlike `cloneSceneGraph` (which operates on serialized data), this function works
+ * on live runtime nodes that may have non-serializable properties (Three.js objects,
+ * etc.). It uses JSON roundtrip to safely strip them.
+ *
+ * @returns clonedNodes - flat array of all cloned nodes (level + descendants)
+ * @returns newLevelId - the ID of the cloned level node
+ * @returns idMap - old ID → new ID mapping
+ */
+export declare function cloneLevelSubtree(nodes: Record<AnyNodeId, AnyNode>, levelId: AnyNodeId): {
+    clonedNodes: AnyNode[];
+    newLevelId: AnyNodeId;
+    idMap: Map<string, string>;
+};
+/**
+ * Forks a scene graph for use as a new project: clones with new IDs and strips
+ * scan and guide nodes (and their references) since those contain user-uploaded
+ * imagery that shouldn't carry over to a forked project.
+ */
+export declare function forkSceneGraph(sceneGraph: SceneGraph): SceneGraph;
 //# sourceMappingURL=clone-scene-graph.d.ts.map

package/dist/utils/clone-scene-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;CAC/C,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CA4FlE"}
+{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;CAC/C,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAuGlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA8E/E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAgEjE"}