@pascal-app/core 0.8.0 → 0.9.2

package/dist/services/movement.js

@@ -0,0 +1,65 @@
+import { nodeRegistry } from '../registry/registry';
+import { snapVec3ToGrid } from './snap';
+/**
+ * Returns the MovableConfig effective for `node` after running its `override`
+ * callback if declared. Returns `null` if the node's def doesn't declare
+ * `movable` (i.e. the node is not movable).
+ */
+export function resolveMovable(node) {
+    const def = nodeRegistry.get(node.type);
+    const base = def?.capabilities.movable;
+    if (!base)
+        return null;
+    if (base.override) {
+        const overridden = base.override({ node });
+        return overridden ?? base;
+    }
+    return base;
+}
+/**
+ * Projects a target X/Y/Z onto the axes a node is allowed to move on. Components
+ * outside the lock fall back to the node's current values, so caller-supplied
+ * positions can come from any 3D source without breaking axis-locked motion.
+ */
+export function applyAxisLock(current, target, axes) {
+    return [
+        axes.includes('x') ? target[0] : current[0],
+        axes.includes('y') ? target[1] : current[1],
+        axes.includes('z') ? target[2] : current[2],
+    ];
+}
+/**
+ * Top-level helper: takes a node and a desired position, returns the position
+ * filtered through the node's movable capability (axis lock + optional grid
+ * snap). Returns `null` when the node is not movable.
+ */
+export function moveToward(node, current, target, options = {}) {
+    const config = resolveMovable(node);
+    if (!config)
+        return null;
+    let next = applyAxisLock(current, target, config.axes);
+    const wantsGridSnap = options.gridSnap ?? config.gridSnap;
+    if (wantsGridSnap) {
+        next = snapVec3ToGrid(next, options.gridStep);
+    }
+    return next;
+}
+/**
+ * 2D convenience: same as moveToward but for plan-view (X/Z) operations like
+ * floor placement. Returns a tuple in the X/Z plane so callers don't have to
+ * pack/unpack the dropped Y.
+ */
+export function movePlanToward(node, currentY, current, target, options = {}) {
+    const result = moveToward(node, [current[0], currentY, current[1]], [target[0], currentY, target[1]], options);
+    if (!result)
+        return null;
+    return [result[0], result[2]];
+}
+/**
+ * Returns true when a node's def declares it as movable on any axis.
+ * Quick predicate for tools/UI that gate on movability.
+ */
+export function isMovable(node) {
+    const config = resolveMovable(node);
+    return config != null && config.axes.length > 0;
+}

package/dist/services/movement.test.d.ts

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

package/dist/services/movement.test.d.ts.map

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

