@pascal-app/core 0.1.3

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

@@ -0,0 +1,32 @@
+import type { WallNode } from '../../schema';
+export interface Point2D {
+    x: number;
+    y: number;
+}
+type WallIntersections = Map<string, {
+    left?: Point2D;
+    right?: Point2D;
+}>;
+type JunctionData = Map<string, WallIntersections>;
+declare function pointToKey(p: Point2D, tolerance?: number): string;
+interface Junction {
+    meetingPoint: Point2D;
+    connectedWalls: Array<{
+        wall: WallNode;
+        endType: 'start' | 'end' | 'passthrough';
+    }>;
+}
+export interface WallMiterData {
+    junctionData: JunctionData;
+    junctions: Map<string, Junction>;
+}
+/**
+ * Calculates miter data for all walls on a level
+ */
+export declare function calculateLevelMiters(walls: WallNode[]): WallMiterData;
+/**
+ * Gets wall IDs that share junctions with the given walls
+ */
+export declare function getAdjacentWallIds(allWalls: WallNode[], dirtyWallIds: Set<string>): Set<string>;
+export { pointToKey };
+//# sourceMappingURL=wall-mitering.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAM5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAQlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAkKD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}

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

@@ -0,0 +1,214 @@
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+const TOLERANCE = 0.001;
+function pointToKey(p, tolerance = TOLERANCE) {
+    const snap = 1 / tolerance;
+    return `${Math.round(p.x * snap)},${Math.round(p.y * snap)}`;
+}
+function createLineFromPointAndVector(p, v) {
+    const a = -v.y;
+    const b = v.x;
+    const c = -(a * p.x + b * p.y);
+    return { a, b, c };
+}
+/**
+ * Checks if a point lies on a wall segment (not at its endpoints)
+ */
+function pointOnWallSegment(point, wall, tolerance = TOLERANCE) {
+    const start = { x: wall.start[0], y: wall.start[1] };
+    const end = { x: wall.end[0], y: wall.end[1] };
+    // Check if point is at endpoints (those are handled separately)
+    if (pointToKey(point, tolerance) === pointToKey(start, tolerance))
+        return false;
+    if (pointToKey(point, tolerance) === pointToKey(end, tolerance))
+        return false;
+    // Vector from start to end
+    const v = { x: end.x - start.x, y: end.y - start.y };
+    const L = Math.sqrt(v.x * v.x + v.y * v.y);
+    if (L < 1e-9)
+        return false;
+    // Vector from start to point
+    const w = { x: point.x - start.x, y: point.y - start.y };
+    // Project point onto wall line (t is parametric position along segment)
+    const t = (v.x * w.x + v.y * w.y) / (L * L);
+    // Check if projection is within segment (not at endpoints)
+    if (t < tolerance || t > 1 - tolerance)
+        return false;
+    // Check distance from point to line
+    const projX = start.x + t * v.x;
+    const projY = start.y + t * v.y;
+    const dist = Math.sqrt((point.x - projX) ** 2 + (point.y - projY) ** 2);
+    return dist < tolerance;
+}
+function findJunctions(walls) {
+    const junctions = new Map();
+    // First pass: group walls by their endpoints
+    for (const wall of walls) {
+        const startPt = { x: wall.start[0], y: wall.start[1] };
+        const endPt = { x: wall.end[0], y: wall.end[1] };
+        const keyStart = pointToKey(startPt);
+        const keyEnd = pointToKey(endPt);
+        if (!junctions.has(keyStart)) {
+            junctions.set(keyStart, { meetingPoint: startPt, connectedWalls: [] });
+        }
+        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' });
+    }
+    // Second pass: detect T-junctions (walls passing through junction points)
+    for (const [_key, junction] of junctions.entries()) {
+        for (const wall of walls) {
+            // Skip if wall already in this junction
+            if (junction.connectedWalls.some((cw) => cw.wall.id === wall.id))
+                continue;
+            // Check if junction point lies on this wall's segment (not at endpoints)
+            if (pointOnWallSegment(junction.meetingPoint, wall)) {
+                junction.connectedWalls.push({ wall, endType: 'passthrough' });
+            }
+        }
+    }
+    // Filter to only junctions with 2+ walls
+    const actualJunctions = new Map();
+    for (const [key, junction] of junctions.entries()) {
+        if (junction.connectedWalls.length >= 2) {
+            actualJunctions.set(key, junction);
+        }
+    }
+    return actualJunctions;
+}
+function calculateJunctionIntersections(junction, getThickness) {
+    const { meetingPoint, connectedWalls } = junction;
+    const processedWalls = [];
+    for (const { wall, endType } of connectedWalls) {
+        const halfT = getThickness(wall) / 2;
+        if (endType === 'passthrough') {
+            // For passthrough walls (T-junctions), add both directions
+            // This allows walls meeting the middle of this wall to miter against it
+            const v1 = { x: wall.end[0] - wall.start[0], y: wall.end[1] - wall.start[1] };
+            const v2 = { x: -v1.x, y: -v1.y };
+            for (const v of [v1, v2]) {
+                const L = Math.sqrt(v.x * v.x + v.y * v.y);
+                if (L < 1e-9)
+                    continue;
+                const nUnit = { x: -v.y / L, y: v.x / L };
+                const pA = { x: meetingPoint.x + nUnit.x * halfT, y: meetingPoint.y + nUnit.y * halfT };
+                const pB = { x: meetingPoint.x - nUnit.x * halfT, y: meetingPoint.y - nUnit.y * halfT };
+                const edgeA = createLineFromPointAndVector(pA, v);
+                const edgeB = createLineFromPointAndVector(pB, v);
+                const angle = Math.atan2(v.y, v.x);
+                processedWalls.push({ wallId: wall.id, angle, edgeA, edgeB, isPassthrough: true });
+            }
+        }
+        else {
+            // Normal wall endpoint (start or end)
+            const v = endType === 'start'
+                ? { x: wall.end[0] - wall.start[0], y: wall.end[1] - wall.start[1] }
+                : { x: wall.start[0] - wall.end[0], y: wall.start[1] - wall.end[1] };
+            const L = Math.sqrt(v.x * v.x + v.y * v.y);
+            if (L < 1e-9)
+                continue;
+            const nUnit = { x: -v.y / L, y: v.x / L };
+            const pA = { x: meetingPoint.x + nUnit.x * halfT, y: meetingPoint.y + nUnit.y * halfT };
+            const pB = { x: meetingPoint.x - nUnit.x * halfT, y: meetingPoint.y - nUnit.y * halfT };
+            const edgeA = createLineFromPointAndVector(pA, v);
+            const edgeB = createLineFromPointAndVector(pB, v);
+            const angle = Math.atan2(v.y, v.x);
+            processedWalls.push({ wallId: wall.id, angle, edgeA, edgeB, isPassthrough: false });
+        }
+    }
+    // Sort by outgoing angle
+    processedWalls.sort((a, b) => a.angle - b.angle);
+    const wallIntersections = new Map();
+    const n = processedWalls.length;
+    if (n < 2)
+        return wallIntersections;
+    // Calculate intersections between adjacent walls (exactly like demo)
+    for (let i = 0; i < n; i++) {
+        const wall1 = processedWalls[i];
+        const wall2 = processedWalls[(i + 1) % n];
+        // Intersect left edge of wall1 with right edge of wall2
+        const det = wall1.edgeA.a * wall2.edgeB.b - wall2.edgeB.a * wall1.edgeA.b;
+        // If lines are parallel (det ≈ 0), skip this intersection - walls will use defaults
+        if (Math.abs(det) < 1e-9) {
+            continue;
+        }
+        const p = {
+            x: (wall1.edgeA.b * wall2.edgeB.c - wall2.edgeB.b * wall1.edgeA.c) / det,
+            y: (wall2.edgeB.a * wall1.edgeA.c - wall1.edgeA.a * wall2.edgeB.c) / det,
+        };
+        // Only assign intersection to non-passthrough walls
+        // Passthrough walls don't receive junction data (their geometry doesn't change)
+        if (!wall1.isPassthrough) {
+            if (!wallIntersections.has(wall1.wallId)) {
+                wallIntersections.set(wall1.wallId, {});
+            }
+            wallIntersections.get(wall1.wallId).left = p;
+        }
+        if (!wall2.isPassthrough) {
+            if (!wallIntersections.has(wall2.wallId)) {
+                wallIntersections.set(wall2.wallId, {});
+            }
+            wallIntersections.get(wall2.wallId).right = p;
+        }
+    }
+    return wallIntersections;
+}
+/**
+ * Calculates miter data for all walls on a level
+ */
+export function calculateLevelMiters(walls) {
+    const getThickness = (wall) => wall.thickness ?? 0.1;
+    const junctions = findJunctions(walls);
+    const junctionData = new Map();
+    for (const [key, junction] of junctions.entries()) {
+        const wallIntersections = calculateJunctionIntersections(junction, getThickness);
+        junctionData.set(key, wallIntersections);
+    }
+    return { junctionData, junctions };
+}
+/**
+ * Gets wall IDs that share junctions with the given walls
+ */
+export function getAdjacentWallIds(allWalls, dirtyWallIds) {
+    const adjacent = new Set();
+    for (const dirtyId of dirtyWallIds) {
+        const dirtyWall = allWalls.find((w) => w.id === dirtyId);
+        if (!dirtyWall)
+            continue;
+        const dirtyStart = { x: dirtyWall.start[0], y: dirtyWall.start[1] };
+        const dirtyEnd = { x: dirtyWall.end[0], y: dirtyWall.end[1] };
+        for (const wall of allWalls) {
+            if (wall.id === dirtyId)
+                continue;
+            const wallStart = { x: wall.start[0], y: wall.start[1] };
+            const wallEnd = { x: wall.end[0], y: wall.end[1] };
+            // Check corner connections (endpoints meeting)
+            const startKey = pointToKey(wallStart);
+            const endKey = pointToKey(wallEnd);
+            const dirtyStartKey = pointToKey(dirtyStart);
+            const dirtyEndKey = pointToKey(dirtyEnd);
+            if (startKey === dirtyStartKey ||
+                startKey === dirtyEndKey ||
+                endKey === dirtyStartKey ||
+                endKey === dirtyEndKey) {
+                adjacent.add(wall.id);
+                continue;
+            }
+            // Check T-junction connections (dirty wall endpoint on other wall's segment)
+            if (pointOnWallSegment(dirtyStart, wall) || pointOnWallSegment(dirtyEnd, wall)) {
+                adjacent.add(wall.id);
+                continue;
+            }
+            // Check reverse T-junction (other wall endpoint on dirty wall's segment)
+            if (pointOnWallSegment(wallStart, dirtyWall) || pointOnWallSegment(wallEnd, dirtyWall)) {
+                adjacent.add(wall.id);
+            }
+        }
+    }
+    return adjacent;
+}
+// Re-export for backwards compatibility
+export { pointToKey };

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

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+import type { AnyNode, WallNode } from '../../schema';
+import { type WallMiterData } from './wall-mitering';
+export declare const WallSystem: () => null;
+/**
+ * Generates extruded wall geometry with mitering and cutouts
+ *
+ * Key insight from demo: polygon is built in WORLD coordinates first,
+ * then we transform to wall-local for the 3D mesh.
+ */
+export declare function generateExtrudedWall(wallNode: WallNode, childrenNodes: AnyNode[], miterData: WallMiterData, slabElevation?: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+//# sourceMappingURL=wall-system.d.ts.map

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

@@ -0,0 +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;AAK9B,OAAO,KAAK,EAAE,OAAO,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEhE,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AASxB,eAAO,MAAM,UAAU,YAwDtB,CAAA;AA0DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,oFA0IlB"}

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

@@ -0,0 +1,286 @@
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
+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';
+// Reusable CSG evaluator for better performance
+const csgEvaluator = new Evaluator();
+// ============================================================================
+// WALL SYSTEM
+// ============================================================================
+export const WallSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        // Collect dirty walls and their levels
+        const dirtyWallsByLevel = new Map();
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'wall')
+                return;
+            console.log('wall front/back', node.frontSide, node.backSide);
+            const levelId = node.parentId;
+            if (!levelId)
+                return;
+            if (!dirtyWallsByLevel.has(levelId)) {
+                dirtyWallsByLevel.set(levelId, new Set());
+            }
+            dirtyWallsByLevel.get(levelId).add(id);
+        });
+        // Process each level that has dirty walls
+        for (const [levelId, dirtyWallIds] of dirtyWallsByLevel) {
+            const levelWalls = getLevelWalls(levelId);
+            const miterData = calculateLevelMiters(levelWalls);
+            // Update dirty walls
+            for (const wallId of dirtyWallIds) {
+                const mesh = sceneRegistry.nodes.get(wallId);
+                if (mesh) {
+                    updateWallGeometry(wallId, miterData);
+                    clearDirty(wallId);
+                }
+                // If mesh not found, keep it dirty for next frame
+            }
+            // Update adjacent walls that share junctions
+            const adjacentWallIds = getAdjacentWallIds(levelWalls, dirtyWallIds);
+            for (const wallId of adjacentWallIds) {
+                if (!dirtyWallIds.has(wallId)) {
+                    const mesh = sceneRegistry.nodes.get(wallId);
+                    if (mesh) {
+                        updateWallGeometry(wallId, miterData);
+                    }
+                }
+            }
+        }
+    });
+    return null;
+};
+/**
+ * Gets all walls that belong to a level
+ */
+function getLevelWalls(levelId) {
+    const { nodes } = useScene.getState();
+    const level = nodes[levelId];
+    if (!level || level.type !== 'level')
+        return [];
+    const walls = [];
+    for (const childId of level.children) {
+        const child = nodes[childId];
+        if (child?.type === 'wall') {
+            walls.push(child);
+        }
+    }
+    return walls;
+}
+/**
+ * Updates the geometry for a single wall
+ */
+function updateWallGeometry(wallId, miterData) {
+    const nodes = useScene.getState().nodes;
+    const node = nodes[wallId];
+    if (!node || node.type !== 'wall')
+        return;
+    const mesh = sceneRegistry.nodes.get(wallId);
+    if (!mesh)
+        return;
+    const levelId = resolveLevelId(node, nodes);
+    const slabElevation = spatialGridManager.getSlabElevationForWall(levelId, node.start, node.end);
+    const childrenIds = node.children || [];
+    const childrenNodes = childrenIds
+        .map((childId) => nodes[childId])
+        .filter((n) => n !== undefined);
+    const newGeo = generateExtrudedWall(node, childrenNodes, miterData, slabElevation);
+    mesh.geometry.dispose();
+    mesh.geometry = newGeo;
+    // Update collision mesh
+    const collisionMesh = mesh.getObjectByName('collision-mesh');
+    if (collisionMesh) {
+        const collisionGeo = generateExtrudedWall(node, [], miterData, slabElevation);
+        collisionMesh.geometry.dispose();
+        collisionMesh.geometry = collisionGeo;
+    }
+    mesh.position.set(node.start[0], 0, node.start[1]);
+    const angle = Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]);
+    mesh.rotation.y = -angle;
+}
+/**
+ * Generates extruded wall geometry with mitering and cutouts
+ *
+ * Key insight from demo: polygon is built in WORLD coordinates first,
+ * 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] };
+    // Wall height is adjusted by slab elevation (positive reduces, negative increases)
+    const height = (wallNode.height ?? 2.5) - slabElevation;
+    const thickness = wallNode.thickness ?? 0.1;
+    const halfT = thickness / 2;
+    // 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
+    }
+    // Transform world coordinates to wall-local coordinates
+    // Wall-local: x along wall, z perpendicular (thickness direction)
+    const wallAngle = Math.atan2(v.y, v.x);
+    const cosA = Math.cos(-wallAngle);
+    const sinA = Math.sin(-wallAngle);
+    const worldToLocal = (worldPt) => {
+        const dx = worldPt.x - wallStart.x;
+        const dy = worldPt.y - wallStart.y;
+        return {
+            x: dx * cosA - dy * sinA,
+            z: dx * sinA + dy * cosA,
+        };
+    };
+    // Convert polygon to local coordinates
+    const localPoints = polyPoints.map(worldToLocal);
+    // Build THREE.js shape
+    // Shape uses (x, y) where we map: shape.x = local.x, shape.y = -local.z
+    // The negation is needed because after rotateX(-PI/2), shape.y becomes -geometry.z
+    const footprint = new THREE.Shape();
+    footprint.moveTo(localPoints[0].x, -localPoints[0].z);
+    for (let i = 1; i < localPoints.length; i++) {
+        footprint.lineTo(localPoints[i].x, -localPoints[i].z);
+    }
+    footprint.closePath();
+    // Extrude along Z by height
+    const geometry = new THREE.ExtrudeGeometry(footprint, {
+        depth: height,
+        bevelEnabled: false,
+    });
+    // Rotate so extrusion direction (Z) becomes height direction (Y)
+    geometry.rotateX(-Math.PI / 2);
+    // Translate by slab elevation (works for both positive and negative values)
+    if (slabElevation !== 0) {
+        geometry.translate(0, slabElevation, 0);
+    }
+    geometry.computeVertexNormals();
+    // Apply CSG subtraction for cutouts (doors/windows)
+    const cutoutBrushes = collectCutoutBrushes(wallNode, childrenNodes, thickness);
+    if (cutoutBrushes.length === 0) {
+        return geometry;
+    }
+    // Create wall brush from geometry
+    const wallBrush = new Brush(geometry);
+    wallBrush.updateMatrixWorld();
+    // Subtract each cutout from the wall
+    let resultBrush = wallBrush;
+    for (const cutoutBrush of cutoutBrushes) {
+        cutoutBrush.updateMatrixWorld();
+        const newResult = csgEvaluator.evaluate(resultBrush, cutoutBrush, SUBTRACTION);
+        if (resultBrush !== wallBrush) {
+            resultBrush.geometry.dispose();
+        }
+        resultBrush = newResult;
+    }
+    // Clean up
+    wallBrush.geometry.dispose();
+    for (const brush of cutoutBrushes) {
+        brush.geometry.dispose();
+    }
+    const resultGeometry = resultBrush.geometry;
+    resultGeometry.computeVertexNormals();
+    return resultGeometry;
+}
+/**
+ * Collects cutout brushes from child items for CSG subtraction
+ * The cutout mesh is a plane, so we extrude it into a box that goes through the wall
+ */
+function collectCutoutBrushes(wallNode, childrenNodes, wallThickness) {
+    const brushes = [];
+    const wallMesh = sceneRegistry.nodes.get(wallNode.id);
+    if (!wallMesh)
+        return brushes;
+    // Get wall's world matrix inverse to transform cutouts to wall-local space
+    wallMesh.updateMatrixWorld();
+    const wallMatrixInverse = wallMesh.matrixWorld.clone().invert();
+    for (const child of childrenNodes) {
+        if (child.type !== 'item')
+            continue;
+        const childMesh = sceneRegistry.nodes.get(child.id);
+        if (!childMesh)
+            continue;
+        const cutoutMesh = childMesh.getObjectByName('cutout');
+        if (!cutoutMesh)
+            continue;
+        // Get the cutout's bounding box in world space
+        cutoutMesh.updateMatrixWorld();
+        const positions = cutoutMesh.geometry?.attributes?.position;
+        if (!positions)
+            continue;
+        // Calculate bounds in wall-local space
+        const v3 = new THREE.Vector3();
+        let minX = Infinity, maxX = -Infinity;
+        let minY = Infinity, maxY = -Infinity;
+        for (let i = 0; i < positions.count; i++) {
+            v3.fromBufferAttribute(positions, i);
+            v3.applyMatrix4(cutoutMesh.matrixWorld);
+            v3.applyMatrix4(wallMatrixInverse);
+            minX = Math.min(minX, v3.x);
+            maxX = Math.max(maxX, v3.x);
+            minY = Math.min(minY, v3.y);
+            maxY = Math.max(maxY, v3.y);
+        }
+        if (!Number.isFinite(minX))
+            continue;
+        // Create a box geometry that extends through the wall thickness
+        const width = maxX - minX;
+        const height = maxY - minY;
+        const depth = wallThickness * 2; // Extend beyond wall to ensure clean cut
+        const boxGeo = new THREE.BoxGeometry(width, height, depth);
+        // Position box at the center of the cutout
+        boxGeo.translate(minX + width / 2, minY + height / 2, 0);
+        const brush = new Brush(boxGeo);
+        brushes.push(brush);
+    }
+    return brushes;
+}

