@pascal-app/core 0.1.13 → 0.3.0

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

@@ -24,7 +24,7 @@ export const SlabSystem = () => {
             }
             // If mesh not found, keep it dirty for next frame
         });
-    });
+    }, 1);
     return null;
 };
 /**
@@ -63,8 +63,8 @@ function outsetPolygon(polygon, amount) {
             offEdges.push([polygon[i][0], polygon[i][1], dx, dz]);
             continue;
         }
-        const nx = (s * dz / len) * amount;
-        const nz = (s * -dx / len) * amount;
+        const nx = ((s * dz) / len) * amount;
+        const nz = ((s * -dx) / len) * amount;
         offEdges.push([polygon[i][0] + nx, polygon[i][1] + nz, dx, dz]);
     }
     // Intersect consecutive offset edges to get new vertices

package/dist/systems/wall/wall-footprint.d.ts

@@ -0,0 +1,7 @@
+import type { WallNode } from '../../schema';
+import { type Point2D, type WallMiterData } from './wall-mitering';
+export declare const DEFAULT_WALL_THICKNESS = 0.1;
+export declare const DEFAULT_WALL_HEIGHT = 2.5;
+export declare function getWallThickness(wallNode: WallNode): number;
+export declare function getWallPlanFootprint(wallNode: WallNode, miterData: WallMiterData): Point2D[];
+//# sourceMappingURL=wall-footprint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,KAAK,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE9E,eAAO,MAAM,sBAAsB,MAAM,CAAA;AACzC,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAEtC,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE3D;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,EAAE,CAkD5F"}

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

@@ -0,0 +1,49 @@
+import { pointToKey } from './wall-mitering';
+export const DEFAULT_WALL_THICKNESS = 0.1;
+export const DEFAULT_WALL_HEIGHT = 2.5;
+export function getWallThickness(wallNode) {
+    return wallNode.thickness ?? DEFAULT_WALL_THICKNESS;
+}
+export function getWallPlanFootprint(wallNode, miterData) {
+    const { junctionData } = miterData;
+    const wallStart = { x: wallNode.start[0], y: wallNode.start[1] };
+    const wallEnd = { x: wallNode.end[0], y: wallNode.end[1] };
+    const thickness = getWallThickness(wallNode);
+    const halfT = thickness / 2;
+    const v = { x: wallEnd.x - wallStart.x, y: wallEnd.y - wallStart.y };
+    const L = Math.sqrt(v.x * v.x + v.y * v.y);
+    if (L < 1e-9) {
+        return [];
+    }
+    const nUnit = { x: -v.y / L, y: v.x / L };
+    const keyStart = pointToKey(wallStart);
+    const keyEnd = pointToKey(wallEnd);
+    const startJunction = junctionData.get(keyStart)?.get(wallNode.id);
+    const endJunction = junctionData.get(keyEnd)?.get(wallNode.id);
+    const pStartLeft = startJunction?.left || {
+        x: wallStart.x + nUnit.x * halfT,
+        y: wallStart.y + nUnit.y * halfT,
+    };
+    const pStartRight = startJunction?.right || {
+        x: wallStart.x - nUnit.x * halfT,
+        y: wallStart.y - nUnit.y * halfT,
+    };
+    // Junction offsets are stored relative to the outgoing direction.
+    const pEndLeft = endJunction?.right || {
+        x: wallEnd.x + nUnit.x * halfT,
+        y: wallEnd.y + nUnit.y * halfT,
+    };
+    const pEndRight = endJunction?.left || {
+        x: wallEnd.x - nUnit.x * halfT,
+        y: wallEnd.y - nUnit.y * halfT,
+    };
+    const polygon = [pStartRight, pEndRight];
+    if (endJunction) {
+        polygon.push(wallEnd);
+    }
+    polygon.push(pEndLeft, pStartLeft);
+    if (startJunction) {
+        polygon.push(wallStart);
+    }
+    return polygon;
+}

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

@@ -52,11 +52,11 @@ function findJunctions(walls) {
         if (!junctions.has(keyStart)) {
             junctions.set(keyStart, { meetingPoint: startPt, connectedWalls: [] });
         }
-        junctions.get(keyStart).connectedWalls.push({ wall, endType: 'start' });
+        junctions.get(keyStart)?.connectedWalls.push({ wall, endType: 'start' });
         if (!junctions.has(keyEnd)) {
             junctions.set(keyEnd, { meetingPoint: endPt, connectedWalls: [] });
         }
-        junctions.get(keyEnd).connectedWalls.push({ wall, endType: 'end' });
+        junctions.get(keyEnd)?.connectedWalls.push({ wall, endType: 'end' });
     }
     // Second pass: detect T-junctions (walls passing through junction points)
     for (const [_key, junction] of junctions.entries()) {

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;AAEhE,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAUxB,eAAO,MAAM,UAAU,YAuDtB,CAAA;AA2DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,oFA4IlB"}
+{"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

@@ -1,12 +1,13 @@
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
-import { computeBoundsTree } from 'three-mesh-bvh';
 import { Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
+import { computeBoundsTree } from 'three-mesh-bvh';
 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';
-import { calculateLevelMiters, getAdjacentWallIds, pointToKey, } from './wall-mitering';
+import { DEFAULT_WALL_HEIGHT, getWallPlanFootprint, getWallThickness } from './wall-footprint';
+import { calculateLevelMiters, getAdjacentWallIds, } from './wall-mitering';
 // Reusable CSG evaluator for better performance
 const csgEvaluator = new Evaluator();
 // ============================================================================
@@ -33,7 +34,7 @@ export const WallSystem = () => {
             if (!dirtyWallsByLevel.has(levelId)) {
                 dirtyWallsByLevel.set(levelId, new Set());
             }
-            dirtyWallsByLevel.get(levelId).add(id);
+            dirtyWallsByLevel.get(levelId)?.add(id);
         });
         // Process each level that has dirty walls
         for (const [levelId, dirtyWallIds] of dirtyWallsByLevel) {
@@ -59,7 +60,7 @@ export const WallSystem = () => {
                 }
             }
         }
-    });
+    }, 4);
     return null;
 };
 /**
@@ -117,60 +118,22 @@ function updateWallGeometry(wallId, miterData) {
  * then we transform to wall-local for the 3D mesh.
  */
 export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabElevation = 0) {
-    const { junctionData } = miterData;
     const wallStart = { x: wallNode.start[0], y: wallNode.start[1] };
     const wallEnd = { x: wallNode.end[0], y: wallNode.end[1] };
     // Positive slab: shift the whole wall up (full height preserved)
     // Negative slab: extend wall downward so top stays fixed at wallNode.height
-    const wallHeight = wallNode.height ?? 2.5;
+    const wallHeight = wallNode.height ?? DEFAULT_WALL_HEIGHT;
     const height = slabElevation > 0 ? wallHeight : wallHeight - slabElevation;
-    const thickness = wallNode.thickness ?? 0.1;
-    const halfT = thickness / 2;
+    const thickness = getWallThickness(wallNode);
     // Wall direction and normal (exactly like demo)
     const v = { x: wallEnd.x - wallStart.x, y: wallEnd.y - wallStart.y };
     const L = Math.sqrt(v.x * v.x + v.y * v.y);
     if (L < 1e-9) {
         return new THREE.BufferGeometry();
     }
-    const nUnit = { x: -v.y / L, y: v.x / L };
-    // Get junction data for start and end (exactly like demo)
-    const keyStart = pointToKey(wallStart);
-    const keyEnd = pointToKey(wallEnd);
-    const startJunction = junctionData.get(keyStart)?.get(wallNode.id);
-    const endJunction = junctionData.get(keyEnd)?.get(wallNode.id);
-    // Calculate polygon corners in world coordinates (exactly like demo)
-    // p_start_L = left side at start
-    // p_start_R = right side at start
-    // p_end_L = left side at end
-    // p_end_R = right side at end
-    const p_start_L = startJunction?.left || {
-        x: wallStart.x + nUnit.x * halfT,
-        y: wallStart.y + nUnit.y * halfT,
-    };
-    const p_start_R = startJunction?.right || {
-        x: wallStart.x - nUnit.x * halfT,
-        y: wallStart.y - nUnit.y * halfT,
-    };
-    // At end, SWAP left/right from junction data (exactly like demo)
-    // This is because junction stores left/right relative to OUTGOING direction,
-    // which is reversed at the end of the wall
-    const p_end_L = endJunction?.right || {
-        x: wallEnd.x + nUnit.x * halfT,
-        y: wallEnd.y + nUnit.y * halfT,
-    };
-    const p_end_R = endJunction?.left || {
-        x: wallEnd.x - nUnit.x * halfT,
-        y: wallEnd.y - nUnit.y * halfT,
-    };
-    // Build polygon points (exactly like demo)
-    // Order: start-right -> end-right -> [end center] -> end-left -> start-left -> [start center]
-    const polyPoints = [p_start_R, p_end_R];
-    if (endJunction) {
-        polyPoints.push(wallEnd); // Add center vertex at junction
-    }
-    polyPoints.push(p_end_L, p_start_L);
-    if (startJunction) {
-        polyPoints.push(wallStart); // Add center vertex at junction
+    const polyPoints = getWallPlanFootprint(wallNode, miterData);
+    if (polyPoints.length < 3) {
+        return new THREE.BufferGeometry();
     }
     // Transform world coordinates to wall-local coordinates
     // Wall-local: x along wall, z perpendicular (thickness direction)
@@ -247,7 +210,7 @@ function collectCutoutBrushes(wallNode, childrenNodes, wallThickness) {
     wallMesh.updateMatrixWorld();
     const wallMatrixInverse = wallMesh.matrixWorld.clone().invert();
     for (const child of childrenNodes) {
-        if (child.type !== 'item' && child.type !== 'window')
+        if (child.type !== 'item' && child.type !== 'window' && child.type !== 'door')
             continue;
         const childMesh = sceneRegistry.nodes.get(child.id);
         if (!childMesh)
@@ -262,8 +225,8 @@ function collectCutoutBrushes(wallNode, childrenNodes, wallThickness) {
             continue;
         // Calculate bounds in wall-local space
         const v3 = new THREE.Vector3();
-        let minX = Infinity, maxX = -Infinity;
-        let minY = Infinity, maxY = -Infinity;
+        let minX = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
         for (let i = 0; i < positions.count; i++) {
             v3.fromBufferAttribute(positions, i);
             v3.applyMatrix4(cutoutMesh.matrixWorld);

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

@@ -42,7 +42,7 @@ export const WindowSystem = () => {
                 useScene.getState().dirtyNodes.add(node.parentId);
             }
         });
-    });
+    }, 3);
     return null;
 };
 function addBox(parent, material, w, h, d, x, y, z) {
@@ -83,8 +83,8 @@ function updateWindowMesh(node, mesh) {
     const usableH = innerH - (numRows - 1) * rowDividerThickness;
     const colSum = columnRatios.reduce((a, b) => a + b, 0);
     const rowSum = rowRatios.reduce((a, b) => a + b, 0);
-    const colWidths = columnRatios.map(r => (r / colSum) * usableW);
-    const rowHeights = rowRatios.map(r => (r / rowSum) * usableH);
+    const colWidths = columnRatios.map((r) => (r / colSum) * usableW);
+    const rowHeights = rowRatios.map((r) => (r / rowSum) * usableH);
     // Compute column x-centers starting from left edge of inner area
     const colXCenters = [];
     let cx = -innerW / 2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "0.1.13",
+  "version": "0.3.0",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,24 +25,24 @@
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
-    "three": "^0.182"
+    "three": "^0.183"
   },
   "dependencies": {
     "dedent": "^1.7.1",
     "idb-keyval": "^6.2.2",
     "mitt": "^3.0.1",
     "nanoid": "^5.1.6",
-    "three-bvh-csg": "^0.0.17",
+    "three-bvh-csg": "^0.0.18",
     "three-mesh-bvh": "^0.9.8",
     "zod": "^4.3.5",
     "zundo": "^2.3.0",
     "zustand": "^5"
   },
   "devDependencies": {
-    "@repo/typescript-config": "*",
+    "@pascal/typescript-config": "*",
     "@types/react": "^19.2.2",
-    "typescript": "5.9.2",
-    "@types/three": "^0.182.0"
+    "typescript": "5.9.3",
+    "@types/three": "^0.183.0"
   },
   "keywords": [
     "3d",