@pascal-app/core 0.8.0 → 0.9.2

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

@@ -0,0 +1,225 @@
+import { useInteractive } from '../../store/use-interactive';
+import useScene from '../../store/use-scene';
+import { resolveElevatorLevels } from './elevator-service';
+const EPSILON = 0.001;
+function moveToward(current, target, maxDelta) {
+    const delta = target - current;
+    if (Math.abs(delta) <= maxDelta)
+        return target;
+    return current + Math.sign(delta) * maxDelta;
+}
+export function createElevatorInteractiveState(levelId, carY) {
+    return {
+        currentLevelId: levelId,
+        targetLevelId: null,
+        carY,
+        doorOpen: 0,
+        phase: 'idle',
+        phaseStartedAt: null,
+        queue: [],
+        requestedStops: [],
+    };
+}
+function getInitialElevatorState(elevatorId, nodes) {
+    const node = nodes[elevatorId];
+    if (node?.type !== 'elevator')
+        return null;
+    const { defaultEntry } = resolveElevatorLevels(node, nodes);
+    if (!defaultEntry)
+        return null;
+    return createElevatorInteractiveState(defaultEntry.id, defaultEntry.baseY);
+}
+function ensureElevatorState(elevatorId, nodes) {
+    const interactive = useInteractive.getState();
+    const existing = interactive.elevators[elevatorId];
+    if (existing)
+        return existing;
+    const initial = getInitialElevatorState(elevatorId, nodes);
+    if (!initial)
+        return null;
+    interactive.initElevator(elevatorId, initial.currentLevelId, initial.carY);
+    return initial;
+}
+export function queueElevatorRequest(state, levelId) {
+    const isAlreadyQueued = state.queue.includes(levelId) || state.targetLevelId === levelId;
+    if (isAlreadyQueued)
+        return state;
+    return {
+        ...state,
+        queue: [...state.queue, levelId],
+        requestedStops: state.requestedStops.includes(levelId)
+            ? state.requestedStops
+            : [...state.requestedStops, levelId],
+    };
+}
+export function openElevatorDoorState(state) {
+    if (!state.currentLevelId || state.phase === 'moving')
+        return state;
+    return {
+        ...state,
+        phase: 'opening',
+        phaseStartedAt: null,
+    };
+}
+export function requestElevatorLevel(elevatorId, levelId) {
+    const nodes = useScene.getState().nodes;
+    const current = ensureElevatorState(elevatorId, nodes);
+    if (!current)
+        return;
+    const next = queueElevatorRequest(current, levelId);
+    if (next === current)
+        return;
+    useInteractive.getState().setElevatorState(elevatorId, next);
+}
+export function openElevatorDoor(elevatorId) {
+    const nodes = useScene.getState().nodes;
+    const current = ensureElevatorState(elevatorId, nodes);
+    if (!current)
+        return;
+    const next = openElevatorDoorState(current);
+    if (next === current)
+        return;
+    useInteractive.getState().setElevatorState(elevatorId, next);
+}
+export function stepElevatorRuntimeState({ defaultEntry, delta, elevator, entries, now, state, }) {
+    const currentEntry = entries.find((entry) => entry.id === state.currentLevelId) ?? defaultEntry;
+    if (currentEntry.id !== state.currentLevelId) {
+        return {
+            ...state,
+            currentLevelId: currentEntry.id,
+            carY: currentEntry.baseY,
+            targetLevelId: null,
+            phase: 'idle',
+            phaseStartedAt: null,
+            queue: [],
+            requestedStops: [],
+            doorOpen: 0,
+        };
+    }
+    const targetEntry = state.targetLevelId
+        ? entries.find((entry) => entry.id === state.targetLevelId)
+        : state.queue[0]
+            ? entries.find((entry) => entry.id === state.queue[0])
+            : null;
+    const doorDurationMs = Math.max(elevator.doorDurationMs ?? 900, 1);
+    const doorStep = (delta * 1000) / doorDurationMs;
+    switch (state.phase) {
+        case 'idle': {
+            const nextLevelId = state.queue[0] ?? null;
+            if (!nextLevelId) {
+                if (state.doorOpen > EPSILON) {
+                    return {
+                        ...state,
+                        doorOpen: Math.max(0, state.doorOpen - doorStep),
+                    };
+                }
+                if (state.requestedStops.length === 0)
+                    return state;
+                return {
+                    ...state,
+                    requestedStops: [],
+                };
+            }
+            return {
+                ...state,
+                targetLevelId: nextLevelId,
+                phase: state.doorOpen > EPSILON
+                    ? 'closing'
+                    : nextLevelId === state.currentLevelId
+                        ? 'opening'
+                        : 'moving',
+                phaseStartedAt: now,
+            };
+        }
+        case 'closing': {
+            const doorOpen = Math.max(0, state.doorOpen - doorStep);
+            return {
+                ...state,
+                doorOpen,
+                phase: doorOpen <= EPSILON ? (state.targetLevelId ? 'moving' : 'idle') : 'closing',
+                phaseStartedAt: doorOpen <= EPSILON ? now : state.phaseStartedAt,
+            };
+        }
+        case 'moving': {
+            if (!targetEntry) {
+                return {
+                    ...state,
+                    targetLevelId: null,
+                    phase: 'idle',
+                    queue: [],
+                    requestedStops: [],
+                };
+            }
+            const speed = Math.max(elevator.speed ?? 2.2, 0.1);
+            const nextY = moveToward(state.carY, targetEntry.baseY, speed * delta);
+            const arrived = Math.abs(nextY - targetEntry.baseY) <= EPSILON;
+            return {
+                ...state,
+                carY: nextY,
+                currentLevelId: arrived ? targetEntry.id : state.currentLevelId,
+                phase: arrived ? 'opening' : 'moving',
+                phaseStartedAt: arrived ? now : state.phaseStartedAt,
+            };
+        }
+        case 'opening': {
+            const doorOpen = Math.min(1, state.doorOpen + doorStep);
+            return {
+                ...state,
+                doorOpen,
+                phase: doorOpen >= 1 - EPSILON ? 'open' : 'opening',
+                phaseStartedAt: doorOpen >= 1 - EPSILON ? now : state.phaseStartedAt,
+                targetLevelId: doorOpen >= 1 - EPSILON ? null : state.targetLevelId,
+                queue: doorOpen >= 1 - EPSILON && state.queue[0] === state.currentLevelId
+                    ? state.queue.slice(1)
+                    : state.queue,
+            };
+        }
+        case 'open': {
+            const elapsed = now - (state.phaseStartedAt ?? now);
+            if (elapsed < Math.max(elevator.dwellMs ?? 1400, 0))
+                return state;
+            return {
+                ...state,
+                phase: 'closing',
+                phaseStartedAt: now,
+                targetLevelId: state.queue[0] ?? null,
+            };
+        }
+    }
+}
+export function stepElevatorRuntimes(now, delta) {
+    const nodes = useScene.getState().nodes;
+    const interactive = useInteractive.getState();
+    for (const elevatorId of Object.keys(interactive.elevators)) {
+        const typedElevatorId = elevatorId;
+        if (nodes[typedElevatorId]?.type !== 'elevator') {
+            interactive.removeElevator(typedElevatorId);
+        }
+    }
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'elevator')
+            continue;
+        const elevatorId = node.id;
+        const { entries, defaultEntry } = resolveElevatorLevels(node, nodes);
+        if (!defaultEntry)
+            continue;
+        const state = useInteractive.getState().elevators[elevatorId];
+        if (!state) {
+            useInteractive
+                .getState()
+                .initElevator(elevatorId, defaultEntry.id, defaultEntry.baseY);
+            continue;
+        }
+        const next = stepElevatorRuntimeState({
+            defaultEntry,
+            delta,
+            elevator: node,
+            entries,
+            now,
+            state,
+        });
+        if (next !== state) {
+            useInteractive.getState().setElevatorState(elevatorId, next);
+        }
+    }
+}

