@pascal-app/core 0.9.1 → 1.0.0-beta.1

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

@@ -1,2 +1,3 @@
+export declare function initializeElevatorOpeningSync(): () => void;
 export declare const ElevatorOpeningSystem: () => null;
 //# sourceMappingURL=elevator-opening-system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"elevator-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-system.tsx"],"names":[],"mappings":"AAkCA,eAAO,MAAM,qBAAqB,YAuBjC,CAAA"}
+{"version":3,"file":"elevator-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-system.tsx"],"names":[],"mappings":"AAmCA,wBAAgB,6BAA6B,eAsB5C;AAED,eAAO,MAAM,qBAAqB,YAIjC,CAAA"}

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

@@ -1,5 +1,6 @@
 'use client';
-import { useEffect, useRef } from 'react';
+import { useEffect } from 'react';
+import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control';
 import useScene from '../../store/use-scene';
 import { syncAutoElevatorOpenings } from './elevator-opening-sync';
 function isOpeningRelevantNode(node) {
@@ -23,26 +24,31 @@ function hasOpeningRelevantNodeChange(nextNodes, prevNodes) {
     }
     return false;
 }
-export const ElevatorOpeningSystem = () => {
-    const syncingAutoOpeningsRef = useRef(false);
-    useEffect(() => {
-        const applyUpdates = (updates) => {
-            if (updates.length === 0)
-                return;
-            syncingAutoOpeningsRef.current = true;
+export function initializeElevatorOpeningSync() {
+    let syncingAutoOpenings = false;
+    const applyUpdates = (updates) => {
+        if (updates.length === 0)
+            return;
+        syncingAutoOpenings = true;
+        pauseSceneHistory(useScene);
+        try {
             useScene.getState().updateNodes(updates);
-            queueMicrotask(() => {
-                syncingAutoOpeningsRef.current = false;
-            });
-        };
-        applyUpdates(syncAutoElevatorOpenings(useScene.getState().nodes));
-        return useScene.subscribe((state, prevState) => {
-            if (syncingAutoOpeningsRef.current)
-                return;
-            if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
-                return;
-            applyUpdates(syncAutoElevatorOpenings(state.nodes));
-        });
-    }, []);
+        }
+        finally {
+            resumeSceneHistory(useScene);
+            syncingAutoOpenings = false;
+        }
+    };
+    applyUpdates(syncAutoElevatorOpenings(useScene.getState().nodes));
+    return useScene.subscribe((state, prevState) => {
+        if (syncingAutoOpenings)
+            return;
+        if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
+            return;
+        applyUpdates(syncAutoElevatorOpenings(state.nodes));
+    });
+}
+export const ElevatorOpeningSystem = () => {
+    useEffect(() => initializeElevatorOpeningSync(), []);
     return null;
 };

package/dist/systems/elevator/elevator-service.d.ts

@@ -1,5 +1,4 @@
 import type { AnyNode, ElevatorNode, LevelNode } from '../../schema';
-export declare const DEFAULT_ELEVATOR_LEVEL_HEIGHT = 2.5;
 export type ElevatorLevelEntry = {
     id: LevelNode['id'];
     label: string;
@@ -8,7 +7,6 @@ export type ElevatorLevelEntry = {
 export declare function resolveElevatorBuildingLevels(elevator: ElevatorNode, nodes: Record<string, AnyNode>): LevelNode[];
 export declare function resolveElevatorServiceLevelIds(elevator: ElevatorNode, nodes: Record<string, AnyNode>): string[];
 export declare function resolveElevatorServiceLevels(elevator: ElevatorNode, nodes: Record<string, AnyNode>): LevelNode[];
-export declare function getElevatorLevelHeight(levelId: string, nodes: Record<string, AnyNode>): number;
 export declare function resolveElevatorLevels(elevator: ElevatorNode, nodes: Record<string, AnyNode>): {
     entries: ElevatorLevelEntry[];
     defaultEntry: ElevatorLevelEntry | null;

package/dist/systems/elevator/elevator-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-service.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAGP,YAAY,EACZ,SAAS,EAEV,MAAM,cAAc,CAAA;AAErB,eAAO,MAAM,6BAA6B,MAAM,CAAA;AAEhD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AA2BD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAEb;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,EAAE,CAEV;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAsBb;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAoB9F;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,CA0CA"}
+{"version":3,"file":"elevator-service.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAG/E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AA2BD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAEb;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,EAAE,CAEV;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAsBb;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,CA0CA"}

package/dist/systems/elevator/elevator-service.js

@@ -1,4 +1,4 @@
-export const DEFAULT_ELEVATOR_LEVEL_HEIGHT = 2.5;
+import { getStoredLevelHeight } from '../../services/storey';
 function getBuildingLevels(elevator, nodes) {
     const building = elevator.parentId && nodes[elevator.parentId]?.type === 'building'
         ? nodes[elevator.parentId]
@@ -49,35 +49,13 @@ export function resolveElevatorServiceLevels(elevator, nodes) {
     const maxIndex = Math.max(fromIndex, resolvedToIndex);
     return levels.slice(minIndex, maxIndex + 1);
 }
-export function getElevatorLevelHeight(levelId, nodes) {
-    const level = nodes[levelId];
-    if (!level || level.type !== 'level')
-        return DEFAULT_ELEVATOR_LEVEL_HEIGHT;
-    let maxTop = 0;
-    for (const childId of level.children) {
-        const child = nodes[childId];
-        if (!child)
-            continue;
-        if (child.type === 'ceiling') {
-            const height = child.height ?? DEFAULT_ELEVATOR_LEVEL_HEIGHT;
-            if (height > maxTop)
-                maxTop = height;
-        }
-        else if (child.type === 'wall') {
-            const height = child.height ?? DEFAULT_ELEVATOR_LEVEL_HEIGHT;
-            if (height > maxTop)
-                maxTop = height;
-        }
-    }
-    return maxTop > 0 ? maxTop : DEFAULT_ELEVATOR_LEVEL_HEIGHT;
-}
 export function resolveElevatorLevels(elevator, nodes) {
     const allLevels = resolveElevatorBuildingLevels(elevator, nodes);
     const baseYByLevelId = new Map();
     let cumulativeY = 0;
     for (const level of allLevels) {
         baseYByLevelId.set(level.id, cumulativeY);
-        cumulativeY += getElevatorLevelHeight(level.id, nodes);
+        cumulativeY += getStoredLevelHeight(level);
     }
     const serviceLevels = resolveElevatorServiceLevels(elevator, nodes);
     const entries = serviceLevels.map((level) => ({

package/dist/systems/fence/fence-centerline.d.ts

@@ -0,0 +1,12 @@
+import type { FenceNode } from '../../schema';
+import type { Point2D } from '../wall/wall-mitering';
+type CurveFrame = {
+    point: Point2D;
+    tangent: Point2D;
+    normal: Point2D;
+};
+export declare function getFenceCenterlineFrameAt(fence: FenceNode, t: number): CurveFrame;
+export declare function sampleFenceCenterline(fence: FenceNode, segments?: number): Point2D[];
+export declare function getFenceCenterlineLength(fence: FenceNode, segments?: number): number;
+export {};
+//# sourceMappingURL=fence-centerline.d.ts.map

package/dist/systems/fence/fence-centerline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fence-centerline.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-centerline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAqBpD,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAKjF;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,QAAQ,SAA0B,GACjC,OAAO,EAAE,CASX;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,EAChB,QAAQ,SAA0B,GACjC,MAAM,CAOR"}

package/dist/systems/fence/fence-centerline.js

@@ -0,0 +1,37 @@
+import { getWallCurveFrameAt, getWallCurveLength, sampleWallCenterline } from '../wall/wall-curve';
+import { getFenceSplineFrameAt, getFenceSplineLength, isSplineFence, sampleFenceSpline, } from './fence-spline';
+/**
+ * Unified fence centerline accessors. A fence is either:
+ *   - a spline fence (`path` of >= 2 control points) → smooth Catmull-Rom, or
+ *   - a straight / single-arc fence (`start`/`end` + optional `curveOffset`).
+ *
+ * These wrappers branch on `isSplineFence` and return the SAME shapes the wall
+ * arc helpers return, so every consumer (3D geometry, 2D floor-plan, length,
+ * handles) can sample the centerline without caring which kind it is. Wall arc
+ * math in `wall-curve.ts` is untouched — walls never carry a `path`.
+ */
+const DEFAULT_SAMPLE_SEGMENTS = 96;
+export function getFenceCenterlineFrameAt(fence, t) {
+    if (isSplineFence(fence) && fence.path) {
+        return getFenceSplineFrameAt(fence.path, t, fence.tangents);
+    }
+    return getWallCurveFrameAt(fence, t);
+}
+export function sampleFenceCenterline(fence, segments = DEFAULT_SAMPLE_SEGMENTS) {
+    if (isSplineFence(fence) && fence.path) {
+        // Spread the requested sample budget across the spans so a long path still
+        // reads smoothly without exploding the point count.
+        const spanCount = Math.max(1, fence.path.length - 1);
+        const perSpan = Math.max(2, Math.ceil(segments / spanCount));
+        return sampleFenceSpline(fence.path, fence.tangents, perSpan);
+    }
+    return sampleWallCenterline(fence, segments);
+}
+export function getFenceCenterlineLength(fence, segments = DEFAULT_SAMPLE_SEGMENTS) {
+    if (isSplineFence(fence) && fence.path) {
+        const spanCount = Math.max(1, fence.path.length - 1);
+        const perSpan = Math.max(2, Math.ceil(segments / spanCount));
+        return getFenceSplineLength(fence.path, fence.tangents, perSpan);
+    }
+    return getWallCurveLength(fence, segments);
+}

package/dist/systems/fence/fence-spline.d.ts

@@ -0,0 +1,39 @@
+import type { FenceNode } from '../../schema';
+import type { Point2D } from '../wall/wall-mitering';
+type FenceSplineLike = Pick<FenceNode, 'path'>;
+type TangentList = ReadonlyArray<readonly [number, number] | null> | undefined;
+export declare function isSplineFence(fence: FenceSplineLike): boolean;
+type CurveFrame = {
+    point: Point2D;
+    tangent: Point2D;
+    normal: Point2D;
+};
+/**
+ * OUT-handle offset vector for control point `index` — the stored tangent if
+ * the user has adjusted it, otherwise the automatic distance-aware tangent
+ * (endpoints duplicate the neighbour so the ends stay tangent to their single
+ * span). The IN handle is the negation of this.
+ *
+ * Exported so the editing UI can draw the tangent line / handle dots at the
+ * right place even before the user has dragged them.
+ */
+export declare function getFenceControlHandle(path: ReadonlyArray<readonly [number, number]>, tangents: TangentList, index: number): Point2D;
+export declare function getTwoPointFenceCurveTangents(path: ReadonlyArray<readonly [number, number]>): Array<[number, number] | null> | undefined;
+/**
+ * Sample the spline centerline into a polyline. Control points are honored as
+ * on-curve anchors; `segmentsPerSpan` controls smoothness between them.
+ * Returns `(segmentsPerSpan * spanCount) + 1` points, first == path[0],
+ * last == path[-1].
+ */
+export declare function sampleFenceSpline(path: ReadonlyArray<readonly [number, number]>, tangents?: TangentList, segmentsPerSpan?: number): Point2D[];
+/**
+ * Frame (point + tangent + normal) at parameter `t` in [0, 1] along the spline
+ * centerline. Same return shape as `getWallCurveFrameAt` so it is a drop-in for
+ * the arc branch. `t` is uniform over the sampled polyline (arc length is not
+ * reparameterised — adequate for marching posts / rails and far cheaper).
+ */
+export declare function getFenceSplineFrameAt(path: ReadonlyArray<readonly [number, number]>, t: number, tangents?: TangentList, segmentsPerSpan?: number): CurveFrame;
+/** Total polyline length of the sampled spline centerline. */
+export declare function getFenceSplineLength(path: ReadonlyArray<readonly [number, number]>, tangents?: TangentList, segmentsPerSpan?: number): number;
+export {};
+//# sourceMappingURL=fence-spline.d.ts.map

package/dist/systems/fence/fence-spline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fence-spline.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-spline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AA0BpD,KAAK,eAAe,GAAG,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;AAC9C,KAAK,WAAW,GAAG,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAA;AAE9E,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAE7D;AAED,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,MAAM,GACZ,OAAO,CAiCT;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC7C,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAyB5C;AAkBD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,QAAQ,CAAC,EAAE,WAAW,EACtB,eAAe,SAA4B,GAC1C,OAAO,EAAE,CA0BX;AA4CD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,CAAC,EAAE,MAAM,EACT,QAAQ,CAAC,EAAE,WAAW,EACtB,eAAe,SAA4B,GAC1C,UAAU,CAEZ;AAED,8DAA8D;AAC9D,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,QAAQ,CAAC,EAAE,WAAW,EACtB,eAAe,SAA4B,GAC1C,MAAM,CAOR"}

package/dist/systems/fence/fence-spline.js

@@ -0,0 +1,196 @@
+/**
+ * Pure 2D spline sampling for fences whose centerline is defined by a `path`
+ * of control points (the "flying path" curved fence).
+ *
+ * Each control point carries an OUT-handle offset vector. When the user has
+ * not adjusted it, the handle defaults to a distance-aware Catmull-Rom-style
+ * tangent: direction comes from neighbouring points, while length is capped by
+ * the shorter adjacent span. When the user drags a tangent handle (stored in
+ * `tangents[i]`), that point's handle becomes the stored vector and the IN
+ * handle is its mirror, so the curve stays smooth (C1) through the point but
+ * bends to taste. Each span is then a cubic Bézier between consecutive points
+ * using their handles.
+ *
+ * Lives in `@pascal-app/core` and imports NO Three.js — the same `CurveFrame`
+ * shape that `wall-curve.ts` returns (point / tangent / normal) is produced
+ * here so the spline branch is a drop-in for the arc branch in every consumer.
+ */
+const EPSILON = 1e-6;
+const DEFAULT_SEGMENTS_PER_SPAN = 32;
+const TWO_POINT_CURVE_SAGITTA_RATIO = 0.18;
+const TWO_POINT_CURVE_MIN_SAGITTA = 0.18;
+const TWO_POINT_CURVE_MAX_SAGITTA = 1.2;
+export function isSplineFence(fence) {
+    return Array.isArray(fence.path) && fence.path.length >= 2;
+}
+function toPoints(path) {
+    return path.map(([x, y]) => ({ x, y }));
+}
+function distance(a, b) {
+    return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+/**
+ * OUT-handle offset vector for control point `index` — the stored tangent if
+ * the user has adjusted it, otherwise the automatic distance-aware tangent
+ * (endpoints duplicate the neighbour so the ends stay tangent to their single
+ * span). The IN handle is the negation of this.
+ *
+ * Exported so the editing UI can draw the tangent line / handle dots at the
+ * right place even before the user has dragged them.
+ */
+export function getFenceControlHandle(path, tangents, index) {
+    const stored = tangents?.[index];
+    if (stored) {
+        return { x: stored[0], y: stored[1] };
+    }
+    const prev = path[index - 1] ?? path[index];
+    const next = path[index + 1] ?? path[index];
+    const prevDistance = distance({ x: path[index][0], y: path[index][1] }, {
+        x: prev[0],
+        y: prev[1],
+    });
+    const nextDistance = distance({ x: path[index][0], y: path[index][1] }, {
+        x: next[0],
+        y: next[1],
+    });
+    const handleLength = Math.min(prevDistance || nextDistance, nextDistance || prevDistance) / 3;
+    const vx = next[0] - prev[0];
+    const vy = next[1] - prev[1];
+    const len = Math.hypot(vx, vy);
+    if (len < EPSILON || handleLength < EPSILON) {
+        return { x: 0, y: 0 };
+    }
+    return {
+        x: (vx / len) * handleLength,
+        y: (vy / len) * handleLength,
+    };
+}
+export function getTwoPointFenceCurveTangents(path) {
+    if (path.length !== 2)
+        return undefined;
+    const start = path[0];
+    const end = path[1];
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const chordLength = Math.hypot(dx, dy);
+    if (chordLength < EPSILON)
+        return undefined;
+    const tangentX = dx / 3;
+    const tangentY = dy / 3;
+    const normalX = -dy / chordLength;
+    const normalY = dx / chordLength;
+    const sagitta = clamp(chordLength * TWO_POINT_CURVE_SAGITTA_RATIO, TWO_POINT_CURVE_MIN_SAGITTA, TWO_POINT_CURVE_MAX_SAGITTA);
+    const bendX = normalX * sagitta * (4 / 3);
+    const bendY = normalY * sagitta * (4 / 3);
+    return [
+        [tangentX + bendX, tangentY + bendY],
+        [tangentX - bendX, tangentY - bendY],
+    ];
+}
+function cubicBezier(p0, p1, p2, p3, u) {
+    const mu = 1 - u;
+    const a = mu * mu * mu;
+    const b = 3 * mu * mu * u;
+    const c = 3 * mu * u * u;
+    const d = u * u * u;
+    return {
+        x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,
+        y: a * p0.y + b * p1.y + c * p2.y + d * p3.y,
+    };
+}
+function hasAnyTangent(tangents) {
+    return Array.isArray(tangents) && tangents.some((t) => t != null);
+}
+/**
+ * Sample the spline centerline into a polyline. Control points are honored as
+ * on-curve anchors; `segmentsPerSpan` controls smoothness between them.
+ * Returns `(segmentsPerSpan * spanCount) + 1` points, first == path[0],
+ * last == path[-1].
+ */
+export function sampleFenceSpline(path, tangents, segmentsPerSpan = DEFAULT_SEGMENTS_PER_SPAN) {
+    const pts = toPoints(path);
+    if (pts.length === 0)
+        return [];
+    if (pts.length === 1)
+        return [pts[0]];
+    // Two points with no adjusted tangents is a straight segment.
+    if (pts.length === 2 && !hasAnyTangent(tangents))
+        return [pts[0], pts[1]];
+    const steps = Math.max(1, Math.floor(segmentsPerSpan));
+    const result = [pts[0]];
+    for (let i = 0; i < pts.length - 1; i += 1) {
+        const p1 = pts[i];
+        const p2 = pts[i + 1];
+        const outHandle = getFenceControlHandle(path, tangents, i);
+        const nextHandle = getFenceControlHandle(path, tangents, i + 1);
+        // Bézier controls: leave p1 along its OUT handle, arrive at p2 along its
+        // IN handle (= negated OUT handle).
+        const c1 = { x: p1.x + outHandle.x, y: p1.y + outHandle.y };
+        const c2 = { x: p2.x - nextHandle.x, y: p2.y - nextHandle.y };
+        for (let s = 1; s <= steps; s += 1) {
+            result.push(cubicBezier(p1, c1, c2, p2, s / steps));
+        }
+    }
+    return result;
+}
+function frameFromPolyline(points, t) {
+    if (points.length === 0) {
+        return {
+            point: { x: 0, y: 0 },
+            tangent: { x: 1, y: 0 },
+            normal: { x: 0, y: 1 },
+        };
+    }
+    if (points.length === 1) {
+        return {
+            point: points[0],
+            tangent: { x: 1, y: 0 },
+            normal: { x: 0, y: 1 },
+        };
+    }
+    const clamped = clamp01(t);
+    const lastIndex = points.length - 1;
+    const scaled = clamped * lastIndex;
+    const lower = Math.min(lastIndex - 1, Math.floor(scaled));
+    const upper = lower + 1;
+    const localU = scaled - lower;
+    const a = points[lower];
+    const b = points[upper];
+    const point = {
+        x: a.x + (b.x - a.x) * localU,
+        y: a.y + (b.y - a.y) * localU,
+    };
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len = Math.hypot(dx, dy);
+    const tangent = len < EPSILON ? { x: 1, y: 0 } : { x: dx / len, y: dy / len };
+    return {
+        point,
+        tangent,
+        normal: { x: -tangent.y, y: tangent.x },
+    };
+}
+/**
+ * Frame (point + tangent + normal) at parameter `t` in [0, 1] along the spline
+ * centerline. Same return shape as `getWallCurveFrameAt` so it is a drop-in for
+ * the arc branch. `t` is uniform over the sampled polyline (arc length is not
+ * reparameterised — adequate for marching posts / rails and far cheaper).
+ */
+export function getFenceSplineFrameAt(path, t, tangents, segmentsPerSpan = DEFAULT_SEGMENTS_PER_SPAN) {
+    return frameFromPolyline(sampleFenceSpline(path, tangents, segmentsPerSpan), t);
+}
+/** Total polyline length of the sampled spline centerline. */
+export function getFenceSplineLength(path, tangents, segmentsPerSpan = DEFAULT_SEGMENTS_PER_SPAN) {
+    const points = sampleFenceSpline(path, tangents, segmentsPerSpan);
+    let total = 0;
+    for (let i = 1; i < points.length; i += 1) {
+        total += distance(points[i - 1], points[i]);
+    }
+    return total;
+}

package/dist/systems/slab/slab-placement.d.ts

@@ -0,0 +1,11 @@
+import type { SlabNode } from '../../schema';
+/**
+ * Translate a solid slab's authored vertical interval onto a chosen base plane.
+ *
+ * `slab.elevation` is the authored top relative to the placement plane and
+ * `thickness` grows downward. Adding the base therefore preserves both the
+ * thickness and any intentional clearance in a preset. Recessed slabs keep
+ * their level-relative depth because their rim is defined by the level plane.
+ */
+export declare function resolveSlabPlacementElevation(slab: Pick<SlabNode, 'elevation' | 'recessed'>, baseElevation: number | null | undefined): number;
+//# sourceMappingURL=slab-placement.d.ts.map

package/dist/systems/slab/slab-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slab-placement.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-placement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,UAAU,CAAC,EAC9C,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACvC,MAAM,CAKR"}

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

@@ -0,0 +1,14 @@
+/**
+ * Translate a solid slab's authored vertical interval onto a chosen base plane.
+ *
+ * `slab.elevation` is the authored top relative to the placement plane and
+ * `thickness` grows downward. Adding the base therefore preserves both the
+ * thickness and any intentional clearance in a preset. Recessed slabs keep
+ * their level-relative depth because their rim is defined by the level plane.
+ */
+export function resolveSlabPlacementElevation(slab, baseElevation) {
+    if (slab.recessed || baseElevation == null || !Number.isFinite(baseElevation)) {
+        return slab.elevation;
+    }
+    return slab.elevation + baseElevation;
+}

package/dist/systems/slab/slab-support.d.ts

@@ -0,0 +1,137 @@
+import type { SlabNode, WallNode } from '../../schema';
+export type SlabElevationClamp = {
+    elevation: number;
+    clamped: boolean;
+};
+/**
+ * Clamp-never-ask upper bound for a slab's elevation. A plane-bound wall
+ * (no stored `height`) keeps its top at the storey plane, so a slab that
+ * rises past `storeyHeight - MIN_WALL_HEIGHT` while electing as that
+ * wall's base would squeeze the wall body below its minimum (and at the
+ * plane, to nothing). Walls with explicit heights don't constrain — their
+ * top rides the elected base, not the plane. Negative proposals (the
+ * drag-through-zero path that commits the `recessed` intent) pass
+ * through untouched: this is a purely numeric upper bound.
+ *
+ * The election runs against `levelSlabs` with `proposedElevation`
+ * substituted into `slab`, so a slab that would only WIN the election at
+ * the proposed elevation still clamps, and a slab out-elected by a
+ * sibling doesn't. Pure.
+ */
+export declare function clampSlabElevationForWalls(proposedElevation: number, slab: SlabNode, levelWalls: WallNode[], levelSlabs: readonly SlabNode[], storeyHeight: number): SlabElevationClamp;
+/**
+ * Static upper bound for a slab-elevation drag: probe the election with
+ * the slab raised above every sibling and the storey plane. If any
+ * plane-bound wall would elect it there, the drag may not pass
+ * `storeyHeight - MIN_WALL_HEIGHT`; otherwise it is unbounded above.
+ */
+export declare function getSlabElevationUpperBound(slab: SlabNode, levelWalls: WallNode[], levelSlabs: readonly SlabNode[], storeyHeight: number): number;
+/**
+ * Point-in-polygon test using ray casting algorithm.
+ */
+export declare function pointInPolygon(px: number, pz: number, polygon: Array<[number, number]>): boolean;
+export declare function pointOnPolygonBoundary(px: number, pz: number, polygon: Array<[number, number]>): boolean;
+export type WallOverlapInput = {
+    start: [number, number];
+    end: [number, number];
+    curveOffset?: number;
+    thickness?: number;
+};
+/**
+ * Test whether a wall overlaps a slab polygon along a segment of its length.
+ *
+ * The wall's centerline and both face lines are clipped against the polygon;
+ * the wall overlaps when the longest clipped inside-or-on-boundary length
+ * exceeds a threshold (5cm, halved for very short walls). Because interval
+ * midpoints classify "on the boundary" as inside explicitly (never by
+ * ray-cast tie-breaking), a wall sitting exactly on a slab edge resolves
+ * identically on every side of the slab.
+ *
+ * A wall that only touches the polygon at a point — a perpendicular wall
+ * butting into a room's edge, or a corner-to-corner touch — clips to ~zero
+ * length and does NOT overlap.
+ */
+export declare function wallOverlapsPolygon(startOrWall: [number, number] | WallOverlapInput, endOrPolygon: [number, number] | Array<[number, number]>, polygonArg?: Array<[number, number]>): boolean;
+/**
+ * {@link wallOverlapsPolygon} with the slab's stored holes subtracted from
+ * the covered length: a wall whose band only reaches the polygon inside a
+ * hole does not overlap. Hole boundaries keep coverage (rim convention —
+ * see {@link computeWallSlabSupport}). Polygon boundary contact counts as
+ * covered, so a wall sitting exactly on a slab edge resolves identically
+ * on every side of the slab. Pure.
+ */
+export declare function wallOverlapsSlabFootprint(wallLike: WallOverlapInput, polygon: Array<[number, number]>, holes?: ReadonlyArray<Array<[number, number]>>): boolean;
+/**
+ * Tolerance for the pointer-decided support cap: a slab still counts as
+ * "the surface you're pointing at (or below)" when its walking surface is
+ * within this many meters ABOVE the pointed elevation. Absorbs elevation
+ * noise between the ray hit and slab tops without letting a deck hanging
+ * clearly above the hit point capture the election. Defined here (rather
+ * than in the spatial-grid manager, which re-exports it) so the wall
+ * election below can honour the same cap without an import cycle.
+ */
+export declare const SUPPORT_ELEVATION_EPSILON = 0.05;
+/**
+ * Base elevation for a wall, decided by which slabs actually SUPPORT it.
+ *
+ * Support is measured as covered length: the wall's centerline and face
+ * lines are clipped against each slab's RENDERED footprint
+ * (`getRenderableSlabPolygon` with the level walls + siblings, not the
+ * stored polygon — legacy polygons stored at wall faces or with old
+ * baked offsets fall short of the wall body, but their band-adopted
+ * rendered edge reaches the wall's outer face) minus the slab's stored
+ * holes (holes are data, never render-offset). A slab supporting less
+ * than `WALL_SLAB_MIN_OVERLAP` of the wall is ignored entirely (point
+ * contact, endpoint grazes).
+ *
+ * Same-elevation slabs pool their coverage. `elevation` is elected from
+ * the wall's carrying profile: per arc segment, the highest support on
+ * each face, then the min across supported faces — so a slab that only
+ * brushes one face (e.g. an elevated deck adjacent along the outer face)
+ * never lifts the wall origin. The highest carrying elevation covering
+ * at least `WALL_SLAB_SUPPORT_MAJORITY` of the wall wins, or the
+ * best-covered carrying elevation when none reaches majority.
+ * `baseElevation` only fills down
+ * where a lower support remains exposed on a wall face after higher,
+ * overlapping support is accounted for. Coincident floor/platform slabs
+ * therefore keep the wall on the platform, while slabs on opposite wall
+ * sides bridge correctly. A slab touching only one endpoint never enters
+ * either result. Pure;
+ * exported for tests.
+ */
+export type WallSlabSupport = {
+    /** Existing wall-relative floor elevation used by hosted children and wall height. */
+    elevation: number;
+    /** Slab whose elevation won the election, or null when the wall has no support. */
+    electedSlabId: string | null;
+    /** Lowest exposed adjacent support; wall geometry fills down to this elevation. */
+    baseElevation: number;
+    /** Piecewise bottom elevation along the wall centerline, in normalized arc-length units. */
+    baseSegments: WallSlabSupportSegment[];
+};
+export type WallSlabSupportSegment = {
+    start: number;
+    end: number;
+    elevation: number;
+};
+/**
+ * `preferredSlabId` is a persisted support host (`wall.supportSlabId`):
+ * while that slab is still in the candidate set (still overlaps the wall
+ * band with enough covered length), the elected `elevation` is pinned to
+ * it instead of the majority/best-coverage election. `baseSegments` /
+ * `baseElevation` (fill-down) still derive from ALL supporting slabs
+ * unchanged. A preferred slab that no longer qualifies is silently
+ * ignored — deliberately never cleared here, so the host resumes if the
+ * slab's polygon returns (only slab deletion strips the stored field).
+ *
+ * `maxElevation` is the pointer-decided support cap (level-local Y, same
+ * semantics as the item election): when set, elevation groups whose
+ * walking surface sits above `maxElevation + SUPPORT_ELEVATION_EPSILON`
+ * are excluded from the majority/best election — a deck hanging above the
+ * surface the cursor ray actually hit never captures the elected base.
+ * `baseSegments` / `baseElevation` stay uncapped (geometry fill-down), and
+ * an explicit `preferredSlabId` still wins over the cap.
+ */
+export declare function computeWallSlabSupport(wallLike: WallOverlapInput, slabs: readonly SlabNode[], levelWalls: WallNode[], preferredSlabId?: string | null, maxElevation?: number | null): WallSlabSupport;
+export declare function computeWallSlabElevation(wallLike: WallOverlapInput, slabs: readonly SlabNode[], levelWalls: WallNode[]): number;
+//# sourceMappingURL=slab-support.d.ts.map

package/dist/systems/slab/slab-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slab-support.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-support.ts"],"names":[],"mappings":"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"}