@pascal-app/core 0.8.0 → 0.9.2

package/dist/systems/stair/stair-opening-sync.test.js

@@ -1,8 +1,8 @@
 import { describe, expect, test } from 'bun:test';
-import { BuildingNode, LevelNode, SlabNode, StairNode, StairSegmentNode } from '../../schema';
+import { BuildingNode, CeilingNode, LevelNode, SlabNode, StairNode, StairSegmentNode, } from '../../schema';
 import { syncAutoStairOpenings } from './stair-opening-sync';
 describe('syncAutoStairOpenings', () => {
-    test('only applies stair holes to destination slabs that contain the opening', () => {
+    test('only applies stair holes to destination slabs that overlap the opening', () => {
         const building = BuildingNode.parse({ name: 'Building' });
         const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
         const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
@@ -60,4 +60,426 @@ describe('syncAutoStairOpenings', () => {
         expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
         expect(bedroomUpdate).toBeUndefined();
     });
+    test('applies stair holes to a later destination slab when the configured offset overhangs the slab edge', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_edge',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_edge',
+            name: 'Edge Stair',
+            parentId: ground.id,
+            position: [2, 0, 0],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            openingOffset: 0.08,
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        const hole = landingUpdate?.data.holes?.[0];
+        expect(hole).toBeDefined();
+        expect(Math.min(...hole.map(([, z]) => z))).toBeCloseTo(-0.08);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
+    test('does not apply stair holes to slabs on another building with a matching level number', () => {
+        const buildingA = BuildingNode.parse({ name: 'Building A' });
+        const groundA = LevelNode.parse({ name: 'Ground A', level: 0, parentId: buildingA.id });
+        const upperA = LevelNode.parse({ name: 'Upper A', level: 1, parentId: buildingA.id });
+        const buildingB = BuildingNode.parse({ name: 'Building B' });
+        const upperB = LevelNode.parse({ name: 'Upper B', level: 1, parentId: buildingB.id });
+        const slabA = SlabNode.parse({
+            name: 'Upper A Slab',
+            parentId: upperA.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+        });
+        const slabB = SlabNode.parse({
+            name: 'Upper B Slab',
+            parentId: upperB.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_scoped',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_scoped',
+            name: 'Scoped Stair',
+            parentId: groundA.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: groundA.id,
+            toLevelId: upperA.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([
+            buildingA,
+            groundA,
+            upperA,
+            buildingB,
+            upperB,
+            slabA,
+            slabB,
+            stair,
+            { ...segment, parentId: stair.id },
+        ].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        expect(updates.find((update) => update.id === slabA.id)?.data.holes).toHaveLength(1);
+        expect(updates.find((update) => update.id === slabB.id)).toBeUndefined();
+    });
+    test('uses the parent level when a stair has stale from-level data', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 8],
+                [0, 8],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_stale_from',
+            width: 1,
+            length: 6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_stale_from',
+            name: 'Stale From Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: 'default',
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        const hole = landingUpdate?.data.holes?.[0];
+        expect(hole).toBeDefined();
+        expect(Math.min(...hole.map(([, z]) => z))).toBeGreaterThan(0.9);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
+    test('infers the destination level when a destination stair has blank level fields', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 8],
+                [0, 8],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_blank_levels',
+            width: 1,
+            length: 6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_blank_levels',
+            name: 'Blank Level Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: '',
+            toLevelId: '',
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        expect(landingUpdate?.data.holes).toHaveLength(1);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
+    test('infers the destination level when a destination stair targets its source level', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 8],
+                [0, 8],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_self_target',
+            width: 1,
+            length: 6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_self_target',
+            name: 'Self Target Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: ground.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        expect(landingUpdate?.data.holes).toHaveLength(1);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
+    test('does not add stair holes when a manual surface hole already covers them', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const manualOpening = [
+            [1.0, 0.0],
+            [3.0, 0.0],
+            [3.0, 3.0],
+            [1.0, 3.0],
+        ];
+        const sourceCeiling = CeilingNode.parse({
+            name: 'Source Ceiling',
+            parentId: ground.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_main',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_main',
+            name: 'Main Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([
+            building,
+            ground,
+            upper,
+            sourceCeiling,
+            landingSlab,
+            stair,
+            { ...segment, parentId: stair.id },
+        ].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        expect(updates.find((update) => update.id === landingSlab.id)).toBeUndefined();
+        expect(updates.find((update) => update.id === sourceCeiling.id)).toBeUndefined();
+    });
+    test('adds stair holes when an existing manual hole is too small', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const smallManualOpening = [
+            [1.8, 1.6],
+            [2.2, 1.6],
+            [2.2, 2.1],
+            [1.8, 2.1],
+        ];
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [smallManualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_main',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_main',
+            name: 'Main Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        expect(landingUpdate?.data.holes).toHaveLength(2);
+        expect(landingUpdate?.data.holes?.[0]).toEqual(smallManualOpening);
+        expect(landingUpdate?.data.holeMetadata).toEqual([
+            { source: 'manual' },
+            { source: 'stair', stairId: stair.id },
+        ]);
+    });
+    test('removes stale auto stair holes when a manual hole overlaps the stair opening', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const manualOpening = [
+            [1.0, 0.0],
+            [3.0, 0.0],
+            [3.0, 3.0],
+            [1.0, 3.0],
+        ];
+        const staleAutoOpening = [
+            [1.5, 1],
+            [2.5, 1],
+            [2.5, 2.8],
+            [1.5, 2.8],
+        ];
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening, staleAutoOpening],
+            holeMetadata: [{ source: 'manual' }, { source: 'stair', stairId: 'stair_main' }],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_main',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_main',
+            name: 'Main Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        expect(landingUpdate?.data.holes).toEqual([manualOpening]);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'manual' }]);
+    });
+    test('does not add a separate rectangular hole for an integrated spiral top landing', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [-4, -4],
+                [4, -4],
+                [4, 4],
+                [-4, 4],
+            ],
+        });
+        const stair = StairNode.parse({
+            id: 'stair_spiral_landing',
+            name: 'Spiral Landing Stair',
+            parentId: ground.id,
+            position: [0, 0, 0],
+            rotation: Math.PI / 2,
+            stairType: 'spiral',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            innerRadius: 0.35,
+            width: 1.2,
+            sweepAngle: Math.PI * 1.6,
+            topLandingMode: 'integrated',
+            topLandingDepth: 1.1,
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        const holes = landingUpdate?.data.holes ?? [];
+        const rectangularHoles = holes.filter((hole) => hole.length === 4);
+        expect(holes).toHaveLength(1);
+        expect(rectangularHoles).toHaveLength(0);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
 });

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

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

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

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

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

@@ -0,0 +1,104 @@
+'use client';
+import { useEffect, useRef } from 'react';
+import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control';
+import useLiveNodeOverrides from '../../store/use-live-node-overrides';
+import useLiveTransforms from '../../store/use-live-transforms';
+import useScene from '../../store/use-scene';
+import { createSurfaceOpeningPreviewController, getNodesWithLiveStairOpeningInputs, hasLiveStairOpeningInputs, } from './stair-opening-preview';
+import { syncAutoStairOpenings } from './stair-opening-sync';
+function isOpeningRelevantNode(node) {
+    return (node?.type === 'building' ||
+        node?.type === 'ceiling' ||
+        node?.type === 'level' ||
+        node?.type === 'slab' ||
+        node?.type === 'stair' ||
+        node?.type === 'stair-segment');
+}
+function hasOpeningRelevantNodeChange(nextNodes, prevNodes) {
+    if (nextNodes === prevNodes)
+        return false;
+    const ids = new Set([...Object.keys(nextNodes), ...Object.keys(prevNodes)]);
+    for (const id of ids) {
+        const nextNode = nextNodes[id];
+        const prevNode = prevNodes[id];
+        if (nextNode === prevNode)
+            continue;
+        if (isOpeningRelevantNode(nextNode) || isOpeningRelevantNode(prevNode))
+            return true;
+    }
+    return false;
+}
+export const StairOpeningSystem = () => {
+    const syncingAutoOpeningsRef = useRef(false);
+    const syncingPreviewOpeningsRef = useRef(false);
+    const previewControllerRef = useRef(createSurfaceOpeningPreviewController());
+    useEffect(() => {
+        const applyUpdates = (updates) => {
+            if (updates.length === 0)
+                return;
+            syncingAutoOpeningsRef.current = true;
+            pauseSceneHistory(useScene);
+            try {
+                useScene.getState().updateNodes(updates);
+            }
+            finally {
+                resumeSceneHistory(useScene);
+            }
+            queueMicrotask(() => {
+                syncingAutoOpeningsRef.current = false;
+            });
+        };
+        const applyPreviewUpdates = (updates) => {
+            syncingPreviewOpeningsRef.current = true;
+            previewControllerRef.current.apply(updates);
+            queueMicrotask(() => {
+                syncingPreviewOpeningsRef.current = false;
+            });
+        };
+        const clearPreviewUpdates = () => {
+            if (previewControllerRef.current.previewSurfaceIds.size === 0)
+                return;
+            syncingPreviewOpeningsRef.current = true;
+            previewControllerRef.current.clear();
+            queueMicrotask(() => {
+                syncingPreviewOpeningsRef.current = false;
+            });
+        };
+        const refreshLivePreview = () => {
+            if (syncingPreviewOpeningsRef.current)
+                return;
+            const nodes = useScene.getState().nodes;
+            const liveTransforms = useLiveTransforms.getState().transforms;
+            const liveOverrides = useLiveNodeOverrides.getState().overrides;
+            const previewSurfaceIds = previewControllerRef.current.previewSurfaceIds;
+            if (!hasLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds)) {
+                clearPreviewUpdates();
+                return;
+            }
+            applyPreviewUpdates(syncAutoStairOpenings(getNodesWithLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds)));
+        };
+        applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
+        refreshLivePreview();
+        const unsubscribeScene = useScene.subscribe((state, prevState) => {
+            if (syncingAutoOpeningsRef.current)
+                return;
+            if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
+                return;
+            applyUpdates(syncAutoStairOpenings(state.nodes));
+            refreshLivePreview();
+        });
+        const unsubscribeLiveTransforms = useLiveTransforms.subscribe(() => {
+            refreshLivePreview();
+        });
+        const unsubscribeLiveOverrides = useLiveNodeOverrides.subscribe(() => {
+            refreshLivePreview();
+        });
+        return () => {
+            unsubscribeScene();
+            unsubscribeLiveTransforms();
+            unsubscribeLiveOverrides();
+            previewControllerRef.current.clear();
+        };
+    }, []);
+    return null;
+};

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;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;AAoND,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"}
+{"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;AAmBlD,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;AAkPD,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

@@ -3,6 +3,16 @@ import { getWallCurveFrameAt, isCurvedWall } from './wall-curve';
 // UTILITY FUNCTIONS
 // ============================================================================
 const TOLERANCE = 0.001;
+// Miter joints are line-line intersections, so the joint point sits a distance
+// ≈ halfThickness / sin(θ) from the junction, where θ is the angle between the
+// two walls. As θ → 0 (two walls nearly collinear — e.g. a room-preset preview
+// dragged on top of an existing wall, or a freshly-drawn wall almost parallel
+// to its neighbour) that distance runs away to infinity and the wall renders as
+// an infinite spike. Cap the joint at this multiple of the wall half-thickness;
+// beyond it we fall back to a square (butt) joint, exactly like the existing
+// parallel-walls guard. 10× preserves every realistic corner (a 0.1 m wall keeps
+// mitering down to ~11°) while bounding the pathological near-collinear case.
+const MITER_LIMIT = 10;
 function pointToKey(p, tolerance = TOLERANCE) {
     const snap = 1 / tolerance;
     return `${Math.round(p.x * snap)},${Math.round(p.y * snap)}`;
@@ -144,7 +154,14 @@ function calculateJunctionIntersections(junction, getThickness) {
                 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 });
+                processedWalls.push({
+                    wallId: wall.id,
+                    angle,
+                    edgeA,
+                    edgeB,
+                    isPassthrough: true,
+                    halfThickness: halfT,
+                });
             }
         }
         else {
@@ -159,7 +176,14 @@ function calculateJunctionIntersections(junction, getThickness) {
             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 });
+            processedWalls.push({
+                wallId: wall.id,
+                angle,
+                edgeA,
+                edgeB,
+                isPassthrough: false,
+                halfThickness: halfT,
+            });
         }
     }
     // Sort by outgoing angle
@@ -182,6 +206,18 @@ function calculateJunctionIntersections(junction, getThickness) {
             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,
         };
+        // Miter limit: `det` only catches walls that are *exactly* parallel. Two
+        // walls meeting at a shallow angle have a small-but-nonzero `det`, so `p`
+        // lands far from the junction (∝ 1/sin θ) and the wall renders as an
+        // infinite spike. Reject any joint farther than MITER_LIMIT half-thicknesses
+        // from the meeting point — those walls fall back to a square joint.
+        const maxMiter = MITER_LIMIT * Math.max(wall1.halfThickness, wall2.halfThickness);
+        const dx = p.x - meetingPoint.x;
+        const dy = p.y - meetingPoint.y;
+        if (!(Number.isFinite(p.x) && Number.isFinite(p.y)) ||
+            dx * dx + dy * dy > maxMiter * maxMiter) {
+            continue;
+        }
         // Only assign intersection to non-passthrough walls
         // Passthrough walls don't receive junction data (their geometry doesn't change)
         if (!wall1.isPassthrough) {

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wall-mitering.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-mitering.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.test.ts"],"names":[],"mappings":""}