package/dist/systems/elevator/elevator-runtime.test.d.ts

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

package/dist/systems/elevator/elevator-runtime.test.d.ts.map

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

package/dist/systems/elevator/elevator-runtime.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'bun:test';
+import { ElevatorNode } from '../../schema';
+import { createElevatorInteractiveState, openElevatorDoorState, queueElevatorRequest, stepElevatorRuntimeState, } from './elevator-runtime';
+const groundLevelId = 'level_ground';
+const upperLevelId = 'level_upper';
+const entries = [
+    { id: groundLevelId, label: '0', baseY: 0 },
+    { id: upperLevelId, label: '1', baseY: 2.5 },
+];
+const elevator = ElevatorNode.parse({
+    speed: 10,
+    doorDurationMs: 100,
+    dwellMs: 0,
+});
+describe('elevator runtime helpers', () => {
+    test('queues level requests without duplicating the target', () => {
+        const state = createElevatorInteractiveState(groundLevelId, 0);
+        const queued = queueElevatorRequest(state, upperLevelId);
+        const duplicated = queueElevatorRequest(queued, upperLevelId);
+        expect(queued.queue).toEqual([upperLevelId]);
+        expect(queued.requestedStops).toEqual([upperLevelId]);
+        expect(duplicated.queue).toEqual([upperLevelId]);
+        expect(duplicated.requestedStops).toEqual([upperLevelId]);
+    });
+    test('opens doors only when the elevator is not moving', () => {
+        const idle = createElevatorInteractiveState(groundLevelId, 0);
+        const moving = { ...idle, phase: 'moving' };
+        expect(openElevatorDoorState(idle).phase).toBe('opening');
+        expect(openElevatorDoorState(moving)).toBe(moving);
+    });
+    test('moves to a queued level and clears the served request on arrival', () => {
+        const queued = queueElevatorRequest(createElevatorInteractiveState(groundLevelId, 0), upperLevelId);
+        const moving = stepElevatorRuntimeState({
+            defaultEntry: entries[0],
+            delta: 0.016,
+            elevator,
+            entries,
+            now: 0,
+            state: queued,
+        });
+        const arrived = stepElevatorRuntimeState({
+            defaultEntry: entries[0],
+            delta: 1,
+            elevator,
+            entries,
+            now: 100,
+            state: moving,
+        });
+        const open = stepElevatorRuntimeState({
+            defaultEntry: entries[0],
+            delta: 1,
+            elevator,
+            entries,
+            now: 200,
+            state: arrived,
+        });
+        expect(moving.phase).toBe('moving');
+        expect(arrived.currentLevelId).toBe(upperLevelId);
+        expect(arrived.phase).toBe('opening');
+        expect(open.phase).toBe('open');
+        expect(open.queue).toEqual([]);
+        expect(open.requestedStops).toEqual([upperLevelId]);
+    });
+});

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