package/dist/utils/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Type guard to check if a value is a plain object (and not null or an array).
+ * Useful for narrowing down Zod's generic JSON types.
+ */
+export declare const isObject: (val: unknown) => val is Record<string, any>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,OAAO,KAAG,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAEhE,CAAA"}

package/dist/utils/types.js

@@ -0,0 +1,7 @@
+/**
+ * Type guard to check if a value is a plain object (and not null or an array).
+ * Useful for narrowing down Zod's generic JSON types.
+ */
+export const isObject = (val) => {
+    return val !== null && typeof val === 'object' && !Array.isArray(val);
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@pascal-app/core",
+  "version": "0.1.3",
+  "description": "Core library for Pascal 3D building editor",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc --declaration --emitDeclarationOnly && tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@react-three/drei": "^10",
+    "@react-three/fiber": "^9",
+    "react": "^18 || ^19",
+    "three": "^0.182"
+  },
+  "dependencies": {
+    "dedent": "^1.7.1",
+    "idb-keyval": "^6.2.2",
+    "mitt": "^3.0.1",
+    "nanoid": "^5.1.6",
+    "zod": "^4.3.5",
+    "zundo": "^2.3.0",
+    "zustand": "^5"
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "*",
+    "@types/react": "^19.2.2",
+    "typescript": "5.9.2",
+    "@types/three": "^0.182.0"
+  },
+  "keywords": [
+    "3d",
+    "building",
+    "editor",
+    "architecture",
+    "webgpu",
+    "three.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/pascal-editor.git",
+    "directory": "packages/core"
+  },
+  "license": "MIT"
+}