@pascal-app/core 0.5.1 → 0.6.0

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

@@ -1,13 +1,19 @@
 import { useFrame } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
 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';
+import { syncAutoStairOpenings } from './stair-opening-sync';
 const pendingStairUpdates = new Set();
 const MAX_STAIRS_PER_FRAME = 2;
 const MAX_SEGMENTS_PER_FRAME = 4;
+const STAIR_TREAD_MATERIAL_INDEX = 0;
+const STAIR_SIDE_MATERIAL_INDEX = 1;
+const _uvPosition = new THREE.Vector3();
+const _uvNormal = new THREE.Vector3();
 // ============================================================================
 // STAIR SYSTEM
 // ============================================================================
@@ -15,6 +21,26 @@ export const StairSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
     const rootNodeIds = useScene((state) => state.rootNodeIds);
+    const syncingAutoOpeningsRef = useRef(false);
+    useEffect(() => {
+        const applyUpdates = (updates) => {
+            if (updates.length === 0)
+                return;
+            syncingAutoOpeningsRef.current = true;
+            useScene.getState().updateNodes(updates);
+            queueMicrotask(() => {
+                syncingAutoOpeningsRef.current = false;
+            });
+        };
+        applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
+        return useScene.subscribe((state, prevState) => {
+            if (syncingAutoOpeningsRef.current)
+                return;
+            if (state.nodes === prevState.nodes)
+                return;
+            applyUpdates(syncAutoStairOpenings(state.nodes));
+        });
+    }, []);
     useFrame(() => {
         if (rootNodeIds.length === 0) {
             pendingStairUpdates.clear();
@@ -159,7 +185,7 @@ function generateStairSegmentGeometry(segment, absoluteHeight) {
         }
     }
     shape.lineTo(0, 0);
-    const geometry = new THREE.ExtrudeGeometry(shape, {
+    const extrudedGeometry = new THREE.ExtrudeGeometry(shape, {
         steps: 1,
         depth: width,
         bevelEnabled: false,
@@ -169,13 +195,21 @@ function generateStairSegmentGeometry(segment, absoluteHeight) {
     const matrix = new THREE.Matrix4();
     matrix.makeRotationY(-Math.PI / 2);
     matrix.setPosition(width / 2, 0, 0);
-    geometry.applyMatrix4(matrix);
+    extrudedGeometry.applyMatrix4(matrix);
+    extrudedGeometry.computeVertexNormals();
+    const geometry = extrudedGeometry.toNonIndexed() ?? extrudedGeometry;
+    if (geometry !== extrudedGeometry) {
+        extrudedGeometry.dispose();
+    }
+    applyStairSegmentUvs(geometry);
+    ensureUv2Attribute(geometry);
     return geometry;
 }
 function updateStairSegmentGeometry(node, mesh) {
     // Compute absolute height from parent chain
     const absoluteHeight = computeAbsoluteHeight(node);
     const newGeometry = generateStairSegmentGeometry(node, absoluteHeight);
+    applyStraightStairMaterialGroups(newGeometry);
     mesh.geometry.dispose();
     mesh.geometry = newGeometry;
     // NOTE: position/rotation are NOT set here — they're set by syncSegmentMeshTransforms
@@ -274,12 +308,93 @@ function updateMergedStairGeometry(stairNode, group, nodes) {
         geometries.push(geo);
     }
     const merged = mergeGeometries(geometries, false) ?? createEmptyGeometry();
+    applyStraightStairMaterialGroups(merged);
     replaceMeshGeometry(mergedMesh, merged);
     // Dispose individual geometries
     for (const geo of geometries) {
         geo.dispose();
     }
 }
+function applyStraightStairMaterialGroups(geometry) {
+    const position = geometry.getAttribute('position');
+    if (!position || position.count < 3) {
+        geometry.clearGroups();
+        return;
+    }
+    const index = geometry.getIndex();
+    const triangleCount = index ? index.count / 3 : position.count / 3;
+    if (!Number.isFinite(triangleCount) || triangleCount <= 0) {
+        geometry.clearGroups();
+        return;
+    }
+    const triangleMaterials = new Array(triangleCount);
+    const v0 = new THREE.Vector3();
+    const v1 = new THREE.Vector3();
+    const v2 = new THREE.Vector3();
+    const edge1 = new THREE.Vector3();
+    const edge2 = new THREE.Vector3();
+    const normal = new THREE.Vector3();
+    for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex++) {
+        const vertexOffset = triangleIndex * 3;
+        const a = index ? index.getX(vertexOffset) : vertexOffset;
+        const b = index ? index.getX(vertexOffset + 1) : vertexOffset + 1;
+        const c = index ? index.getX(vertexOffset + 2) : vertexOffset + 2;
+        v0.fromBufferAttribute(position, a);
+        v1.fromBufferAttribute(position, b);
+        v2.fromBufferAttribute(position, c);
+        edge1.subVectors(v1, v0);
+        edge2.subVectors(v2, v0);
+        normal.crossVectors(edge1, edge2);
+        triangleMaterials[triangleIndex] =
+            normal.lengthSq() > 0 && normal.normalize().y > 0.75
+                ? STAIR_TREAD_MATERIAL_INDEX
+                : STAIR_SIDE_MATERIAL_INDEX;
+    }
+    geometry.clearGroups();
+    let currentMaterial = triangleMaterials[0];
+    let groupStart = 0;
+    for (let triangleIndex = 1; triangleIndex < triangleMaterials.length; triangleIndex++) {
+        const materialIndex = triangleMaterials[triangleIndex];
+        if (materialIndex === currentMaterial)
+            continue;
+        geometry.addGroup(groupStart * 3, (triangleIndex - groupStart) * 3, currentMaterial);
+        groupStart = triangleIndex;
+        currentMaterial = materialIndex;
+    }
+    geometry.addGroup(groupStart * 3, (triangleMaterials.length - groupStart) * 3, currentMaterial ?? STAIR_SIDE_MATERIAL_INDEX);
+}
+function applyStairSegmentUvs(geometry) {
+    const position = geometry.getAttribute('position');
+    const normal = geometry.getAttribute('normal');
+    if (!position || !normal || position.count === 0) {
+        geometry.deleteAttribute('uv');
+        return;
+    }
+    const uv = [];
+    for (let index = 0; index < position.count; index++) {
+        _uvPosition.fromBufferAttribute(position, index);
+        _uvNormal.fromBufferAttribute(normal, index).normalize();
+        const absX = Math.abs(_uvNormal.x);
+        const absY = Math.abs(_uvNormal.y);
+        const absZ = Math.abs(_uvNormal.z);
+        if (absY >= absX && absY >= absZ) {
+            uv.push(_uvPosition.x, _uvPosition.z);
+        }
+        else if (absX >= absZ) {
+            uv.push(_uvPosition.z, _uvPosition.y);
+        }
+        else {
+            uv.push(_uvPosition.x, _uvPosition.y);
+        }
+    }
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+}
+function ensureUv2Attribute(geometry) {
+    const uv = geometry.getAttribute('uv');
+    if (!uv)
+        return;
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
+}
 /**
  * Computes world-relative transforms for each segment by chaining
  * based on attachmentSide. This mirrors the prototype's StairSystem logic.
@@ -334,6 +449,8 @@ function rotateXZ(x, z, angle) {
 function createEmptyGeometry() {
     const geometry = new THREE.BufferGeometry();
     geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+    geometry.addGroup(0, 0, STAIR_TREAD_MATERIAL_INDEX);
+    geometry.addGroup(0, 0, STAIR_SIDE_MATERIAL_INDEX);
     return geometry;
 }
 function replaceMeshGeometry(mesh, geometry) {

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

@@ -0,0 +1,43 @@
+import type { Point2D } from './wall-mitering';
+import type { FenceNode, WallNode } from '../../schema';
+type WallCurveLike = Pick<WallNode | FenceNode, 'start' | 'end' | 'curveOffset'>;
+type CurveFrame = {
+    point: Point2D;
+    tangent: Point2D;
+    normal: Point2D;
+};
+type WallSurfaceMiterOverrides = {
+    startLeft?: Point2D;
+    startRight?: Point2D;
+    endLeft?: Point2D;
+    endRight?: Point2D;
+};
+export declare function getWallStartPoint(wall: WallCurveLike): Point2D;
+export declare function getWallEndPoint(wall: WallCurveLike): Point2D;
+export declare function getWallChordLength(wall: WallCurveLike): number;
+export declare function getMaxWallCurveOffset(wall: WallCurveLike): number;
+export declare function getWallStraightSnapOffset(wall: WallCurveLike): number;
+export declare function normalizeWallCurveOffset(wall: WallCurveLike, offset: number): number;
+export declare function getClampedWallCurveOffset(wall: WallCurveLike): number;
+export declare function isCurvedWall(wall: WallCurveLike): boolean;
+export declare function getWallChordFrame(wall: WallCurveLike): {
+    start: Point2D;
+    end: Point2D;
+    midpoint: Point2D;
+    tangent: {
+        x: number;
+        y: number;
+    };
+    normal: {
+        x: number;
+        y: number;
+    };
+    length: number;
+};
+export declare function getWallCurveFrameAt(wall: WallCurveLike, t: number): CurveFrame;
+export declare function getWallMidpointHandlePoint(wall: WallCurveLike): Point2D;
+export declare function sampleWallCenterline(wall: WallCurveLike, segments?: number): Point2D[];
+export declare function getWallCurveLength(wall: WallCurveLike, segments?: number): number;
+export declare function getWallSurfacePolygon(wall: Pick<WallNode | FenceNode, 'start' | 'end' | 'curveOffset' | 'thickness'>, segments?: number, miterOverrides?: WallSurfaceMiterOverrides): Point2D[];
+export {};
+//# sourceMappingURL=wall-curve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-curve.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAKvD,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAC,CAAA;AAEhF,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAcD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE9D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,UAErD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,UAExD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAE5D;AAWD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,UAG3E;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAI5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,WAE/C;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa;;;;;;;;;;;;;EA6BpD;AA+BD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAwC9E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,aAAa,WAE7D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,aAG3F;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,UASzF;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,GAAG,WAAW,CAAC,EAC/E,QAAQ,SAA0B,EAClC,cAAc,CAAC,EAAE,yBAAyB,aA2B3C"}

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

@@ -0,0 +1,176 @@
+const CURVE_EPSILON = 1e-6;
+const DEFAULT_SAMPLE_SEGMENTS = 24;
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function distance(a, b) {
+    return Math.hypot(b.x - a.x, b.y - a.y);
+}
+export function getWallStartPoint(wall) {
+    return { x: wall.start[0], y: wall.start[1] };
+}
+export function getWallEndPoint(wall) {
+    return { x: wall.end[0], y: wall.end[1] };
+}
+export function getWallChordLength(wall) {
+    return distance(getWallStartPoint(wall), getWallEndPoint(wall));
+}
+export function getMaxWallCurveOffset(wall) {
+    return getWallChordLength(wall) / 2;
+}
+export function getWallStraightSnapOffset(wall) {
+    return Math.min(0.03, Math.max(0.005, getWallChordLength(wall) * 0.005));
+}
+function clampCurveOffset(wall, offset) {
+    const maxOffset = getMaxWallCurveOffset(wall);
+    if (!Number.isFinite(maxOffset) || maxOffset < CURVE_EPSILON) {
+        return 0;
+    }
+    return Math.max(-maxOffset, Math.min(maxOffset, offset));
+}
+export function normalizeWallCurveOffset(wall, offset) {
+    const clamped = clampCurveOffset(wall, offset);
+    return Math.abs(clamped) <= getWallStraightSnapOffset(wall) ? 0 : clamped;
+}
+export function getClampedWallCurveOffset(wall) {
+    const value = wall.curveOffset ?? 0;
+    const normalized = normalizeWallCurveOffset(wall, value);
+    return Math.abs(normalized) > CURVE_EPSILON ? normalized : 0;
+}
+export function isCurvedWall(wall) {
+    return Math.abs(getClampedWallCurveOffset(wall)) > CURVE_EPSILON;
+}
+export function getWallChordFrame(wall) {
+    const start = getWallStartPoint(wall);
+    const end = getWallEndPoint(wall);
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const length = Math.hypot(dx, dy);
+    if (length < CURVE_EPSILON) {
+        return {
+            start,
+            end,
+            midpoint: start,
+            tangent: { x: 1, y: 0 },
+            normal: { x: 0, y: 1 },
+            length: 0,
+        };
+    }
+    return {
+        start,
+        end,
+        midpoint: {
+            x: (start.x + end.x) / 2,
+            y: (start.y + end.y) / 2,
+        },
+        tangent: { x: dx / length, y: dy / length },
+        normal: { x: -dy / length, y: dx / length },
+        length,
+    };
+}
+function getWallArcData(wall) {
+    const chord = getWallChordFrame(wall);
+    const sagitta = getClampedWallCurveOffset(wall);
+    if (Math.abs(sagitta) <= CURVE_EPSILON || chord.length < CURVE_EPSILON) {
+        return null;
+    }
+    const absSagitta = Math.abs(sagitta);
+    const radius = chord.length * chord.length / (8 * absSagitta) + absSagitta / 2;
+    const centerOffset = radius - absSagitta;
+    const direction = Math.sign(sagitta) || 1;
+    const center = {
+        x: chord.midpoint.x + chord.normal.x * centerOffset * direction,
+        y: chord.midpoint.y + chord.normal.y * centerOffset * direction,
+    };
+    const startAngle = Math.atan2(chord.start.y - center.y, chord.start.x - center.x);
+    const endAngle = Math.atan2(chord.end.y - center.y, chord.end.x - center.x);
+    let delta = endAngle - startAngle;
+    if (direction > 0) {
+        while (delta <= 0)
+            delta += Math.PI * 2;
+    }
+    else {
+        while (delta >= 0)
+            delta -= Math.PI * 2;
+    }
+    return { center, radius, startAngle, delta, direction };
+}
+export function getWallCurveFrameAt(wall, t) {
+    const chord = getWallChordFrame(wall);
+    if (!isCurvedWall(wall) || chord.length < CURVE_EPSILON) {
+        return {
+            point: {
+                x: lerp(chord.start.x, chord.end.x, clamp01(t)),
+                y: lerp(chord.start.y, chord.end.y, clamp01(t)),
+            },
+            tangent: chord.tangent,
+            normal: chord.normal,
+        };
+    }
+    const arc = getWallArcData(wall);
+    if (!arc) {
+        return {
+            point: chord.midpoint,
+            tangent: chord.tangent,
+            normal: chord.normal,
+        };
+    }
+    const angle = arc.startAngle + arc.delta * clamp01(t);
+    const point = {
+        x: arc.center.x + Math.cos(angle) * arc.radius,
+        y: arc.center.y + Math.sin(angle) * arc.radius,
+    };
+    const tangent = arc.direction > 0
+        ? { x: -Math.sin(angle), y: Math.cos(angle) }
+        : { x: Math.sin(angle), y: -Math.cos(angle) };
+    return {
+        point,
+        tangent,
+        normal: {
+            x: -tangent.y,
+            y: tangent.x,
+        },
+    };
+}
+export function getWallMidpointHandlePoint(wall) {
+    return getWallCurveFrameAt(wall, 0.5).point;
+}
+export function sampleWallCenterline(wall, segments = DEFAULT_SAMPLE_SEGMENTS) {
+    const count = Math.max(1, segments);
+    return Array.from({ length: count + 1 }, (_, index) => getWallCurveFrameAt(wall, index / count).point);
+}
+export function getWallCurveLength(wall, segments = DEFAULT_SAMPLE_SEGMENTS) {
+    const points = sampleWallCenterline(wall, segments);
+    let totalLength = 0;
+    for (let index = 1; index < points.length; index += 1) {
+        totalLength += distance(points[index - 1], points[index]);
+    }
+    return totalLength;
+}
+export function getWallSurfacePolygon(wall, segments = DEFAULT_SAMPLE_SEGMENTS, miterOverrides) {
+    const halfThickness = (wall.thickness ?? 0.1) / 2;
+    const count = Math.max(1, segments);
+    const left = [];
+    const right = [];
+    for (let index = 0; index <= count; index += 1) {
+        const frame = getWallCurveFrameAt(wall, index / count);
+        left.push({
+            x: frame.point.x + frame.normal.x * halfThickness,
+            y: frame.point.y + frame.normal.y * halfThickness,
+        });
+        right.push({
+            x: frame.point.x - frame.normal.x * halfThickness,
+            y: frame.point.y - frame.normal.y * halfThickness,
+        });
+    }
+    if (left.length > 0 && right.length > 0) {
+        left[0] = miterOverrides?.startLeft ?? left[0];
+        right[0] = miterOverrides?.startRight ?? right[0];
+        left[left.length - 1] = miterOverrides?.endLeft ?? left[left.length - 1];
+        right[right.length - 1] = miterOverrides?.endRight ?? right[right.length - 1];
+    }
+    return [...right, ...left.reverse()];
+}

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

@@ -1 +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"}
+{"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;AAE5C,OAAO,EAEL,KAAK,OAAO,EAEZ,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAExB,eAAO,MAAM,sBAAsB,MAAM,CAAA;AACzC,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAGtC,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE3D;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,EAAE,CA6D5F"}

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

@@ -1,6 +1,8 @@
-import { pointToKey } from './wall-mitering';
+import { getWallSurfacePolygon, isCurvedWall } from './wall-curve';
+import { getWallMiterBoundaryPoints, pointToKey, } from './wall-mitering';
 export const DEFAULT_WALL_THICKNESS = 0.1;
 export const DEFAULT_WALL_HEIGHT = 2.5;
+const CURVED_WALL_SURFACE_SEGMENTS = 24;
 export function getWallThickness(wallNode) {
     return wallNode.thickness ?? DEFAULT_WALL_THICKNESS;
 }
@@ -20,6 +22,19 @@ export function getWallPlanFootprint(wallNode, miterData) {
     const keyEnd = pointToKey(wallEnd);
     const startJunction = junctionData.get(keyStart)?.get(wallNode.id);
     const endJunction = junctionData.get(keyEnd)?.get(wallNode.id);
+    if (isCurvedWall(wallNode)) {
+        const boundaryPoints = getWallMiterBoundaryPoints(wallNode, miterData);
+        if (!boundaryPoints) {
+            return [];
+        }
+        const { startLeft, startRight, endLeft, endRight } = boundaryPoints;
+        return getWallSurfacePolygon(wallNode, CURVED_WALL_SURFACE_SEGMENTS, {
+            endLeft,
+            endRight,
+            startLeft,
+            startRight,
+        });
+    }
     const pStartLeft = startJunction?.left || {
         x: wallStart.x + nUnit.x * halfT,
         y: wallStart.y + nUnit.y * halfT,
@@ -28,7 +43,6 @@ export function getWallPlanFootprint(wallNode, miterData) {
         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,

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

@@ -3,6 +3,12 @@ export interface Point2D {
     x: number;
     y: number;
 }
+export interface WallMiterBoundaryPoints {
+    startLeft: Point2D;
+    startRight: Point2D;
+    endLeft: Point2D;
+    endRight: Point2D;
+}
 type WallIntersections = Map<string, {
     left?: Point2D;
     right?: Point2D;
@@ -24,6 +30,7 @@ export interface WallMiterData {
  * Calculates miter data for all walls on a level
  */
 export declare function calculateLevelMiters(walls: WallNode[]): WallMiterData;
+export declare function getWallMiterBoundaryPoints(wall: WallNode, miterData: WallMiterData): WallMiterBoundaryPoints | null;
 /**
  * Gets wall IDs that share junctions with the given walls
  */

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

@@ -1 +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"}
+{"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;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;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;AA+ND,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,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;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

@@ -1,3 +1,4 @@
+import { getWallCurveFrameAt, isCurvedWall } from './wall-curve';
 // ============================================================================
 // UTILITY FUNCTIONS
 // ============================================================================
@@ -79,6 +80,54 @@ function findJunctions(walls) {
     }
     return actualJunctions;
 }
+function getWallDirectionFromJunction(wall, endType) {
+    if (endType === 'passthrough') {
+        return {
+            x: wall.end[0] - wall.start[0],
+            y: wall.end[1] - wall.start[1],
+        };
+    }
+    if (isCurvedWall(wall)) {
+        const frame = getWallCurveFrameAt(wall, endType === 'start' ? 0 : 1);
+        return endType === 'start'
+            ? frame.tangent
+            : { x: -frame.tangent.x, y: -frame.tangent.y };
+    }
+    return 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] };
+}
+function getWallBoundaryFrame(wall, endType) {
+    if (isCurvedWall(wall)) {
+        const frame = getWallCurveFrameAt(wall, endType === 'start' ? 0 : 1);
+        return {
+            point: frame.point,
+            tangent: endType === 'start'
+                ? frame.tangent
+                : { x: -frame.tangent.x, y: -frame.tangent.y },
+            normal: frame.normal,
+        };
+    }
+    const point = endType === 'start'
+        ? { x: wall.start[0], y: wall.start[1] }
+        : { x: wall.end[0], y: wall.end[1] };
+    const vector = 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 length = Math.hypot(vector.x, vector.y);
+    if (length < 1e-9) {
+        return {
+            point,
+            tangent: { x: 1, y: 0 },
+            normal: { x: 0, y: 1 },
+        };
+    }
+    return {
+        point,
+        tangent: { x: vector.x / length, y: vector.y / length },
+        normal: { x: -vector.y / length, y: vector.x / length },
+    };
+}
 function calculateJunctionIntersections(junction, getThickness) {
     const { meetingPoint, connectedWalls } = junction;
     const processedWalls = [];
@@ -104,9 +153,7 @@ function calculateJunctionIntersections(junction, getThickness) {
         }
         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 v = getWallDirectionFromJunction(wall, endType);
             const L = Math.sqrt(v.x * v.x + v.y * v.y);
             if (L < 1e-9)
                 continue;
@@ -169,6 +216,32 @@ export function calculateLevelMiters(walls) {
     }
     return { junctionData, junctions };
 }
+export function getWallMiterBoundaryPoints(wall, miterData) {
+    const thickness = wall.thickness ?? 0.1;
+    const halfThickness = thickness / 2;
+    const startFrame = getWallBoundaryFrame(wall, 'start');
+    const endFrame = getWallBoundaryFrame(wall, 'end');
+    const startJunction = miterData.junctionData.get(pointToKey(startFrame.point))?.get(wall.id);
+    const endJunction = miterData.junctionData.get(pointToKey(endFrame.point))?.get(wall.id);
+    return {
+        startLeft: startJunction?.left ?? {
+            x: startFrame.point.x + startFrame.normal.x * halfThickness,
+            y: startFrame.point.y + startFrame.normal.y * halfThickness,
+        },
+        startRight: startJunction?.right ?? {
+            x: startFrame.point.x - startFrame.normal.x * halfThickness,
+            y: startFrame.point.y - startFrame.normal.y * halfThickness,
+        },
+        endLeft: endJunction?.right ?? {
+            x: endFrame.point.x + endFrame.normal.x * halfThickness,
+            y: endFrame.point.y + endFrame.normal.y * halfThickness,
+        },
+        endRight: endJunction?.left ?? {
+            x: endFrame.point.x - endFrame.normal.x * halfThickness,
+            y: endFrame.point.y - endFrame.normal.y * halfThickness,
+        },
+    };
+}
 /**
  * Gets wall IDs that share junctions with the given walls
  */

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;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"}
+{"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;AAIhE,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAsRxB,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,oFA2GlB"}