@pascal-app/core 1.0.1 → 1.0.4

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

@@ -1 +1 @@
-{"version":3,"file":"elevator-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EAEX,QAAQ,EAET,MAAM,cAAc,CAAA;AA8JrB,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQ1C,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAmG5E"}
+{"version":3,"file":"elevator-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EAEX,QAAQ,EAET,MAAM,cAAc,CAAA;AA8JrB,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQ1C,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAiG5E"}

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

@@ -1,4 +1,4 @@
-import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync.js';
+import { resolveLevelId } from '../../lib/node-ancestry.js';
 import { resolveElevatorServiceLevels } from './elevator-service.js';
 const ELEVATOR_OPENING_PADDING = 0.08;
 const DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS = 0.09;
@@ -82,7 +82,7 @@ function getServedLevelRange(elevator, nodes) {
 }
 function getLevelNumber(levelId, nodes) {
     if (!levelId)
-        return undefined;
+        return;
     const node = nodes[levelId];
     return node?.type === 'level' ? node.level : undefined;
 }
@@ -161,8 +161,7 @@ export function syncAutoElevatorOpenings(nodes) {
             ...elevatorHoles.map((hole) => hole.metadata),
             ...stairHoles.map((hole) => ({ ...hole.metadata })),
         ];
-        if (!polygonsEqual(existingHoles, nextHoles) ||
-            !metadataEqual(existingMetadata, nextMetadata)) {
+        if (!(polygonsEqual(existingHoles, nextHoles) && metadataEqual(existingMetadata, nextMetadata))) {
             updates.push({
                 id: slab.id,
                 data: {
@@ -203,8 +202,7 @@ export function syncAutoElevatorOpenings(nodes) {
             ...elevatorHoles.map((hole) => hole.metadata),
             ...stairHoles.map((hole) => ({ ...hole.metadata })),
         ];
-        if (!polygonsEqual(existingHoles, nextHoles) ||
-            !metadataEqual(existingMetadata, nextMetadata)) {
+        if (!(polygonsEqual(existingHoles, nextHoles) && metadataEqual(existingMetadata, nextMetadata))) {
             updates.push({
                 id: ceiling.id,
                 data: {

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":"AAmCA,wBAAgB,6BAA6B,eAsB5C;AAED,eAAO,MAAM,qBAAqB,YAIjC,CAAA"}
+{"version":3,"file":"elevator-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-system.tsx"],"names":[],"mappings":"AAsCA,wBAAgB,6BAA6B,eAyB5C;AAED,eAAO,MAAM,qBAAqB,YAIjC,CAAA"}

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

@@ -1,8 +1,11 @@
 'use client';
 import { useEffect } from 'react';
+import { structureChangeBatch } from '../../commands/structure/shared.js';
 import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control.js';
+import { isHydrationNormalization } from '../../store/scene-hydration.js';
 import useScene from '../../store/use-scene.js';
-import { syncAutoElevatorOpenings } from './elevator-opening-sync.js';
+import { planOwnedFloorOpenings } from '../owned-floor-openings.js';
+import { reconcileOwnedFloorOpeningChanges } from '../reconcile-owned-floor-openings.js';
 function isOpeningRelevantNode(node) {
     return (node?.type === 'building' ||
         node?.type === 'ceiling' ||
@@ -26,26 +29,29 @@ function hasOpeningRelevantNodeChange(nextNodes, prevNodes) {
 }
 export function initializeElevatorOpeningSync() {
     let syncingAutoOpenings = false;
-    const applyUpdates = (updates) => {
-        if (updates.length === 0)
+    const applyChanges = (skipExistingSurfaces = false) => {
+        const changes = planOwnedFloorOpenings(useScene.getState().nodes, { skipExistingSurfaces });
+        if (changes.length === 0)
             return;
         syncingAutoOpenings = true;
         pauseSceneHistory(useScene);
         try {
-            useScene.getState().updateNodes(updates);
+            const before = useScene.getState().nodes;
+            useScene.getState().applyNodeChanges(structureChangeBatch(changes));
+            reconcileOwnedFloorOpeningChanges(before, changes);
         }
         finally {
             resumeSceneHistory(useScene);
             syncingAutoOpenings = false;
         }
     };
-    applyUpdates(syncAutoElevatorOpenings(useScene.getState().nodes));
+    applyChanges(true);
     return useScene.subscribe((state, prevState) => {
         if (syncingAutoOpenings)
             return;
         if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
             return;
-        applyUpdates(syncAutoElevatorOpenings(state.nodes));
+        applyChanges(isHydrationNormalization() || state.hydrationId !== prevState.hydrationId);
     });
 }
 export const ElevatorOpeningSystem = () => {

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,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,CA6CA"}
+{"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;AAkCD,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,CA6CA"}

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

@@ -1,8 +1,13 @@
 import { getLevelElevations } from '../../services/storey.js';
 function getBuildingLevels(elevator, nodes) {
-    const building = elevator.parentId && nodes[elevator.parentId]?.type === 'building'
-        ? nodes[elevator.parentId]
-        : null;
+    const parent = elevator.parentId ? nodes[elevator.parentId] : undefined;
+    // Older saves attach elevators to a level. Opening queries must agree before
+    // and after client hydration reparents them to the owning building.
+    const building = parent?.type === 'level'
+        ? parent.parentId && nodes[parent.parentId]?.type === 'building'
+            ? nodes[parent.parentId]
+            : Object.values(nodes).find((node) => node.type === 'building' && node.children.includes(parent.id))
+        : parent;
     if (building?.type !== 'building')
         return [];
     return building.children

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

@@ -1 +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"}
+{"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,CAMjF;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

@@ -13,7 +13,8 @@ import { getFenceSplineFrameAt, getFenceSplineLength, isSplineFence, sampleFence
 const DEFAULT_SAMPLE_SEGMENTS = 96;
 export function getFenceCenterlineFrameAt(fence, t) {
     if (isSplineFence(fence) && fence.path) {
-        return getFenceSplineFrameAt(fence.path, t, fence.tangents);
+        const perSpan = Math.max(32, Math.ceil(DEFAULT_SAMPLE_SEGMENTS / (fence.path.length - 1)));
+        return getFenceSplineFrameAt(fence.path, t, fence.tangents, perSpan, fence.spanModes);
     }
     return getWallCurveFrameAt(fence, t);
 }
@@ -22,16 +23,16 @@ export function sampleFenceCenterline(fence, segments = DEFAULT_SAMPLE_SEGMENTS)
         // 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);
+        const perSpan = Math.max(32, Math.ceil(segments / spanCount));
+        return sampleFenceSpline(fence.path, fence.tangents, perSpan, fence.spanModes);
     }
     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);
+        const perSpan = Math.max(32, Math.ceil(segments / spanCount));
+        return getFenceSplineLength(fence.path, fence.tangents, perSpan, fence.spanModes);
     }
     return getWallCurveLength(fence, segments);
 }

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

@@ -0,0 +1,36 @@
+import type { z } from 'zod';
+import type { AnyNode, FenceFeatureNode, FenceNode } from '../../schema/index.js';
+import type { FenceFeature } from '../../schema/nodes/fence.js';
+export type FenceFeatureData = z.infer<typeof FenceFeature>;
+export type FenceWithFeatures = FenceNode & {
+    features?: FenceFeatureData[];
+};
+export type ResolvedFenceFeature = FenceFeatureData & {
+    startT: number;
+    endT: number;
+    centerT: number;
+};
+export declare function fenceFeaturePlacementIssue(fence: FenceWithFeatures, feature: FenceFeatureData): 'width' | 'end' | 'overlap' | null;
+export declare function canPlaceFenceFeature(fence: FenceWithFeatures, feature: FenceFeatureData): boolean;
+export declare function resolveFenceFeatures(fence: FenceWithFeatures): ResolvedFenceFeature[];
+export declare function projectPointToFence(fence: FenceNode, point: readonly [number, number]): {
+    center: number;
+    distance: number;
+};
+export declare function getFenceGateLeaves(fence: FenceNode, feature: ResolvedFenceFeature): {
+    hinge: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    rotation: number;
+    closedAngle: number;
+    end: {
+        x: number;
+        y: number;
+    };
+}[];
+export declare function isFenceFeatureNode(node: AnyNode | undefined): node is FenceFeatureNode;
+export declare function fenceFeatureData(node: FenceFeatureNode): FenceFeatureData;
+export declare function fenceWithFeatures(fence: FenceWithFeatures, children: readonly (AnyNode | undefined)[]): FenceWithFeatures;
+//# sourceMappingURL=fence-features.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fence-features.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-features.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAO5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAC3D,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG;IAAE,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAA;CAAE,CAAA;AAC7E,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG;IACpD,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,gBAAgB,GACxB,OAAO,GAAG,KAAK,GAAG,SAAS,GAAG,IAAI,CAkBpC;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAEjG;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,oBAAoB,EAAE,CAYrF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;;;EAwBrF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,oBAAoB;;;;;;;;;;;;IA+BjF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,IAAI,gBAAgB,CAEtF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB,CAEzE;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,SAAS,CAAC,OAAO,GAAG,SAAS,CAAC,EAAE,GACzC,iBAAiB,CAWnB"}

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

@@ -0,0 +1,105 @@
+import { getFenceCenterlineFrameAt, getFenceCenterlineLength, sampleFenceCenterline, } from './fence-centerline.js';
+export function fenceFeaturePlacementIssue(fence, feature) {
+    const length = getFenceCenterlineLength(fence);
+    const margin = Math.max(fence.postSize / 2, 0.04);
+    const start = feature.center - feature.width / 2;
+    const end = feature.center + feature.width / 2;
+    const gap = Math.max(fence.postSize, 0.05);
+    if (feature.width < 0.35 || !Number.isFinite(start) || !Number.isFinite(end))
+        return 'width';
+    if (start < margin || end > length - margin)
+        return 'end';
+    if ((fence.features ?? []).some((other) => other.id !== feature.id &&
+        start < other.center + other.width / 2 + gap &&
+        end > other.center - other.width / 2 - gap))
+        return 'overlap';
+    return null;
+}
+export function canPlaceFenceFeature(fence, feature) {
+    return fenceFeaturePlacementIssue(fence, feature) === null;
+}
+export function resolveFenceFeatures(fence) {
+    const length = getFenceCenterlineLength(fence);
+    if (length < 0.35)
+        return [];
+    return [...(fence.features ?? [])]
+        .sort((a, b) => a.center - b.center)
+        .filter((feature) => canPlaceFenceFeature(fence, feature))
+        .map((feature) => ({
+        ...feature,
+        startT: (feature.center - feature.width / 2) / length,
+        endT: (feature.center + feature.width / 2) / length,
+        centerT: feature.center / length,
+    }));
+}
+export function projectPointToFence(fence, point) {
+    const points = sampleFenceCenterline(fence);
+    let traversed = 0;
+    let distance = Infinity;
+    let center = 0;
+    for (let index = 1; index < points.length; index += 1) {
+        const a = points[index - 1];
+        const b = points[index];
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const length = Math.hypot(dx, dy);
+        if (length < 1e-8)
+            continue;
+        const t = Math.max(0, Math.min(1, ((point[0] - a.x) * dx + (point[1] - a.y) * dy) / (length * length)));
+        const nextDistance = Math.hypot(point[0] - a.x - dx * t, point[1] - a.y - dy * t);
+        if (nextDistance < distance) {
+            distance = nextDistance;
+            center = traversed + length * t;
+        }
+        traversed += length;
+    }
+    return { center, distance };
+}
+export function getFenceGateLeaves(fence, feature) {
+    const a = getFenceCenterlineFrameAt(fence, feature.startT).point;
+    const b = getFenceCenterlineFrameAt(fence, feature.endT).point;
+    const length = Math.hypot(b.x - a.x, b.y - a.y);
+    const ux = (b.x - a.x) / Math.max(length, 1e-6);
+    const uz = (b.y - a.y) / Math.max(length, 1e-6);
+    const gap = Math.min(Math.max(fence.postSize / 2 + 0.025, 0.06), length * 0.15);
+    const usable = Math.max(0.05, length - 2 * gap);
+    const double = feature.leafType === 'double';
+    const split = feature.leafSplit ?? 0.5;
+    const angle = (((feature.openAngle ?? 0) * Math.PI) / 180) * (feature.swing === 'outward' ? -1 : 1);
+    return (double ? ['left', 'right'] : [feature.hinge ?? 'left']).map((side) => {
+        const sign = side === 'left' ? 1 : -1;
+        const hinge = side === 'left'
+            ? { x: a.x + ux * gap, y: a.y + uz * gap }
+            : { x: b.x - ux * gap, y: b.y - uz * gap };
+        const width = double
+            ? Math.max(0.025, usable * (side === 'left' ? split : 1 - split) - 0.015)
+            : usable;
+        const closedAngle = Math.atan2(uz * sign, ux * sign);
+        const rotation = closedAngle + angle * sign;
+        return {
+            hinge,
+            width,
+            rotation,
+            closedAngle,
+            end: { x: hinge.x + Math.cos(rotation) * width, y: hinge.y + Math.sin(rotation) * width },
+        };
+    });
+}
+export function isFenceFeatureNode(node) {
+    return node?.type === 'fence-gate' || node?.type === 'fence-opening';
+}
+export function fenceFeatureData(node) {
+    return { ...node, kind: node.type === 'fence-gate' ? 'gate' : 'opening' };
+}
+export function fenceWithFeatures(fence, children) {
+    return {
+        ...fence,
+        features: [
+            ...children
+                .filter(isFenceFeatureNode)
+                .filter((n) => n.visible !== false)
+                .map(fenceFeatureData),
+            ...(fence.features ?? []),
+        ],
+    };
+}

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

@@ -2,6 +2,9 @@ import type { FenceNode } from '../../schema/index.js';
 import type { Point2D } from '../wall/wall-mitering.js';
 type FenceSplineLike = Pick<FenceNode, 'path'>;
 type TangentList = ReadonlyArray<readonly [number, number] | null> | undefined;
+export type FenceSpanMode = 'straight' | 'curve';
+type SpanModes = ReadonlyArray<FenceSpanMode> | undefined;
+export declare function getFenceSpanMode(path: ReadonlyArray<readonly [number, number]>, tangents: TangentList, spanModes: SpanModes, index: number): FenceSpanMode;
 export declare function isSplineFence(fence: FenceSplineLike): boolean;
 type CurveFrame = {
     point: Point2D;
@@ -25,15 +28,15 @@ export declare function getTwoPointFenceCurveTangents(path: ReadonlyArray<readon
  * 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[];
+export declare function sampleFenceSpline(path: ReadonlyArray<readonly [number, number]>, tangents?: TangentList, segmentsPerSpan?: number, spanModes?: SpanModes): 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).
+ * the arc branch. `t` measures a fraction of the sampled curve's length so
+ * spacing stays consistent even when control points are unevenly distributed.
  */
-export declare function getFenceSplineFrameAt(path: ReadonlyArray<readonly [number, number]>, t: number, tangents?: TangentList, segmentsPerSpan?: number): CurveFrame;
+export declare function getFenceSplineFrameAt(path: ReadonlyArray<readonly [number, number]>, t: number, tangents?: TangentList, segmentsPerSpan?: number, spanModes?: SpanModes): CurveFrame;
 /** Total polyline length of the sampled spline centerline. */
-export declare function getFenceSplineLength(path: ReadonlyArray<readonly [number, number]>, tangents?: TangentList, segmentsPerSpan?: number): number;
+export declare function getFenceSplineLength(path: ReadonlyArray<readonly [number, number]>, tangents?: TangentList, segmentsPerSpan?: number, spanModes?: SpanModes): number;
 export {};
 //# sourceMappingURL=fence-spline.d.ts.map

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

@@ -1 +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"}
+{"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;AAC9E,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,OAAO,CAAA;AAChD,KAAK,SAAS,GAAG,aAAa,CAAC,aAAa,CAAC,GAAG,SAAS,CAAA;AAEzD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,GACZ,aAAa,CAIf;AAED,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,EAC3C,SAAS,CAAC,EAAE,SAAS,GACpB,OAAO,EAAE,CA+BX;AAwED;;;;;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,EAC3C,SAAS,CAAC,EAAE,SAAS,GACpB,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,EAC3C,SAAS,CAAC,EAAE,SAAS,GACpB,MAAM,CAOR"}

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

@@ -20,6 +20,9 @@ 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 getFenceSpanMode(path, tangents, spanModes, index) {
+    return (spanModes?.[index] ?? (path.length === 2 && !hasAnyTangent(tangents) ? 'straight' : 'curve'));
+}
 export function isSplineFence(fence) {
     return Array.isArray(fence.path) && fence.path.length >= 2;
 }
@@ -113,20 +116,24 @@ function hasAnyTangent(tangents) {
  * Returns `(segmentsPerSpan * spanCount) + 1` points, first == path[0],
  * last == path[-1].
  */
-export function sampleFenceSpline(path, tangents, segmentsPerSpan = DEFAULT_SEGMENTS_PER_SPAN) {
+export function sampleFenceSpline(path, tangents, segmentsPerSpan = DEFAULT_SEGMENTS_PER_SPAN, spanModes) {
     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))
+    if (pts.length === 2 && getFenceSpanMode(path, tangents, spanModes, 0) === 'straight')
         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];
+        if (getFenceSpanMode(path, tangents, spanModes, i) === 'straight') {
+            result.push(p2);
+            continue;
+        }
         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
@@ -154,22 +161,50 @@ function frameFromPolyline(points, t) {
             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 lengths = points.slice(1).map((point, index) => distance(points[index], point));
+    const totalLength = lengths.reduce((sum, length) => sum + length, 0);
+    const targetDistance = clamp01(t) * totalLength;
+    let lower = 0;
+    let traversed = 0;
+    while (lower < lengths.length - 1 && traversed + lengths[lower] < targetDistance) {
+        traversed += lengths[lower];
+        lower += 1;
+    }
+    while (lower < lengths.length - 1 && lengths[lower] < EPSILON)
+        lower += 1;
     const upper = lower + 1;
-    const localU = scaled - lower;
+    const localU = lengths[lower] < EPSILON ? 0 : clamp01((targetDistance - traversed) / lengths[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 directionAt = (index) => {
+        let before = index - 1;
+        let after = index + 1;
+        while (before >= 0 && distance(points[before], points[index]) < EPSILON)
+            before -= 1;
+        while (after < points.length && distance(points[after], points[index]) < EPSILON)
+            after += 1;
+        const current = points[index];
+        const previous = points[Math.max(0, before)];
+        const next = points[Math.min(points.length - 1, after)];
+        const incomingLength = distance(previous, current);
+        const outgoingLength = distance(current, next);
+        const dx = (current.x - previous.x) / Math.max(incomingLength, EPSILON) +
+            (next.x - current.x) / Math.max(outgoingLength, EPSILON);
+        const dy = (current.y - previous.y) / Math.max(incomingLength, EPSILON) +
+            (next.y - current.y) / Math.max(outgoingLength, EPSILON);
+        const length = Math.hypot(dx, dy);
+        return length < EPSILON ? { x: 1, y: 0 } : { x: dx / length, y: dy / length };
+    };
+    const startDirection = directionAt(lower);
+    const endDirection = directionAt(upper);
+    const dx = startDirection.x * (1 - localU) + endDirection.x * localU;
+    const dy = startDirection.y * (1 - localU) + endDirection.y * localU;
     const len = Math.hypot(dx, dy);
-    const tangent = len < EPSILON ? { x: 1, y: 0 } : { x: dx / len, y: dy / len };
+    const tangent = len < EPSILON ? startDirection : { x: dx / len, y: dy / len };
     return {
         point,
         tangent,
@@ -179,15 +214,15 @@ function frameFromPolyline(points, t) {
 /**
  * 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).
+ * the arc branch. `t` measures a fraction of the sampled curve's length so
+ * spacing stays consistent even when control points are unevenly distributed.
  */
-export function getFenceSplineFrameAt(path, t, tangents, segmentsPerSpan = DEFAULT_SEGMENTS_PER_SPAN) {
-    return frameFromPolyline(sampleFenceSpline(path, tangents, segmentsPerSpan), t);
+export function getFenceSplineFrameAt(path, t, tangents, segmentsPerSpan = DEFAULT_SEGMENTS_PER_SPAN, spanModes) {
+    return frameFromPolyline(sampleFenceSpline(path, tangents, segmentsPerSpan, spanModes), 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);
+export function getFenceSplineLength(path, tangents, segmentsPerSpan = DEFAULT_SEGMENTS_PER_SPAN, spanModes) {
+    const points = sampleFenceSpline(path, tangents, segmentsPerSpan, spanModes);
     let total = 0;
     for (let i = 1; i < points.length; i += 1) {
         total += distance(points[i - 1], points[i]);

package/dist/systems/owned-floor-openings.d.ts

@@ -0,0 +1,9 @@
+import type { NodePatch } from '../lib/structure-kernel.js';
+import type { AnyNode } from '../schema/index.js';
+export declare function planOwnedFloorOpenings(nodes: Record<string, AnyNode>, options?: {
+    ownerIds?: ReadonlySet<string>;
+    skipExistingSurfaces?: boolean;
+    enforceReach?: boolean;
+    materializedNodes?: Record<string, AnyNode>;
+}): NodePatch[];
+//# sourceMappingURL=owned-floor-openings.d.ts.map

package/dist/systems/owned-floor-openings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owned-floor-openings.d.ts","sourceRoot":"","sources":["../../src/systems/owned-floor-openings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,OAAO,EAAoD,MAAM,WAAW,CAAA;AA6G1F,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC9B,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACvC,GACL,SAAS,EAAE,CA2Qb"}