@pascal-app/core 1.0.0 → 1.0.3

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

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}
+{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}

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

@@ -1,5 +1,5 @@
-import useLiveNodeOverrides, {} from '../../store/use-live-node-overrides';
-import useScene from '../../store/use-scene';
+import useLiveNodeOverrides, {} from '../../store/use-live-node-overrides.js';
+import useScene from '../../store/use-scene.js';
 const SURFACE_OPENING_FIELDS = ['holes', 'holeMetadata'];
 function isSurface(node) {
     return node?.type === 'slab' || node?.type === 'ceiling';

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

@@ -1,4 +1,4 @@
-import type { AnyNode, AnyNodeId, CeilingNode, SlabNode } from '../../schema';
+import type { AnyNode, AnyNodeId, CeilingNode, SlabNode } from '../../schema/index.js';
 export declare function syncAutoStairOpenings(nodes: Record<string, AnyNode>): {
     id: AnyNodeId;
     data: Partial<SlabNode | CeilingNode>;

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

@@ -1,9 +1,9 @@
-import { resolveBuildingForLevel, resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
-import { polygonContainsPolygon, polygonsOverlap } from '../../lib/polygon-relations';
-import { resolveCeilingHeight } from '../../services/level-height';
-import { getLevelElevations } from '../../services/storey';
-import { computeSegmentTransforms, rotateXZ } from './stair-footprint';
-import { resolveStairTotalRise } from './stair-rise';
+import { resolveBuildingForLevel, resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync.js';
+import { polygonContainsPolygon, polygonsOverlap } from '../../lib/polygon-relations.js';
+import { resolveCeilingHeight } from '../../services/level-height.js';
+import { getLevelElevations } from '../../services/storey.js';
+import { computeSegmentTransforms, rotateXZ } from './stair-footprint.js';
+import { resolveStairTotalRise } from './stair-rise.js';
 const CURVED_STAIR_SLAB_OPENING_RATIO = 0.8;
 const STRAIGHT_STAIR_TARGET_THRESHOLD_MIN = 0.35;
 const STAIR_SLAB_OPENING_TIGHTENING = 0;

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

@@ -1,13 +1,13 @@
 'use client';
 import { useEffect } from 'react';
-import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control';
-import { queueSceneNormalization } from '../../store/scene-hydration';
-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';
-import { syncStairRises } from './stair-rise';
+import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control.js';
+import { queueSceneNormalization } from '../../store/scene-hydration.js';
+import useLiveNodeOverrides from '../../store/use-live-node-overrides.js';
+import useLiveTransforms from '../../store/use-live-transforms.js';
+import useScene from '../../store/use-scene.js';
+import { createSurfaceOpeningPreviewController, getNodesWithLiveStairOpeningInputs, hasLiveStairOpeningInputs, } from './stair-opening-preview.js';
+import { syncAutoStairOpenings } from './stair-opening-sync.js';
+import { syncStairRises } from './stair-rise.js';
 function isOpeningRelevantNode(node) {
     return (node?.type === 'building' ||
         node?.type === 'ceiling' ||

package/dist/systems/stair/stair-rise.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, AnyNodeId, StairNode } from '../../schema';
+import type { AnyNode, AnyNodeId, StairNode } from '../../schema/index.js';
 export declare function resolveStairTotalRise(stair: StairNode, nodes: Record<string, AnyNode>): number;
 /**
  * Keeps straight stairs' flight segments in step with the resolved rise.

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

@@ -1,6 +1,6 @@
-import { getFloorStackedPosition } from '../../hooks/spatial-grid/floor-placed-elevation';
-import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height';
-import { getLevelFloorToFloorHeight } from '../../services/storey';
+import { getFloorStackedPosition } from '../../hooks/spatial-grid/floor-placed-elevation.js';
+import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height.js';
+import { getLevelFloorToFloorHeight } from '../../services/storey.js';
 export function resolveStairTotalRise(stair, nodes) {
     if (stair.totalRise !== undefined)
         return stair.totalRise;

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

@@ -1,5 +1,5 @@
-import type { FenceNode, WallNode } from '../../schema';
-import type { Point2D } from './wall-mitering';
+import type { FenceNode, WallNode } from '../../schema/index.js';
+import type { Point2D } from './wall-mitering.js';
 type WallCurveLike = Pick<WallNode | FenceNode, 'start' | 'end' | 'curveOffset'>;
 type CurveFrame = {
     point: Point2D;

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

@@ -1,6 +1,6 @@
-import type { WallNode } from '../../schema';
-import { type Point2D, type WallMiterData } from './wall-mitering';
-export { calculateLevelMiters, type Point2D, type WallMiterData } from './wall-mitering';
+import type { WallNode } from '../../schema/index.js';
+import { type Point2D, type WallMiterData } from './wall-mitering.js';
+export { calculateLevelMiters, type Point2D, type WallMiterData } from './wall-mitering.js';
 export declare const DEFAULT_WALL_THICKNESS = 0.1;
 export declare const DEFAULT_WALL_HEIGHT = 2.5;
 export declare function getWallThickness(wallNode: WallNode): number;

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

@@ -1,6 +1,6 @@
-import { getWallSurfacePolygon, isCurvedWall } from './wall-curve';
-import { getWallMiterBoundaryPoints, pointToKey, } from './wall-mitering';
-export { calculateLevelMiters } from './wall-mitering';
+import { getWallSurfacePolygon, isCurvedWall } from './wall-curve.js';
+import { getWallMiterBoundaryPoints, pointToKey, } from './wall-mitering.js';
+export { calculateLevelMiters } from './wall-mitering.js';
 export const DEFAULT_WALL_THICKNESS = 0.1;
 export const DEFAULT_WALL_HEIGHT = 2.5;
 const CURVED_WALL_SURFACE_SEGMENTS = 24;

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

@@ -0,0 +1,38 @@
+import { type AnyNode, type AnyNodeId, type WallNode } from '../../schema/index.js';
+import type { WallTopologyChanges } from './wall-topology.js';
+export type WallAttachmentUpdate = {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+};
+export declare function getWallEndpointAtPoint(wall: Pick<WallNode, 'start' | 'end'>, point: [number, number]): 'start' | 'end' | null;
+/**
+ * The first thing two walls disagree on (for the merge's explanation), or null.
+ * The delete heal is strict: room sides must match, and a wall following the
+ * storey never joins one with an explicit height. An explicit merge compares
+ * what is visible instead — `heightOf` resolves each wall's actual height — and
+ * leaves the sides to room detection, which reclassifies the merged wall.
+ */
+export declare function wallStyleMismatch(a: WallNode, b: WallNode, options: {
+    sides: boolean;
+    heightOf?: (wall: WallNode) => number;
+}): string | null;
+export declare function areWallStylesCompatible(a: WallNode, b: WallNode): boolean;
+export declare function areWallsCollinearAcrossPoint(a: WallNode, b: WallNode, sharedPoint: [number, number]): boolean;
+export declare function resolveMergedWallEndpoints(primary: WallNode, secondary: WallNode, sharedPoint: [number, number]): {
+    start: [number, number];
+    end: [number, number];
+};
+export declare function buildMergedWallAttachmentUpdates(primary: WallNode, secondary: WallNode, mergedWallId: AnyNodeId, mergedStart: [number, number], mergedEnd: [number, number], nodes: Record<AnyNodeId, AnyNode>): WallAttachmentUpdate[];
+/**
+ * Merges a straight run of adjoining walls into one — the inverse of a split.
+ * Every joint must hold exactly these walls (a T or a cross stays split), and
+ * neighbours must continue in line and look alike (`wallStyleMismatch`: same
+ * thickness, visible height and finish). The wall with the most attachments
+ * keeps its id and height mode; openings and wall items keep their world
+ * position on it.
+ */
+export declare function planWallMerge(nodes: Record<AnyNodeId, AnyNode>, wallIds: readonly AnyNodeId[]): {
+    changes: WallTopologyChanges;
+    wallId: WallNode['id'];
+};
+//# sourceMappingURL=wall-merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-merge.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-merge.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,KAAK,QAAQ,EACd,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAK1D,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAY5E,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,OAAO,GAAG,KAAK,GAAG,IAAI,CAIxB;AAMD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,EACX,OAAO,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,CAAA;CAAE,GACjE,MAAM,GAAG,IAAI,CAuBf;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,WAE/D;AAED,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,EACX,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,WAgB9B;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAkBpD;AAyBD,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,YAAY,EAAE,SAAS,EACvB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,oBAAoB,EAAE,CAyDxB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,SAAS,EAAE,GAC5B;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;CAAE,CA4F1D"}

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

@@ -0,0 +1,240 @@
+import { getWallEffectiveHeightForNodes } from '../../hooks/spatial-grid/spatial-grid-manager.js';
+import { getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, } from '../../schema/index.js';
+function pointsEqual(a, b, tolerance = 1e-6) {
+    const dx = a[0] - b[0];
+    const dz = a[1] - b[1];
+    return dx * dx + dz * dz <= tolerance * tolerance;
+}
+function wallLength(wall) {
+    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+}
+export function getWallEndpointAtPoint(wall, point) {
+    if (pointsEqual(wall.start, point))
+        return 'start';
+    if (pointsEqual(wall.end, point))
+        return 'end';
+    return null;
+}
+function getWallFreeEndpoint(wall, sharedPoint) {
+    return pointsEqual(wall.start, sharedPoint) ? wall.end : wall.start;
+}
+/**
+ * The first thing two walls disagree on (for the merge's explanation), or null.
+ * The delete heal is strict: room sides must match, and a wall following the
+ * storey never joins one with an explicit height. An explicit merge compares
+ * what is visible instead — `heightOf` resolves each wall's actual height — and
+ * leaves the sides to room detection, which reclassifies the merged wall.
+ */
+export function wallStyleMismatch(a, b, options) {
+    if ((a.parentId ?? null) !== (b.parentId ?? null))
+        return 'floor';
+    if (Math.abs((a.curveOffset ?? 0) - (b.curveOffset ?? 0)) > 1e-6)
+        return 'curve';
+    if (Math.abs((a.thickness ?? 0.2) - (b.thickness ?? 0.2)) > 1e-6)
+        return 'thickness';
+    const { heightOf } = options;
+    if (heightOf
+        ? Math.abs(heightOf(a) - heightOf(b)) > 1e-6
+        : (a.height == null) !== (b.height == null) ||
+            Math.abs((a.height ?? 0) - (b.height ?? 0)) > 1e-6)
+        return 'height';
+    for (const side of ['interior', 'exterior']) {
+        if (getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(a, side)) !==
+            getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(b, side)))
+            return `${side} finish`;
+    }
+    if (options.sides && (a.frontSide !== b.frontSide || a.backSide !== b.backSide))
+        return 'room sides';
+    if (a.visible !== b.visible)
+        return 'visibility';
+    return null;
+}
+export function areWallStylesCompatible(a, b) {
+    return wallStyleMismatch(a, b, { sides: true }) === null;
+}
+export function areWallsCollinearAcrossPoint(a, b, sharedPoint) {
+    const freeA = getWallFreeEndpoint(a, sharedPoint);
+    const freeB = getWallFreeEndpoint(b, sharedPoint);
+    const ax = freeA[0] - sharedPoint[0];
+    const az = freeA[1] - sharedPoint[1];
+    const bx = freeB[0] - sharedPoint[0];
+    const bz = freeB[1] - sharedPoint[1];
+    const lenA = Math.hypot(ax, az);
+    const lenB = Math.hypot(bx, bz);
+    if (lenA < 1e-6 || lenB < 1e-6)
+        return false;
+    const cross = (ax * bz - az * bx) / (lenA * lenB);
+    const dot = (ax * bx + az * bz) / (lenA * lenB);
+    return Math.abs(cross) <= 1e-4 && dot < -0.999;
+}
+export function resolveMergedWallEndpoints(primary, secondary, sharedPoint) {
+    const primaryEndpoint = getWallEndpointAtPoint(primary, sharedPoint);
+    const secondaryEndpoint = getWallEndpointAtPoint(secondary, sharedPoint);
+    if (primaryEndpoint === 'end' && secondaryEndpoint === 'start') {
+        return { start: primary.start, end: secondary.end };
+    }
+    if (primaryEndpoint === 'start' && secondaryEndpoint === 'end') {
+        return { start: secondary.start, end: primary.end };
+    }
+    // The kept wall never turns around: its sides, finishes and hosted faces stay
+    // where they are. Meeting start-to-start or end-to-end, the absorbed wall is
+    // the one read backwards.
+    if (primaryEndpoint === 'start' && secondaryEndpoint === 'start') {
+        return { start: secondary.end, end: primary.end };
+    }
+    return { start: primary.start, end: secondary.start };
+}
+/**
+ * Hosted nodes live in the wall's local frame (+X along it, +Z its front, yaw
+ * 0 front / π back). A wall read backwards turns that frame by 180° about Y,
+ * so the face and the yaw swap and the caller mirrors depth. Hinges, handles
+ * and swing hang off the node's own yaw (the plan symbol flips them from it),
+ * so they stay as stored.
+ */
+function reversedWallChildPatch(child) {
+    const patch = {};
+    if ('side' in child && (child.side === 'front' || child.side === 'back')) {
+        patch.side = child.side === 'front' ? 'back' : 'front';
+    }
+    if ('rotation' in child && Array.isArray(child.rotation)) {
+        const yaw = child.rotation[1] + Math.PI;
+        patch.rotation = [
+            child.rotation[0],
+            Math.atan2(Math.sin(yaw), Math.cos(yaw)),
+            child.rotation[2],
+        ];
+    }
+    return patch;
+}
+export function buildMergedWallAttachmentUpdates(primary, secondary, mergedWallId, mergedStart, mergedEnd, nodes) {
+    const mergedLength = Math.max(Math.hypot(mergedEnd[0] - mergedStart[0], mergedEnd[1] - mergedStart[1]), 1e-6);
+    const tangentX = (mergedEnd[0] - mergedStart[0]) / mergedLength;
+    const tangentZ = (mergedEnd[1] - mergedStart[1]) / mergedLength;
+    const updates = [];
+    const wallChildren = [...(primary.children ?? []), ...(secondary.children ?? [])];
+    for (const childId of wallChildren) {
+        const child = nodes[childId];
+        if (!child)
+            continue;
+        // Every child moves to the kept wall: deleting the absorbed wall would
+        // otherwise take a child left on it along. Only positioned ones re-place.
+        const rehost = { parentId: mergedWallId, wallId: mergedWallId };
+        if (!('position' in child && Array.isArray(child.position))) {
+            updates.push({ id: childId, data: rehost });
+            continue;
+        }
+        const sourceWall = child.parentId === secondary.id ? secondary : primary;
+        const sourceLength = Math.max(wallLength(sourceWall), 1e-6);
+        const reversed = (sourceWall.end[0] - sourceWall.start[0]) * tangentX +
+            (sourceWall.end[1] - sourceWall.start[1]) * tangentZ <
+            0;
+        const mirrored = reversed ? reversedWallChildPatch(child) : {};
+        const localX = typeof child.position[0] === 'number' ? child.position[0] : 0;
+        const worldX = sourceWall.start[0] + ((sourceWall.end[0] - sourceWall.start[0]) * localX) / sourceLength;
+        const worldZ = sourceWall.start[1] + ((sourceWall.end[1] - sourceWall.start[1]) * localX) / sourceLength;
+        const nextLocalX = Math.max(0, Math.min(mergedLength, (worldX - mergedStart[0]) * tangentX + (worldZ - mergedStart[1]) * tangentZ));
+        updates.push({
+            id: childId,
+            data: {
+                ...rehost,
+                ...mirrored,
+                position: [
+                    nextLocalX,
+                    child.position[1],
+                    reversed ? -child.position[2] : child.position[2],
+                ],
+                ...('wallT' in child ? { wallT: nextLocalX / mergedLength } : {}),
+            },
+        });
+    }
+    return updates;
+}
+/**
+ * Merges a straight run of adjoining walls into one — the inverse of a split.
+ * Every joint must hold exactly these walls (a T or a cross stays split), and
+ * neighbours must continue in line and look alike (`wallStyleMismatch`: same
+ * thickness, visible height and finish). The wall with the most attachments
+ * keeps its id and height mode; openings and wall items keep their world
+ * position on it.
+ */
+export function planWallMerge(nodes, wallIds) {
+    const walls = [...new Set(wallIds)]
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'wall');
+    if (walls.length < 2 || walls.length !== new Set(wallIds).size)
+        throw Error('Select two or more walls to merge.');
+    if (walls.some((wall) => (wall.curveOffset ?? 0) !== 0))
+        throw Error('Only straight walls can be merged.');
+    const levelId = walls[0].parentId ?? null;
+    if (walls.some((wall) => (wall.parentId ?? null) !== levelId))
+        throw Error('Merge walls on the same floor.');
+    const virtual = { ...nodes };
+    const [primary, ...rest] = [...walls].sort((a, b) => (b.children?.length ?? 0) - (a.children?.length ?? 0) || a.id.localeCompare(b.id));
+    let merged = primary;
+    let remaining = rest;
+    while (remaining.length > 0) {
+        let next;
+        let joint;
+        for (const wall of remaining) {
+            joint = [merged.start, merged.end].find((end) => getWallEndpointAtPoint(wall, end) !== null);
+            if (joint) {
+                next = wall;
+                break;
+            }
+        }
+        if (!(next && joint))
+            throw Error('Merge walls that touch end to end.');
+        const atJoint = Object.values(virtual).filter((node) => node?.type === 'wall' &&
+            (node.parentId ?? null) === levelId &&
+            getWallEndpointAtPoint(node, joint) !== null);
+        if (atJoint.length !== 2)
+            throw Error('Another wall meets this joint, so merging would disconnect it.');
+        if (!areWallsCollinearAcrossPoint(merged, next, joint))
+            throw Error('Merge walls that continue in a straight line.');
+        const mismatch = wallStyleMismatch(merged, next, {
+            sides: false,
+            heightOf: (wall) => getWallEffectiveHeightForNodes(wall, virtual),
+        });
+        if (mismatch)
+            throw Error(`These walls have a different ${mismatch}.`);
+        const { start, end } = resolveMergedWallEndpoints(merged, next, joint);
+        for (const update of buildMergedWallAttachmentUpdates(merged, next, merged.id, start, end, virtual)) {
+            virtual[update.id] = { ...virtual[update.id], ...update.data };
+        }
+        merged = {
+            ...merged,
+            start,
+            end,
+            // Ids without a node are dropped rather than carried onto the kept wall.
+            children: [
+                ...new Set([
+                    ...(merged.children ?? []),
+                    ...(next.children ?? []).filter((id) => virtual[id]),
+                ]),
+            ],
+        };
+        virtual[merged.id] = merged;
+        delete virtual[next.id];
+        for (const node of Object.values(virtual)) {
+            if (node?.type !== 'zone' || !node.boundaryWallIds?.includes(next.id))
+                continue;
+            virtual[node.id] = {
+                ...node,
+                boundaryWallIds: [
+                    ...new Set(node.boundaryWallIds.map((id) => (id === next.id ? merged.id : id))),
+                ],
+            };
+        }
+        remaining = remaining.filter((wall) => wall !== next);
+    }
+    return {
+        changes: {
+            create: [],
+            update: Object.values(virtual)
+                .filter((node) => nodes[node.id] && node !== nodes[node.id])
+                .map((node) => ({ id: node.id, data: node })),
+            delete: walls.filter((wall) => !virtual[wall.id]).map((wall) => wall.id),
+        },
+        wallId: merged.id,
+    };
+}

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

@@ -1,4 +1,4 @@
-import type { WallNode } from '../../schema';
+import type { WallNode } from '../../schema/index.js';
 export interface Point2D {
     x: number;
     y: number;

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

@@ -1,4 +1,4 @@
-import { getWallCurveFrameAt, isCurvedWall } from './wall-curve';
+import { getWallCurveFrameAt, isCurvedWall } from './wall-curve.js';
 // ============================================================================
 // UTILITY FUNCTIONS
 // ============================================================================

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

@@ -1,4 +1,4 @@
-import type { WallNode } from '../../schema';
+import type { WallNode } from '../../schema/index.js';
 export type WallPlanPoint = [number, number];
 export type WallMoveAxis = [number, number];
 export type WallMoveEndpoint = 'start' | 'end';

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

@@ -0,0 +1,28 @@
+import type { AnyNode, AnyNodeId, WallNode } from '../../schema/index.js';
+import type { WallPlanPoint } from './wall-move.js';
+import { type WallTopologyChanges } from './wall-topology.js';
+export declare function wallRectangleCorners(a: WallPlanPoint, b: WallPlanPoint): WallPlanPoint[];
+/** Plan against a scratch graph so four sides commit atomically, including junction splits. */
+export declare function planWallRectangle(nodes: Record<AnyNodeId, AnyNode>, args: {
+    levelId: AnyNodeId;
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+    wallDefaults?: Partial<WallNode>;
+}): {
+    changes: WallTopologyChanges;
+    walls: WallNode[];
+};
+/** Explicit split keeps the first wall's identity and reuses the junction planner's host migration. */
+export declare function planWallDivision(nodes: Record<AnyNodeId, AnyNode>, wallId: WallNode['id'], distance: number): {
+    changes: WallTopologyChanges;
+    point: WallPlanPoint;
+};
+/**
+ * Several cuts as one edit. Cutting farthest first keeps the first wall's
+ * identity at every step, so the nearer distances stay valid on it.
+ */
+export declare function planWallDivisions(nodes: Record<AnyNodeId, AnyNode>, wallId: WallNode['id'], distances: readonly number[]): {
+    changes: WallTopologyChanges;
+    points: WallPlanPoint[];
+};
+//# sourceMappingURL=wall-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-operations.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,iBAAiB,CAAA;AAExB,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa,EAAE,CAiBxF;AAED,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CACjC,GACA;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,QAAQ,EAAE,CAAA;CAAE,CAyCrD;AAED,uGAAuG;AACvG,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,EACtB,QAAQ,EAAE,MAAM;;WAsD+B,aAAa;EAC7D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,EACtB,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,aAAa,EAAE,CAAA;CAAE,CAyB3D"}

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

@@ -0,0 +1,145 @@
+import { getWallCurveFrameAt, getWallCurveLength } from './wall-curve.js';
+import { planWallInsertion, planWallSplitAtPoint, uncoveredWallSegments, } from './wall-topology.js';
+export function wallRectangleCorners(a, b) {
+    if (![...a, ...b].every(Number.isFinite) ||
+        Math.abs(a[0] - b[0]) < 0.05 ||
+        Math.abs(a[1] - b[1]) < 0.05)
+        return [];
+    const x = Math.min(a[0], b[0]);
+    const z = Math.min(a[1], b[1]);
+    const right = Math.max(a[0], b[0]);
+    const top = Math.max(a[1], b[1]);
+    return [
+        [x, z],
+        [right, z],
+        [right, top],
+        [x, top],
+    ];
+}
+/** Plan against a scratch graph so four sides commit atomically, including junction splits. */
+export function planWallRectangle(nodes, args) {
+    if (nodes[args.levelId]?.type !== 'level')
+        throw Error('Select an editable floor.');
+    const corners = wallRectangleCorners(args.start, args.end);
+    if (!corners.length)
+        throw Error('Both rectangle dimensions must be at least 5 cm.');
+    const virtual = { ...nodes };
+    const added = new Set();
+    for (let i = 0; i < 4; i++) {
+        // A side that runs along existing walls only adds what they don't cover,
+        // so snapping to a wall and dragging past its end reuses it rather than
+        // doubling it.
+        const levelWalls = Object.values(virtual).filter((node) => node.type === 'wall' && node.parentId === args.levelId);
+        for (const [start, end] of uncoveredWallSegments(corners[i], corners[(i + 1) % 4], levelWalls)) {
+            const result = planWallInsertion(virtual, { ...args, start, end, joinRadius: 0 });
+            if (!result.ok)
+                throw Error('The rectangle cannot be drawn here.');
+            for (const id of result.plan.changes.delete)
+                delete virtual[id];
+            for (const { node, parentId } of result.plan.changes.create) {
+                virtual[node.id] = { ...node, ...(parentId ? { parentId } : {}) };
+            }
+            for (const wall of result.plan.insertedWalls)
+                added.add(wall.id);
+            for (const { id, data } of result.plan.changes.update) {
+                if (virtual[id])
+                    virtual[id] = { ...virtual[id], ...data };
+            }
+        }
+    }
+    const created = Object.values(virtual).filter((n) => !nodes[n.id]);
+    return {
+        changes: {
+            create: created.map((node) => ({ node, parentId: node.parentId })),
+            update: Object.values(virtual)
+                .filter((n) => nodes[n.id] && n !== nodes[n.id])
+                .map((n) => ({ id: n.id, data: n })),
+            delete: Object.keys(nodes).filter((id) => !virtual[id]),
+        },
+        walls: created.filter((n) => n.type === 'wall' && added.has(n.id)),
+    };
+}
+/** Explicit split keeps the first wall's identity and reuses the junction planner's host migration. */
+export function planWallDivision(nodes, wallId, distance) {
+    const wall = nodes[wallId];
+    if (wall?.type !== 'wall' || !wall.parentId)
+        throw Error('Select a wall.');
+    const length = getWallCurveLength(wall);
+    if (!Number.isFinite(distance) || distance < 0.05 || distance > length - 0.05)
+        throw Error('Keep at least 5 cm on each side of the split.');
+    const point = getWallCurveFrameAt(wall, distance / length).point;
+    const result = planWallSplitAtPoint(nodes, {
+        levelId: wall.parentId,
+        point: [point.x, point.y],
+        radius: 0.001,
+        ignoreWallIds: Object.values(nodes)
+            .filter((n) => n.type === 'wall' && n.id !== wallId)
+            .map((n) => n.id),
+    });
+    if (!result.ok || result.plan.changes.create.length !== 2)
+        throw Error('Move the split away from doors, windows and mounted objects.');
+    const [first, second] = result.plan.changes.create;
+    const firstId = first.node.id;
+    const changes = {
+        create: [second],
+        delete: [],
+        update: [
+            {
+                id: wallId,
+                data: { ...first.node, id: wallId, parentId: wall.parentId },
+            },
+            ...result.plan.changes.update.map((op) => ({
+                ...op,
+                data: {
+                    ...op.data,
+                    ...(op.data.parentId === firstId ? { parentId: wallId } : {}),
+                    ...('wallId' in op.data && op.data.wallId === firstId ? { wallId } : {}),
+                },
+            })),
+        ],
+    };
+    for (const node of Object.values(nodes)) {
+        if (node.type === 'zone' &&
+            node.parentId === wall.parentId &&
+            node.boundaryWallIds?.includes(wallId)) {
+            changes.update.push({
+                id: node.id,
+                data: {
+                    boundaryWallIds: node.boundaryWallIds.flatMap((id) => id === wallId ? [wallId, second.node.id] : [id]),
+                },
+            });
+        }
+    }
+    return { changes, point: [point.x, point.y] };
+}
+/**
+ * Several cuts as one edit. Cutting farthest first keeps the first wall's
+ * identity at every step, so the nearer distances stay valid on it.
+ */
+export function planWallDivisions(nodes, wallId, distances) {
+    const virtual = { ...nodes };
+    const points = [];
+    for (const distance of [...distances].sort((a, b) => b - a)) {
+        const plan = planWallDivision(virtual, wallId, distance);
+        for (const { node, parentId } of plan.changes.create) {
+            virtual[node.id] = { ...node, ...(parentId ? { parentId } : {}) };
+        }
+        for (const { id, data } of plan.changes.update) {
+            if (virtual[id])
+                virtual[id] = { ...virtual[id], ...data };
+        }
+        points.push(plan.point);
+    }
+    return {
+        changes: {
+            create: Object.values(virtual)
+                .filter((n) => !nodes[n.id])
+                .map((node) => ({ node, parentId: node.parentId })),
+            update: Object.values(virtual)
+                .filter((n) => nodes[n.id] && n !== nodes[n.id])
+                .map((n) => ({ id: n.id, data: n })),
+            delete: [],
+        },
+        points: points.reverse(),
+    };
+}

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

@@ -1,4 +1,4 @@
-import type { WallNode } from '../../schema/nodes/wall';
+import type { WallNode } from '../../schema/nodes/wall.js';
 /**
  * Minimum wall body height in meters. Governs both the wall height
  * arrow's lower drag bound and the slab-elevation clamp: a slab may not

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

@@ -1,5 +1,5 @@
-import { type AnyNode, type AnyNodeId, type WallNode } from '../../schema';
-import type { WallPlanPoint } from './wall-move';
+import { type AnyNode, type AnyNodeId, type WallNode } from '../../schema/index.js';
+import type { WallPlanPoint } from './wall-move.js';
 export type WallTopologyChanges = {
     create: Array<{
         node: AnyNode;
@@ -37,6 +37,13 @@ export type WallPointSplitResult = {
     ok: false;
     reason: 'no-host';
 };
+/**
+ * The parts of `start→end` that no straight wall already runs along, in order.
+ * A side drawn along an existing wall and past its end yields the overhang
+ * only, so the existing wall is reused instead of doubled. Gaps too short to
+ * be a wall are treated as covered.
+ */
+export declare function uncoveredWallSegments(start: WallPlanPoint, end: WallPlanPoint, walls: WallNode[]): Array<[WallPlanPoint, WallPlanPoint]>;
 export declare function planWallSplitAtPoint(nodes: Record<AnyNodeId, AnyNode>, args: {
     levelId: AnyNodeId | null;
     point: WallPlanPoint;