package/dist/services/movement.test.js

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import { z } from 'zod';
+import { nodeRegistry, registerNode } from '../registry/registry';
+import { applyAxisLock, isMovable, movePlanToward, moveToward, resolveMovable } from './movement';
+const id = (s) => s;
+function makeDef(kind, capabilities = {}) {
+    return {
+        kind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(kind) }),
+        category: 'utility',
+        defaults: () => ({}),
+        capabilities,
+        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    };
+}
+function makeNode(kind, idStr) {
+    return {
+        id: id(idStr),
+        type: kind,
+        parentId: null,
+        visible: true,
+    };
+}
+describe('resolveMovable', () => {
+    beforeEach(() => {
+        nodeRegistry._reset();
+    });
+    test('returns null when no def is registered', () => {
+        expect(resolveMovable(makeNode('mystery', 'm'))).toBeNull();
+    });
+    test('returns null when def declares no movable capability', () => {
+        registerNode(makeDef('static'));
+        expect(resolveMovable(makeNode('static', 's'))).toBeNull();
+    });
+    test('returns the declared config', () => {
+        registerNode(makeDef('column', { movable: { axes: ['x', 'z'], gridSnap: true } }));
+        const config = resolveMovable(makeNode('column', 'c'));
+        expect(config?.axes).toEqual(['x', 'z']);
+        expect(config?.gridSnap).toBe(true);
+    });
+    test('runs override callback when present', () => {
+        let overrideRan = false;
+        const config = {
+            axes: ['x'],
+            override: () => {
+                overrideRan = true;
+                return { axes: ['y'] };
+            },
+        };
+        registerNode(makeDef('weird', { movable: config }));
+        const resolved = resolveMovable(makeNode('weird', 'w'));
+        expect(overrideRan).toBe(true);
+        expect(resolved?.axes).toEqual(['y']);
+    });
+    test('override returning null falls back to base config', () => {
+        registerNode(makeDef('column', {
+            movable: { axes: ['x', 'z'], override: () => null },
+        }));
+        const resolved = resolveMovable(makeNode('column', 'c'));
+        expect(resolved?.axes).toEqual(['x', 'z']);
+    });
+});
+describe('applyAxisLock', () => {
+    test('passes through unlocked axes only', () => {
+        expect(applyAxisLock([1, 2, 3], [10, 20, 30], ['x'])).toEqual([10, 2, 3]);
+        expect(applyAxisLock([1, 2, 3], [10, 20, 30], ['x', 'z'])).toEqual([10, 2, 30]);
+        expect(applyAxisLock([1, 2, 3], [10, 20, 30], ['x', 'y', 'z'])).toEqual([10, 20, 30]);
+    });
+    test('empty lock returns current unchanged', () => {
+        expect(applyAxisLock([1, 2, 3], [10, 20, 30], [])).toEqual([1, 2, 3]);
+    });
+});
+describe('moveToward', () => {
+    beforeEach(() => {
+        nodeRegistry._reset();
+    });
+    test('returns null when node is not movable', () => {
+        registerNode(makeDef('static'));
+        expect(moveToward(makeNode('static', 's'), [0, 0, 0], [1, 1, 1])).toBeNull();
+    });
+    test('axis-locks and returns the constrained target', () => {
+        registerNode(makeDef('column', { movable: { axes: ['x', 'z'] } }));
+        expect(moveToward(makeNode('column', 'c'), [0, 0.5, 0], [1, 99, 2])).toEqual([1, 0.5, 2]);
+    });
+    test('applies grid snap when capability declares gridSnap: true', () => {
+        registerNode(makeDef('column', { movable: { axes: ['x', 'z'], gridSnap: true } }));
+        const result = moveToward(makeNode('column', 'c'), [0, 0, 0], [0.3, 0, 0.6], {
+            gridStep: 0.25,
+        });
+        expect(result).toEqual([0.25, 0, 0.5]);
+    });
+    test('grid snap can be overridden at call site', () => {
+        registerNode(makeDef('column', { movable: { axes: ['x', 'z'], gridSnap: true } }));
+        // Caller explicitly disables grid snap for this call
+        const result = moveToward(makeNode('column', 'c'), [0, 0, 0], [0.3, 0, 0.6], {
+            gridSnap: false,
+        });
+        expect(result).toEqual([0.3, 0, 0.6]);
+    });
+});
+describe('movePlanToward', () => {
+    beforeEach(() => {
+        nodeRegistry._reset();
+    });
+    test('returns 2D point with X/Z constrained, Y dropped', () => {
+        registerNode(makeDef('column', { movable: { axes: ['x', 'z'], gridSnap: true } }));
+        const result = movePlanToward(makeNode('column', 'c'), 0.5, // currentY
+        [0, 0], [0.3, 0.6], { gridStep: 0.25 });
+        expect(result).toEqual([0.25, 0.5]);
+    });
+    test('returns null when node is not movable', () => {
+        registerNode(makeDef('static'));
+        expect(movePlanToward(makeNode('static', 's'), 0, [0, 0], [1, 1])).toBeNull();
+    });
+});
+describe('isMovable', () => {
+    beforeEach(() => {
+        nodeRegistry._reset();
+    });
+    test('true when movable.axes has entries', () => {
+        registerNode(makeDef('column', { movable: { axes: ['x'] } }));
+        expect(isMovable(makeNode('column', 'c'))).toBe(true);
+    });
+    test('false when no movable capability', () => {
+        registerNode(makeDef('static'));
+        expect(isMovable(makeNode('static', 's'))).toBe(false);
+    });
+    test('false when movable.axes is empty', () => {
+        registerNode(makeDef('locked', { movable: { axes: [] } }));
+        expect(isMovable(makeNode('locked', 'l'))).toBe(false);
+    });
+});

package/dist/services/opening-guides.d.ts

