@pascal-app/core 0.3.3 → 0.4.0

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"}

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"}