@@ -0,0 +1,19 @@
+import type { AnyNode, ElevatorNode, LevelNode } from '../../schema';
+export declare const DEFAULT_ELEVATOR_LEVEL_HEIGHT = 2.5;
+export type ElevatorLevelEntry = {
+    id: LevelNode['id'];
+    label: string;
+    baseY: number;
+};
+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;
+    shaftBaseY: number;
+    shaftTopY: number;
+    totalHeight: number;
+};
+//# sourceMappingURL=elevator-service.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,111 @@
+export const DEFAULT_ELEVATOR_LEVEL_HEIGHT = 2.5;
+function getBuildingLevels(elevator, nodes) {
+    const building = elevator.parentId && nodes[elevator.parentId]?.type === 'building'
+        ? nodes[elevator.parentId]
+        : null;
+    if (building?.type !== 'building')
+        return [];
+    return building.children
+        .map((childId) => nodes[childId])
+        .filter((node) => node?.type === 'level')
+        .sort((left, right) => left.level - right.level);
+}
+function findLevelIndex(levels, levelId) {
+    if (!levelId)
+        return -1;
+    return levels.findIndex((level) => level.id === levelId);
+}
+function getDefaultToIndex(levels, fromIndex) {
+    if (levels.length === 0)
+        return -1;
+    if (fromIndex < 0)
+        return Math.min(1, levels.length - 1);
+    return Math.min(fromIndex + 1, levels.length - 1);
+}
+export function resolveElevatorBuildingLevels(elevator, nodes) {
+    return getBuildingLevels(elevator, nodes);
+}
+export function resolveElevatorServiceLevelIds(elevator, nodes) {
+    return resolveElevatorServiceLevels(elevator, nodes).map((level) => level.id);
+}
+export function resolveElevatorServiceLevels(elevator, nodes) {
+    const levels = getBuildingLevels(elevator, nodes);
+    if (levels.length === 0)
+        return [];
+    const hasServiceBounds = Boolean(elevator.fromLevelId || elevator.toLevelId);
+    let legacyServedLevels = [];
+    if (!hasServiceBounds && elevator.servedLevelIds && elevator.servedLevelIds.length > 0) {
+        const servedIds = new Set(elevator.servedLevelIds);
+        legacyServedLevels = levels.filter((level) => servedIds.has(level.id));
+    }
+    const legacyFromLevelId = legacyServedLevels[0]?.id ?? null;
+    const legacyToLevelId = legacyServedLevels[legacyServedLevels.length - 1]?.id ?? null;
+    const explicitFromIndex = findLevelIndex(levels, elevator.fromLevelId ?? legacyFromLevelId);
+    const defaultFromIndex = findLevelIndex(levels, elevator.defaultLevelId);
+    const fromIndex = explicitFromIndex >= 0 ? explicitFromIndex : Math.max(defaultFromIndex, 0);
+    const toIndex = findLevelIndex(levels, elevator.toLevelId ?? legacyToLevelId);
+    const resolvedToIndex = toIndex >= 0 ? toIndex : getDefaultToIndex(levels, fromIndex);
+    const minIndex = Math.min(fromIndex, resolvedToIndex);
+    const maxIndex = Math.max(fromIndex, resolvedToIndex);
+    return levels.slice(minIndex, maxIndex + 1);
+}
+export function getElevatorLevelHeight(levelId, nodes) {
+    const level = nodes[levelId];
+    if (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);
+    }
+    const serviceLevels = resolveElevatorServiceLevels(elevator, nodes);
+    const entries = serviceLevels.map((level) => ({
+        id: level.id,
+        label: String(level.level),
+        baseY: baseYByLevelId.get(level.id) ?? 0,
+    }));
+    const defaultEntry = entries.find((entry) => entry.id === elevator.defaultLevelId) ??
+        entries.find((entry) => entry.id === elevator.fromLevelId) ??
+        entries[0] ??
+        null;
+    const firstServedLevel = serviceLevels[0] ?? null;
+    const lastServedLevel = serviceLevels[serviceLevels.length - 1] ?? null;
+    const shaftBaseY = firstServedLevel ? (baseYByLevelId.get(firstServedLevel.id) ?? 0) : 0;
+    const lastServedIndex = lastServedLevel
+        ? allLevels.findIndex((level) => level.id === lastServedLevel.id)
+        : -1;
+    const nextLevel = lastServedIndex >= 0 ? allLevels[lastServedIndex + 1] : null;
+    const shaftTopY = nextLevel
+        ? (baseYByLevelId.get(nextLevel.id) ?? cumulativeY)
+        : lastServedLevel
+            ? cumulativeY
+            : elevator.cabHeight + 0.3;
+    return {
+        entries,
+        defaultEntry,
+        shaftBaseY,
+        shaftTopY,
+        totalHeight: Math.max(shaftTopY - shaftBaseY, elevator.cabHeight + 0.3),
+    };
+}

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"}