@@ -0,0 +1,141 @@
+/** An opening's footprint in its host wall's local frame. */
+export type OpeningSpan = {
+    id: string;
+    /** Centre along the wall, measured from `wall.start` (m). */
+    centerS: number;
+    /** Along-wall extent (m). */
+    width: number;
+    /** Vertical centre above the wall base (floor at y=0) (m). */
+    centerY: number;
+    /** Vertical extent (m). */
+    height: number;
+};
+export type WallExtent = {
+    /** Wall length (m). */
+    length: number;
+    /** Wall height (m). */
+    height: number;
+};
+export type OpeningGuideTolerances = {
+    /** Max distance for an edge/centre to count as aligned with a neighbour (m). */
+    align: number;
+    /** Max difference between two gaps for them to count as equal (m). */
+    equalSpacing: number;
+    /** Gaps below this are treated as touching/overlap noise and ignored (m). */
+    minGap: number;
+};
+export declare const DEFAULT_OPENING_GUIDE_TOLERANCES: OpeningGuideTolerances;
+/** Which along-wall feature of an opening a guide references. */
+export type AlongWallFeature = 'left' | 'center' | 'right';
+/** Which vertical feature of an opening a guide references. */
+export type VerticalFeature = 'sill' | 'center' | 'top';
+export type SillHeadGuide = {
+    /** Floor (y=0) → the opening's bottom edge (m). */
+    sill: number;
+    /** Wall-local y of the bottom edge. */
+    bottomY: number;
+    /** The opening's top edge → the wall top (m). */
+    head: number;
+    /** Wall-local y of the top edge. */
+    topY: number;
+};
+export type EdgeGap = {
+    side: 'left' | 'right';
+    /** Clearance along the wall (m). */
+    distance: number;
+    /** Wall-local s of the moving opening's edge. */
+    fromS: number;
+    /** Wall-local s of the neighbour edge / wall end. */
+    toS: number;
+    target: 'opening' | 'wall-start' | 'wall-end';
+    /** Set when `target === 'opening'`. */
+    targetId?: string;
+};
+export type AlongWallAlignment = {
+    /** Wall-local s the two features share. */
+    s: number;
+    movingFeature: AlongWallFeature;
+    targetId: string;
+    targetFeature: AlongWallFeature;
+    /** Delta to add to the moving opening's `centerS` to make them coincide. */
+    snap: number;
+};
+export type VerticalAlignment = {
+    /** Wall-local y the two features share. */
+    y: number;
+    movingFeature: VerticalFeature;
+    targetId: string;
+    targetFeature: VerticalFeature;
+    /** Delta to add to the moving opening's `centerY` to make them coincide. */
+    snap: number;
+};
+export type EqualSpacingRun = {
+    /** The repeated gap value (average of the run's gaps) (m). */
+    gap: number;
+    /** The equal-gap segments along the wall, in order (left → right). */
+    segments: {
+        fromS: number;
+        toS: number;
+    }[];
+    /** Participating opening ids, ordered along the wall, including the moving one. */
+    openingIds: string[];
+};
+export type OpeningGuides = {
+    sillHead: SillHeadGuide | null;
+    gaps: EdgeGap[];
+    alongWall: AlongWallAlignment | null;
+    vertical: VerticalAlignment | null;
+    equalSpacing: EqualSpacingRun | null;
+};
+export type OpeningGuideInput = {
+    moving: OpeningSpan;
+    /** Other openings on the SAME wall (the moving opening excluded). */
+    siblings: readonly OpeningSpan[];
+    wall: WallExtent;
+    /**
+     * Whether to compute vertical (sill/head/vertical-alignment) guides. True for
+     * windows; false for doors, which sit on the floor so their sill is always 0.
+     */
+    includeVertical: boolean;
+    tolerances?: Partial<OpeningGuideTolerances>;
+};
+/**
+ * Edge-to-edge clearance from the moving opening to the nearest neighbour on
+ * each side, falling back to the wall ends when there is no neighbour — the
+ * "how much wall is left here" reading. Returns 0–2 gaps (one per side); a side
+ * is omitted when its clearance is below `minGap` (the opening is flush against
+ * or overlapping that neighbour).
+ */
+export declare function computeEdgeGaps(moving: OpeningSpan, siblings: readonly OpeningSpan[], wall: WallExtent, minGap: number): EdgeGap[];
+/**
+ * The closest coincidence between any of the moving opening's edges/centre and
+ * any sibling's edges/centre along the wall, within `tolerance`. Edge-to-edge
+ * and centre-to-centre are weighed equally; the single closest pair wins
+ * (matching the one-guide-per-axis behaviour of the floor-plane resolver).
+ */
+export declare function detectAlongWallAlignment(moving: OpeningSpan, siblings: readonly OpeningSpan[], tolerance: number): AlongWallAlignment | null;
+/**
+ * The closest coincidence between the moving opening's sill/centre/top and any
+ * sibling's sill/centre/top, within `tolerance` — the "these two windows share
+ * a sill height" detector. Same single-best-match policy as the along-wall
+ * variant.
+ */
+export declare function detectVerticalAlignment(moving: OpeningSpan, siblings: readonly OpeningSpan[], tolerance: number): VerticalAlignment | null;
+/**
+ * Figma-style equal-spacing detection: order all openings along the wall, look
+ * at the clearances BETWEEN consecutive openings, and return the longest run of
+ * ≥2 consecutive gaps that are equal within `tolerance` and that the moving
+ * opening participates in (so the badges only appear while the drag is actually
+ * forming or extending a series). Returns null when no such run exists.
+ *
+ * Gaps below `minGap` (touching/overlapping openings) break a run — a row of
+ * flush openings is not "equally spaced".
+ */
+export declare function detectEqualSpacing(allOpenings: readonly OpeningSpan[], movingId: string, tolerance: number, minGap: number): EqualSpacingRun | null;
+/**
+ * Compute every proximity/alignment guide for the moving opening in one pass.
+ * Pure: feed it the moving opening's wall-local span, its same-wall siblings,
+ * and the wall extent; render the result in whichever view.
+ */
+export declare function computeOpeningGuides(input: OpeningGuideInput): OpeningGuides;
+//# sourceMappingURL=opening-guides.d.ts.map

package/dist/services/opening-guides.d.ts.map

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

package/dist/services/opening-guides.js

@@ -0,0 +1,267 @@
+// Proximity / alignment guides for wall-hosted openings (doors, windows).
+//
+// Pure geometry over a single host wall's LOCAL frame — no Three.js, no scene
+// store, no React — so it runs identically for the 3D viewport and the 2D
+// floor plan and is unit-testable in isolation. Callers extract the spans from
+// the scene graph (an opening's `position[0]` is its along-wall centre, its
+// `position[1]` its vertical centre with the wall base at y=0) and feed them in;
+// the renderers transform the returned wall-local coordinates back to world
+// (3D) or plan (2D).
+//
+// What it produces, mirroring the affordances architects expect (and Figma's
+// smart guides):
+//   - sill/head    : a window's bottom edge → floor and top edge → wall top.
+//   - edge gaps     : along-wall clearance to the nearest neighbour opening (or
+//                     the wall end) on each side.
+//   - alongWall     : the moving opening's edge/centre lining up with a
+//                     neighbour's edge/centre along the wall.
+//   - vertical      : two openings sharing a sill / head / vertical centre.
+//   - equalSpacing  : a run of 3+ openings with (near-)equal gaps between them.
+//
+// Detection is passive — it reports what currently coincides within tolerance
+// and the snap delta that would make it exact, leaving the snap decision to the
+// caller's manipulation policy (grid vs. alignment vs. Shift bypass).
+export const DEFAULT_OPENING_GUIDE_TOLERANCES = {
+    // Parity with the along-wall snap threshold (`ALONG_WALL_ALIGN_THRESHOLD_M`).
+    align: 0.08,
+    equalSpacing: 0.03,
+    minGap: 0.02,
+};
+const leftEdge = (s) => s.centerS - s.width / 2;
+const rightEdge = (s) => s.centerS + s.width / 2;
+const bottomEdge = (s) => s.centerY - s.height / 2;
+const topEdge = (s) => s.centerY + s.height / 2;
+function alongWallFeatureCoord(s, feature) {
+    if (feature === 'left')
+        return leftEdge(s);
+    if (feature === 'right')
+        return rightEdge(s);
+    return s.centerS;
+}
+function verticalFeatureCoord(s, feature) {
+    if (feature === 'sill')
+        return bottomEdge(s);
+    if (feature === 'top')
+        return topEdge(s);
+    return s.centerY;
+}
+const ALONG_WALL_FEATURES = ['left', 'center', 'right'];
+const VERTICAL_FEATURES = ['sill', 'center', 'top'];
+/**
+ * Edge-to-edge clearance from the moving opening to the nearest neighbour on
+ * each side, falling back to the wall ends when there is no neighbour — the
+ * "how much wall is left here" reading. Returns 0–2 gaps (one per side); a side
+ * is omitted when its clearance is below `minGap` (the opening is flush against
+ * or overlapping that neighbour).
+ */
+export function computeEdgeGaps(moving, siblings, wall, minGap) {
+    const movingLeft = leftEdge(moving);
+    const movingRight = rightEdge(moving);
+    // A sibling that straddles one of the moving opening's edges is an OVERLAP,
+    // not a neighbour: there is no clearance on that side, and we must not fall
+    // back to the wall end (which would report a misleading distance measured
+    // "through" the overlapping opening).
+    const leftCrossed = siblings.some((s) => leftEdge(s) < movingLeft && rightEdge(s) > movingLeft);
+    const rightCrossed = siblings.some((s) => leftEdge(s) < movingRight && rightEdge(s) > movingRight);
+    let leftNeighbour = null;
+    let rightNeighbour = null;
+    for (const sib of siblings) {
+        const sibRight = rightEdge(sib);
+        const sibLeft = leftEdge(sib);
+        // Entirely to the left of the moving opening → candidate left neighbour.
+        if (sibRight <= movingLeft && (leftNeighbour === null || sibRight > leftNeighbour.s)) {
+            leftNeighbour = { s: sibRight, id: sib.id };
+        }
+        // Entirely to the right → candidate right neighbour.
+        if (sibLeft >= movingRight && (rightNeighbour === null || sibLeft < rightNeighbour.s)) {
+            rightNeighbour = { s: sibLeft, id: sib.id };
+        }
+    }
+    const gaps = [];
+    if (!leftCrossed) {
+        const leftToS = leftNeighbour ? leftNeighbour.s : 0;
+        const leftDistance = movingLeft - leftToS;
+        if (leftDistance >= minGap) {
+            gaps.push({
+                side: 'left',
+                distance: leftDistance,
+                fromS: movingLeft,
+                toS: leftToS,
+                target: leftNeighbour ? 'opening' : 'wall-start',
+                targetId: leftNeighbour?.id,
+            });
+        }
+    }
+    if (!rightCrossed) {
+        const rightToS = rightNeighbour ? rightNeighbour.s : wall.length;
+        const rightDistance = rightToS - movingRight;
+        if (rightDistance >= minGap) {
+            gaps.push({
+                side: 'right',
+                distance: rightDistance,
+                fromS: movingRight,
+                toS: rightToS,
+                target: rightNeighbour ? 'opening' : 'wall-end',
+                targetId: rightNeighbour?.id,
+            });
+        }
+    }
+    return gaps;
+}
+/**
+ * The closest coincidence between any of the moving opening's edges/centre and
+ * any sibling's edges/centre along the wall, within `tolerance`. Edge-to-edge
+ * and centre-to-centre are weighed equally; the single closest pair wins
+ * (matching the one-guide-per-axis behaviour of the floor-plane resolver).
+ */
+export function detectAlongWallAlignment(moving, siblings, tolerance) {
+    let best = null;
+    let bestAbs = tolerance;
+    for (const movingFeature of ALONG_WALL_FEATURES) {
+        const movingCoord = alongWallFeatureCoord(moving, movingFeature);
+        for (const sib of siblings) {
+            if (sib.id === moving.id)
+                continue;
+            for (const targetFeature of ALONG_WALL_FEATURES) {
+                const targetCoord = alongWallFeatureCoord(sib, targetFeature);
+                const diff = targetCoord - movingCoord;
+                const abs = Math.abs(diff);
+                if (abs <= bestAbs && (best === null || abs < bestAbs)) {
+                    bestAbs = abs;
+                    best = {
+                        s: targetCoord,
+                        movingFeature,
+                        targetId: sib.id,
+                        targetFeature,
+                        snap: diff,
+                    };
+                }
+            }
+        }
+    }
+    return best;
+}
+/**
+ * The closest coincidence between the moving opening's sill/centre/top and any
+ * sibling's sill/centre/top, within `tolerance` — the "these two windows share
+ * a sill height" detector. Same single-best-match policy as the along-wall
+ * variant.
+ */
+export function detectVerticalAlignment(moving, siblings, tolerance) {
+    let best = null;
+    let bestAbs = tolerance;
+    for (const movingFeature of VERTICAL_FEATURES) {
+        const movingCoord = verticalFeatureCoord(moving, movingFeature);
+        for (const sib of siblings) {
+            if (sib.id === moving.id)
+                continue;
+            for (const targetFeature of VERTICAL_FEATURES) {
+                const targetCoord = verticalFeatureCoord(sib, targetFeature);
+                const diff = targetCoord - movingCoord;
+                const abs = Math.abs(diff);
+                if (abs <= bestAbs && (best === null || abs < bestAbs)) {
+                    bestAbs = abs;
+                    best = {
+                        y: targetCoord,
+                        movingFeature,
+                        targetId: sib.id,
+                        targetFeature,
+                        snap: diff,
+                    };
+                }
+            }
+        }
+    }
+    return best;
+}
+/**
+ * Figma-style equal-spacing detection: order all openings along the wall, look
+ * at the clearances BETWEEN consecutive openings, and return the longest run of
+ * ≥2 consecutive gaps that are equal within `tolerance` and that the moving
+ * opening participates in (so the badges only appear while the drag is actually
+ * forming or extending a series). Returns null when no such run exists.
+ *
+ * Gaps below `minGap` (touching/overlapping openings) break a run — a row of
+ * flush openings is not "equally spaced".
+ */
+export function detectEqualSpacing(allOpenings, movingId, tolerance, minGap) {
+    if (allOpenings.length < 3)
+        return null;
+    const sorted = [...allOpenings].sort((a, b) => a.centerS - b.centerS);
+    const movingIndex = sorted.findIndex((s) => s.id === movingId);
+    if (movingIndex < 0)
+        return null;
+    // Clearance between opening i and i+1.
+    const gaps = [];
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const a = sorted[i];
+        const b = sorted[i + 1];
+        if (!a || !b)
+            continue;
+        const fromS = rightEdge(a);
+        const toS = leftEdge(b);
+        gaps.push({ value: toS - fromS, fromS, toS });
+    }
+    // Longest contiguous window of gaps that are (a) each ≥ minGap and (b)
+    // mutually equal within tolerance (window max − min ≤ tolerance), spanning at
+    // least 2 gaps and including the moving opening. Brute force over windows
+    // (openings per wall are few). A first-gap-anchored greedy scan is NOT
+    // equivalent: it drops a valid run that begins partway through a drifting
+    // sequence — e.g. gaps 1.00, 1.02, 1.04 with the moving opening at the end,
+    // where [1.02, 1.04] is a real run. On a length tie the leftmost window wins,
+    // for determinism.
+    let best = null;
+    for (let lo = 0; lo < gaps.length; lo++) {
+        let min = Number.POSITIVE_INFINITY;
+        let max = Number.NEGATIVE_INFINITY;
+        for (let hi = lo; hi < gaps.length; hi++) {
+            const gap = gaps[hi];
+            if (!gap || gap.value < minGap)
+                break; // a sub-minGap gap can't join a run
+            min = Math.min(min, gap.value);
+            max = Math.max(max, gap.value);
+            if (max - min > tolerance)
+                break; // extending only widens the spread
+            const gapCount = hi - lo + 1;
+            if (gapCount < 2)
+                continue;
+            const firstOpening = lo; // gap i sits between openings i and i+1
+            const lastOpening = hi + 1;
+            if (movingIndex < firstOpening || movingIndex > lastOpening)
+                continue;
+            if (best !== null && gapCount <= best.segments.length)
+                continue;
+            const windowGaps = gaps.slice(lo, hi + 1);
+            best = {
+                gap: windowGaps.reduce((sum, g) => sum + g.value, 0) / windowGaps.length,
+                segments: windowGaps.map((g) => ({ fromS: g.fromS, toS: g.toS })),
+                openingIds: sorted.slice(firstOpening, lastOpening + 1).map((s) => s.id),
+            };
+        }
+    }
+    return best;
+}
+/**
+ * Compute every proximity/alignment guide for the moving opening in one pass.
+ * Pure: feed it the moving opening's wall-local span, its same-wall siblings,
+ * and the wall extent; render the result in whichever view.
+ */
+export function computeOpeningGuides(input) {
+    const tol = { ...DEFAULT_OPENING_GUIDE_TOLERANCES, ...input.tolerances };
+    const { moving, siblings, wall, includeVertical } = input;
+    const sillHead = includeVertical
+        ? {
+            sill: bottomEdge(moving),
+            bottomY: bottomEdge(moving),
+            head: wall.height - topEdge(moving),
+            topY: topEdge(moving),
+        }
+        : null;
+    return {
+        sillHead,
+        gaps: computeEdgeGaps(moving, siblings, wall, tol.minGap),
+        alongWall: detectAlongWallAlignment(moving, siblings, tol.align),
+        vertical: includeVertical ? detectVerticalAlignment(moving, siblings, tol.align) : null,
+        equalSpacing: detectEqualSpacing([moving, ...siblings], moving.id, tol.equalSpacing, tol.minGap),
+    };
+}

package/dist/services/opening-guides.test.d.ts

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

package/dist/services/opening-guides.test.d.ts.map

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