@pascal-app/core 0.7.0 → 0.9.1

package/dist/services/alignment-anchors.test.js

@@ -0,0 +1,383 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import { z } from 'zod';
+import { nodeRegistry, registerNode } from '../registry';
+import { getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, } from '../systems/elevator/elevator-geometry';
+import { stairFootprintAABB } from '../systems/stair/stair-footprint';
+import { collectAlignmentAnchors, footprintAABB, footprintAABBFrom, movingAlignmentAnchors, movingFootprintAnchors, polygonAnchors, wallSegmentAnchors, } from './alignment-anchors';
+// Minimal floor-placed def whose footprint reads `dimensions` / `rotation`
+// straight off the node, so tests can drive the AABB math directly.
+function floorPlacedDef(kind, applies) {
+    return {
+        kind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(kind) }),
+        category: 'utility',
+        defaults: () => ({}),
+        capabilities: {
+            floorPlaced: {
+                footprint: (n) => ({
+                    dimensions: n.dimensions ?? [1, 1, 1],
+                    rotation: n.rotation ?? [0, 0, 0],
+                }),
+                ...(applies ? { applies } : {}),
+            },
+        },
+        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    };
+}
+// Mirrors the real elevator/stair definitions, which expose their plan
+// footprint via the `alignmentFootprint` capability rather than a hardcoded
+// branch in the anchor bridge. The glue (shaft-outset box / stair AABB) is
+// reproduced here from the same core helpers production uses.
+function elevatorDef() {
+    return {
+        kind: 'elevator',
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal('elevator') }),
+        category: 'structure',
+        defaults: () => ({}),
+        capabilities: {
+            alignmentFootprint: (n) => {
+                const e = n;
+                const wall = getElevatorShaftWallThickness(e);
+                return {
+                    shape: 'box',
+                    dimensions: [getElevatorShaftWidth(e) + wall * 2, 1, getElevatorShaftDepth(e) + wall * 2],
+                    rotation: [0, e.rotation ?? 0, 0],
+                };
+            },
+        },
+        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    };
+}
+function stairDef() {
+    return {
+        kind: 'stair',
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal('stair') }),
+        category: 'structure',
+        defaults: () => ({}),
+        capabilities: {
+            alignmentFootprint: (n, nodes) => {
+                const aabb = stairFootprintAABB(n, nodes);
+                return aabb ? { shape: 'aabb', ...aabb } : null;
+            },
+        },
+        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    };
+}
+function plainDef(kind) {
+    return {
+        kind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(kind) }),
+        category: 'utility',
+        defaults: () => ({}),
+        capabilities: {},
+        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    };
+}
+const node = (over) => over;
+describe('footprintAABBFrom', () => {
+    test('unrotated box is centred at position', () => {
+        const aabb = footprintAABBFrom([10, 0, 20], [2, 1, 4], 0);
+        expect(aabb).toEqual({ minX: 9, minZ: 18, maxX: 11, maxZ: 22 });
+    });
+    test('90° rotation swaps width and depth extents', () => {
+        const aabb = footprintAABBFrom([0, 0, 0], [2, 1, 4], Math.PI / 2);
+        expect(aabb.minX).toBeCloseTo(-2, 10);
+        expect(aabb.maxX).toBeCloseTo(2, 10);
+        expect(aabb.minZ).toBeCloseTo(-1, 10);
+        expect(aabb.maxZ).toBeCloseTo(1, 10);
+    });
+});
+describe('footprintAABB', () => {
+    beforeEach(() => nodeRegistry._reset());
+    test('reads dimensions + rotation from a floor-placed kind', () => {
+        registerNode(floorPlacedDef('box'));
+        const aabb = footprintAABB(node({ id: 'b1', type: 'box', position: [10, 0, 20], dimensions: [2, 1, 4] }));
+        expect(aabb).toEqual({ minX: 9, minZ: 18, maxX: 11, maxZ: 22 });
+    });
+    test('returns null for a kind without a footprint', () => {
+        registerNode(plainDef('wall'));
+        expect(footprintAABB(node({ id: 'w1', type: 'wall', position: [0, 0, 0] }))).toBeNull();
+    });
+    test('derives an elevator footprint from its OUTER SHAFT, not the cab', () => {
+        // Aligns to the visible shaft outline: cab 2×4 + 0.09 m wall each side →
+        // 2.18 × 4.18, centred at (10, 20). The cab corners alone would sit ~9 cm
+        // inside the drawn edge (past the 8 cm snap), so a guide never appeared.
+        // The footprint comes from the elevator's `alignmentFootprint` (box) cap.
+        registerNode(elevatorDef());
+        const aabb = footprintAABB(node({ id: 'e1', type: 'elevator', position: [10, 0, 20], width: 2, depth: 4, rotation: 0 }));
+        expect(aabb).toEqual({ minX: 8.91, minZ: 17.91, maxX: 11.09, maxZ: 22.09 });
+    });
+    test('returns null when the kind predicate excludes the node', () => {
+        registerNode(floorPlacedDef('lamp', (n) => !n.attached));
+        expect(footprintAABB(node({ id: 'l1', type: 'lamp', position: [0, 0, 0], attached: true }))).toBeNull();
+        expect(footprintAABB(node({ id: 'l2', type: 'lamp', position: [0, 0, 0], attached: false }))).not.toBeNull();
+    });
+});
+describe('movingFootprintAnchors', () => {
+    beforeEach(() => nodeRegistry._reset());
+    test('relocates the footprint corners around the proposed centre (edges only, no centre anchor)', () => {
+        registerNode(floorPlacedDef('box'));
+        const anchors = movingFootprintAnchors(node({ id: 'm', type: 'box', position: [0, 0, 0], dimensions: [2, 1, 4] }), 10, 20);
+        // 2×4 box centred at (10, 20): corners at x∈{9,11}, z∈{18,22}.
+        expect(anchors).toHaveLength(4);
+        expect(anchors.every((a) => a.kind === 'corner')).toBe(true);
+        expect(new Set(anchors.map((a) => a.x))).toEqual(new Set([9, 11]));
+        expect(new Set(anchors.map((a) => a.z))).toEqual(new Set([18, 22]));
+    });
+    test('rotationY override drives the AABB regardless of node rotation', () => {
+        registerNode(floorPlacedDef('box'));
+        const anchors = movingFootprintAnchors(node({
+            id: 'm',
+            type: 'box',
+            position: [0, 0, 0],
+            dimensions: [2, 1, 4],
+            rotation: [0, 0, 0],
+        }), 0, 0, Math.PI / 2);
+        const xs = anchors.map((a) => a.x);
+        // Rotated 90°, the 2×4 box spans ±2 in X (its depth) rather than ±1.
+        expect(Math.max(...xs)).toBeCloseTo(2, 10);
+        expect(Math.min(...xs)).toBeCloseTo(-2, 10);
+    });
+    test('returns empty for a footprintless kind', () => {
+        registerNode(plainDef('wall'));
+        expect(movingFootprintAnchors(node({ id: 'w', type: 'wall', position: [0, 0, 0] }), 1, 1)).toEqual([]);
+    });
+});
+describe('movingAlignmentAnchors', () => {
+    beforeEach(() => nodeRegistry._reset());
+    test('relocates a straight stair by its segment-chain footprint', () => {
+        registerNode(stairDef());
+        const nodes = {
+            st: node({
+                id: 'st',
+                type: 'stair',
+                position: [0, 0, 0],
+                rotation: 0,
+                stairType: 'straight',
+                width: 1,
+                children: ['seg'],
+            }),
+            seg: node({
+                id: 'seg',
+                type: 'stair-segment',
+                parentId: 'st',
+                width: 1,
+                length: 3,
+                height: 2.5,
+                attachmentSide: 'front',
+            }),
+        };
+        const anchors = movingAlignmentAnchors(nodes.st, nodes, 10, 20, 0);
+        expect(anchors).toHaveLength(4);
+        expect(new Set(anchors.map((a) => a.x))).toEqual(new Set([9.5, 10.5]));
+        expect(new Set(anchors.map((a) => a.z))).toEqual(new Set([20, 23]));
+    });
+    test('rotation override drives a moving straight stair footprint', () => {
+        registerNode(stairDef());
+        const nodes = {
+            st: node({
+                id: 'st',
+                type: 'stair',
+                position: [0, 0, 0],
+                rotation: 0,
+                stairType: 'straight',
+                width: 1,
+                children: ['seg'],
+            }),
+            seg: node({
+                id: 'seg',
+                type: 'stair-segment',
+                parentId: 'st',
+                width: 1,
+                length: 3,
+                height: 2.5,
+                attachmentSide: 'front',
+            }),
+        };
+        const anchors = movingAlignmentAnchors(nodes.st, nodes, 10, 20, Math.PI / 2);
+        const xs = anchors.map((a) => a.x);
+        const zs = anchors.map((a) => a.z);
+        expect(Math.min(...xs)).toBeCloseTo(10, 10);
+        expect(Math.max(...xs)).toBeCloseTo(13, 10);
+        expect(Math.min(...zs)).toBeCloseTo(19.5, 10);
+        expect(Math.max(...zs)).toBeCloseTo(20.5, 10);
+    });
+});
+describe('wallSegmentAnchors', () => {
+    test('returns both endpoints as corners and the chord midpoint as center', () => {
+        const anchors = wallSegmentAnchors('w', [0, 0], [4, 2]);
+        expect(anchors).toEqual([
+            { nodeId: 'w', kind: 'corner', x: 0, z: 0 },
+            { nodeId: 'w', kind: 'corner', x: 4, z: 2 },
+            { nodeId: 'w', kind: 'center', x: 2, z: 1 },
+        ]);
+    });
+    test('adds ±thickness/2 face corners on each endpoint when thickness is given', () => {
+        // Horizontal wall along +X: perpendicular is ±Z, so faces sit at z = ±0.1.
+        const anchors = wallSegmentAnchors('w', [0, 0], [4, 0], 0.2);
+        expect(anchors).toEqual([
+            { nodeId: 'w', kind: 'corner', x: 0, z: 0 },
+            { nodeId: 'w', kind: 'corner', x: 4, z: 0 },
+            { nodeId: 'w', kind: 'center', x: 2, z: 0 },
+            { nodeId: 'w', kind: 'corner', x: 0, z: 0.1 },
+            { nodeId: 'w', kind: 'corner', x: 0, z: -0.1 },
+            { nodeId: 'w', kind: 'corner', x: 4, z: 0.1 },
+            { nodeId: 'w', kind: 'corner', x: 4, z: -0.1 },
+        ]);
+    });
+    test('skips face corners for zero/degenerate input', () => {
+        expect(wallSegmentAnchors('w', [0, 0], [4, 0], 0)).toHaveLength(3);
+        expect(wallSegmentAnchors('w', [1, 1], [1, 1], 0.2)).toHaveLength(3);
+    });
+});
+describe('polygonAnchors', () => {
+    test('returns each vertex as a corner anchor', () => {
+        expect(polygonAnchors('s', [
+            [0, 0],
+            [2, 0],
+            [2, 3],
+        ])).toEqual([
+            { nodeId: 's', kind: 'corner', x: 0, z: 0 },
+            { nodeId: 's', kind: 'corner', x: 2, z: 0 },
+            { nodeId: 's', kind: 'corner', x: 2, z: 3 },
+        ]);
+    });
+});
+describe('collectAlignmentAnchors', () => {
+    beforeEach(() => nodeRegistry._reset());
+    test('unions footprint corners, segment anchors and polygon vertices, excluding the moving node', () => {
+        registerNode(floorPlacedDef('box'));
+        const nodes = {
+            moving: node({ id: 'moving', type: 'box', position: [0, 0, 0], dimensions: [1, 1, 1] }),
+            box: node({ id: 'box', type: 'box', position: [5, 0, 5], dimensions: [2, 1, 2] }),
+            wall: node({ id: 'wall', type: 'wall', start: [0, 0], end: [4, 0] }),
+            slab: node({
+                id: 'slab',
+                type: 'slab',
+                polygon: [
+                    [0, 0],
+                    [2, 0],
+                    [2, 2],
+                ],
+            }),
+        };
+        const anchors = collectAlignmentAnchors(nodes, 'moving');
+        const ids = anchors.map((a) => a.nodeId);
+        expect(ids).not.toContain('moving');
+        expect(ids.filter((id) => id === 'box')).toHaveLength(4); // corner anchors
+        expect(ids.filter((id) => id === 'wall')).toHaveLength(7); // endpoints + midpoint + 4 face corners
+        expect(ids.filter((id) => id === 'slab')).toHaveLength(3); // polygon vertices
+    });
+    test('levelId filter keeps only nodes resolving to that level (incl. nested)', () => {
+        registerNode(floorPlacedDef('box'));
+        registerNode(elevatorDef());
+        const nodes = {
+            b: node({ id: 'b', type: 'building' }),
+            L1: node({ id: 'L1', type: 'level', parentId: 'b' }),
+            L2: node({ id: 'L2', type: 'level', parentId: 'b' }),
+            moving: node({ id: 'moving', type: 'box', parentId: 'L1', position: [0, 0, 0] }),
+            sameFloor: node({ id: 'sameFloor', type: 'box', parentId: 'L1', position: [5, 0, 5] }),
+            // Item resting on `sameFloor` — resolves to L1 through the parent chain.
+            nested: node({ id: 'nested', type: 'box', parentId: 'sameFloor', position: [5, 0, 5] }),
+            otherFloor: node({ id: 'otherFloor', type: 'box', parentId: 'L2', position: [5, 0, 5] }),
+            // Building-scoped (parented to the building, no level ancestor) — spans
+            // every floor, so it stays in the pool regardless of the active level.
+            elevator: node({
+                id: 'elevator',
+                type: 'elevator',
+                parentId: 'b',
+                position: [9, 0, 9],
+                width: 1.6,
+                depth: 1.6,
+            }),
+        };
+        const ids = collectAlignmentAnchors(nodes, 'moving', 'L1').map((a) => a.nodeId);
+        expect(ids.filter((id) => id === 'sameFloor')).toHaveLength(4);
+        expect(ids.filter((id) => id === 'nested')).toHaveLength(4);
+        expect(ids.filter((id) => id === 'elevator')).toHaveLength(4);
+        expect(ids).not.toContain('otherFloor');
+    });
+    test('straight stair contributes its segment-chain footprint corners', () => {
+        registerNode(stairDef());
+        const nodes = {
+            st: node({
+                id: 'st',
+                type: 'stair',
+                position: [0, 0, 0],
+                rotation: 0,
+                stairType: 'straight',
+                width: 1,
+                children: ['seg'],
+            }),
+            // Single 1×3 flight; origin at the run start, extending +Z by length.
+            seg: node({
+                id: 'seg',
+                type: 'stair-segment',
+                parentId: 'st',
+                width: 1,
+                length: 3,
+                height: 2.5,
+                attachmentSide: 'front',
+            }),
+        };
+        const anchors = collectAlignmentAnchors(nodes, '').filter((a) => a.nodeId === 'st');
+        expect(anchors).toHaveLength(4);
+        expect(anchors.every((a) => a.kind === 'corner')).toBe(true);
+        expect(new Set(anchors.map((a) => a.x))).toEqual(new Set([-0.5, 0.5]));
+        expect(new Set(anchors.map((a) => a.z))).toEqual(new Set([0, 3]));
+    });
+    test('curved stair contributes its sector bounding-box corners', () => {
+        registerNode(stairDef());
+        const nodes = {
+            cs: node({
+                id: 'cs',
+                type: 'stair',
+                position: [0, 0, 0],
+                rotation: 0,
+                stairType: 'curved',
+                width: 1,
+                innerRadius: 1,
+                sweepAngle: Math.PI / 2,
+            }),
+        };
+        const anchors = collectAlignmentAnchors(nodes, '').filter((a) => a.nodeId === 'cs');
+        expect(anchors).toHaveLength(4);
+        // outerRadius = inner(1) + width(1) = 2, sweep π/2 centred on +X. Outer rim
+        // reaches X=2 at the bisector; min X is the inner rim's ±π/4 ends (cos45·1);
+        // Z spans ±(outer·sin45).
+        const xs = anchors.map((a) => a.x);
+        const zs = anchors.map((a) => a.z);
+        expect(Math.max(...xs)).toBeCloseTo(2, 5);
+        expect(Math.min(...xs)).toBeCloseTo(Math.SQRT1_2, 5);
+        expect(Math.max(...zs)).toBeCloseTo(Math.SQRT2, 5);
+        expect(Math.min(...zs)).toBeCloseTo(-Math.SQRT2, 5);
+    });
+    test('spiral stair contributes a full-circle bounding box', () => {
+        registerNode(stairDef());
+        const nodes = {
+            sp: node({
+                id: 'sp',
+                type: 'stair',
+                position: [5, 0, 5],
+                rotation: 0,
+                stairType: 'spiral',
+                width: 1,
+                innerRadius: 0.5,
+                sweepAngle: Math.PI * 2,
+            }),
+        };
+        const anchors = collectAlignmentAnchors(nodes, '').filter((a) => a.nodeId === 'sp');
+        expect(anchors).toHaveLength(4);
+        // outerRadius = inner(0.5) + width(1) = 1.5, a full revolution about (5, 5).
+        const xs = anchors.map((a) => a.x);
+        const zs = anchors.map((a) => a.z);
+        expect(Math.max(...xs)).toBeCloseTo(6.5, 2);
+        expect(Math.min(...xs)).toBeCloseTo(3.5, 2);
+        expect(Math.max(...zs)).toBeCloseTo(6.5, 2);
+        expect(Math.min(...zs)).toBeCloseTo(3.5, 2);
+    });
+});

package/dist/services/alignment.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Pure alignment-guide resolver — no React, no DOM, no scene access.
+ *
+ * Given a moving object's anchor points at its proposed position and a
+ * pool of candidate anchors from nearby static objects, returns:
+ *   - the best per-axis matches as `Guide` rendering primitives, and
+ *   - an optional `{ dx, dz }` snap delta the caller can apply.
+ *
+ * Anchors are 2D points on the floor plane (XZ, in world meters). The
+ * resolver picks at most one match per axis: the smallest |Δx| match
+ * snaps X; the smallest |Δz| match snaps Z. This mirrors Figma's
+ * behaviour — guides appear along the matched axes, regardless of how
+ * many neighbours could have matched.
+ *
+ * Two guides max per call keeps the visual signal sharp at the cost of
+ * not surfacing every possible alignment at once. Multi-guide ("this
+ * lines up with three things") is intentionally out of scope for v1.
+ */
+export type AnchorKind = 'corner' | 'edge-mid' | 'center';
+export type AlignmentAnchor = {
+    /** Owning node id — informational; resolver does not use it. */
+    nodeId: string;
+    kind: AnchorKind;
+    x: number;
+    z: number;
+};
+export type AlignmentGuideAxis = 'x' | 'z';
+/**
+ * Rendering primitive — a guide line on the floor plane.
+ *
+ * `axis === 'x'`: vertical guide. Both endpoints share `coord` as their X.
+ * `axis === 'z'`: horizontal guide. Both endpoints share `coord` as their Z.
+ *
+ * The line spans from the matched candidate anchor to the moving anchor
+ * after snap. Renderers extend visually beyond the endpoints if they want
+ * Figma-style "infinite line" feel.
+ */
+export type AlignmentGuide = {
+    axis: AlignmentGuideAxis;
+    coord: number;
+    from: {
+        x: number;
+        z: number;
+    };
+    to: {
+        x: number;
+        z: number;
+    };
+    movingAnchorKind: AnchorKind;
+    candidateAnchorKind: AnchorKind;
+    candidateNodeId: string;
+    /** Perpendicular distance between the two anchors (used by the distance pill). */
+    distance: number;
+};
+export type ResolveAlignmentInput = {
+    /** Anchors of the moving node, positioned at the proposed (pre-snap) location. */
+    moving: readonly AlignmentAnchor[];
+    /** Anchors from every other candidate node the caller has already filtered. */
+    candidates: readonly AlignmentAnchor[];
+    /**
+     * Max |Δ| (meters) for an anchor pair to count as a match. Typically
+     * derived from a screen-pixel budget × current units-per-pixel so the
+     * snap feel is zoom-invariant.
+     */
+    threshold: number;
+};
+export type ResolveAlignmentResult = {
+    guides: AlignmentGuide[];
+    /**
+     * Delta the caller should add to the moving node's planar position so
+     * its anchors land on the matched axes. `null` when no axis matched.
+     */
+    snap: {
+        dx: number;
+        dz: number;
+    } | null;
+};
+export type BuildingPose = {
+    position: readonly [number, number, number];
+    rotationY: number;
+};
+export type ResolveAlignmentInBuildingResult = {
+    /** Guides in WORLD coordinates. Renderers must be in a world-space group. */
+    guides: AlignmentGuide[];
+    /** Snap delta in the BUILDING-LOCAL frame, ready to add to a local position. */
+    snap: {
+        dx: number;
+        dz: number;
+    } | null;
+};
+/**
+ * Resolve alignment in WORLD space while accepting BUILDING-LOCAL anchors.
+ *
+ * Why this exists: the floor-plan grid lives in world XZ (rendered outside
+ * the rotated scene group), so alignment must follow the same axes —
+ * otherwise rotating a building drags the alignment guides off the visible
+ * grid and onto the rotated wall's local axes (the bug the user hit). The
+ * resolver itself is frame-agnostic; this wrapper just transforms anchors
+ * to world, resolves, then rotates the snap delta back into building-local
+ * so callers can add it to a local position without further math.
+ *
+ * `pose === null` → resolve in the caller's frame as-is (no transform).
+ */
+export declare function resolveAlignmentInBuildingWorld(input: {
+    moving: readonly AlignmentAnchor[];
+    candidates: readonly AlignmentAnchor[];
+    threshold: number;
+    pose: BuildingPose | null;
+}): ResolveAlignmentInBuildingResult;
+export declare function resolveAlignment(input: ResolveAlignmentInput): ResolveAlignmentResult;
+/**
+ * Produces the 9 standard anchors for an axis-aligned bounding box on the
+ * floor plane: 4 corners, 4 edge midpoints, 1 center. Suitable for any
+ * floor-plan entity whose footprint can be expressed as a bbox.
+ *
+ * Caller is responsible for computing the bbox — the resolver doesn't
+ * care how (per-kind dimensions, SVG getBBox(), etc.).
+ */
+export declare function bboxAnchors(nodeId: string, minX: number, minZ: number, maxX: number, maxZ: number): AlignmentAnchor[];
+/**
+ * The 4 corner anchors of a bbox — edges only, no edge-midpoints or center.
+ * Used where alignment should lock to an object's edges (left/right/front/
+ * back), never its centreline.
+ */
+export declare function bboxCornerAnchors(nodeId: string, minX: number, minZ: number, maxX: number, maxZ: number): AlignmentAnchor[];
+//# sourceMappingURL=alignment.d.ts.map

package/dist/services/alignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alignment.d.ts","sourceRoot":"","sources":["../../src/services/alignment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAA;AAEzD,MAAM,MAAM,eAAe,GAAG;IAC5B,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,UAAU,CAAA;IAChB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,GAAG,GAAG,GAAG,CAAA;AAE1C;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,kBAAkB,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9B,EAAE,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC5B,gBAAgB,EAAE,UAAU,CAAA;IAC5B,mBAAmB,EAAE,UAAU,CAAA;IAC/B,eAAe,EAAE,MAAM,CAAA;IACvB,kFAAkF;IAClF,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,kFAAkF;IAClF,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;IAClC,+EAA+E;IAC/E,UAAU,EAAE,SAAS,eAAe,EAAE,CAAA;IACtC;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB;;;OAGG;IACH,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CACxC,CAAA;AAgCD,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,gCAAgC,GAAG;IAC7C,6EAA6E;IAC7E,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,gFAAgF;IAChF,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CACxC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE;IACrD,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;IAClC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAA;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,YAAY,GAAG,IAAI,CAAA;CAC1B,GAAG,gCAAgC,CAwBnC;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,sBAAsB,CA0FrF;AAID;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,eAAe,EAAE,CAcnB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,eAAe,EAAE,CAOnB"}

package/dist/services/alignment.js

@@ -0,0 +1,169 @@
+/**
+ * Pure alignment-guide resolver — no React, no DOM, no scene access.
+ *
+ * Given a moving object's anchor points at its proposed position and a
+ * pool of candidate anchors from nearby static objects, returns:
+ *   - the best per-axis matches as `Guide` rendering primitives, and
+ *   - an optional `{ dx, dz }` snap delta the caller can apply.
+ *
+ * Anchors are 2D points on the floor plane (XZ, in world meters). The
+ * resolver picks at most one match per axis: the smallest |Δx| match
+ * snaps X; the smallest |Δz| match snaps Z. This mirrors Figma's
+ * behaviour — guides appear along the matched axes, regardless of how
+ * many neighbours could have matched.
+ *
+ * Two guides max per call keeps the visual signal sharp at the cost of
+ * not surfacing every possible alignment at once. Multi-guide ("this
+ * lines up with three things") is intentionally out of scope for v1.
+ */
+const EMPTY = { guides: [], snap: null };
+/** Forward rotation: local XZ → world XZ for a node whose parent has
+ *  position `bx,_,bz` and rotation-Y `rotY` (radians). Matches the
+ *  transform used throughout the editor's tools / floor-plan. */
+function localToWorld(x, z, bx, bz, cos, sin) {
+    return {
+        x: bx + x * cos + z * sin,
+        z: bz - x * sin + z * cos,
+    };
+}
+function transformAnchorToWorld(anchor, bx, bz, cos, sin) {
+    const w = localToWorld(anchor.x, anchor.z, bx, bz, cos, sin);
+    return { nodeId: anchor.nodeId, kind: anchor.kind, x: w.x, z: w.z };
+}
+/**
+ * Resolve alignment in WORLD space while accepting BUILDING-LOCAL anchors.
+ *
+ * Why this exists: the floor-plan grid lives in world XZ (rendered outside
+ * the rotated scene group), so alignment must follow the same axes —
+ * otherwise rotating a building drags the alignment guides off the visible
+ * grid and onto the rotated wall's local axes (the bug the user hit). The
+ * resolver itself is frame-agnostic; this wrapper just transforms anchors
+ * to world, resolves, then rotates the snap delta back into building-local
+ * so callers can add it to a local position without further math.
+ *
+ * `pose === null` → resolve in the caller's frame as-is (no transform).
+ */
+export function resolveAlignmentInBuildingWorld(input) {
+    const { moving, candidates, threshold, pose } = input;
+    if (!pose) {
+        return resolveAlignment({ moving, candidates, threshold });
+    }
+    const cos = Math.cos(pose.rotationY);
+    const sin = Math.sin(pose.rotationY);
+    const bx = pose.position[0];
+    const bz = pose.position[2];
+    const movingWorld = moving.map((a) => transformAnchorToWorld(a, bx, bz, cos, sin));
+    const candidatesWorld = candidates.map((a) => transformAnchorToWorld(a, bx, bz, cos, sin));
+    const result = resolveAlignment({
+        moving: movingWorld,
+        candidates: candidatesWorld,
+        threshold,
+    });
+    if (!result.snap)
+        return { guides: result.guides, snap: null };
+    // World → local rotation (orthogonal matrix → transpose). The inverse of
+    // `localToWorld` above maps (dx_world, dz_world) → (dx_local, dz_local).
+    const dxW = result.snap.dx;
+    const dzW = result.snap.dz;
+    const dxL = dxW * cos - dzW * sin;
+    const dzL = dxW * sin + dzW * cos;
+    return { guides: result.guides, snap: { dx: dxL, dz: dzL } };
+}
+export function resolveAlignment(input) {
+    const { moving, candidates, threshold } = input;
+    if (threshold <= 0 || moving.length === 0 || candidates.length === 0)
+        return EMPTY;
+    let bestX = null;
+    let bestZ = null;
+    for (const m of moving) {
+        for (const c of candidates) {
+            const dx = c.x - m.x;
+            const dz = c.z - m.z;
+            const adx = Math.abs(dx);
+            const adz = Math.abs(dz);
+            if (adx <= threshold &&
+                (bestX === null || adz < bestX.perp || (adz === bestX.perp && adx < bestX.primary))) {
+                bestX = { delta: dx, primary: adx, perp: adz, m, c };
+            }
+            if (adz <= threshold &&
+                (bestZ === null || adx < bestZ.perp || (adx === bestZ.perp && adz < bestZ.primary))) {
+                bestZ = { delta: dz, primary: adz, perp: adx, m, c };
+            }
+        }
+    }
+    if (!bestX && !bestZ)
+        return EMPTY;
+    const dxSnap = bestX?.delta ?? 0;
+    const dzSnap = bestZ?.delta ?? 0;
+    const guides = [];
+    if (bestX) {
+        // X-axis match: vertical guide at x = bestX.c.x. The moving anchor
+        // ends up at (c.x, m.z + dzSnap). Span the line between them.
+        const snappedMz = bestX.m.z + dzSnap;
+        const z1 = Math.min(bestX.c.z, snappedMz);
+        const z2 = Math.max(bestX.c.z, snappedMz);
+        guides.push({
+            axis: 'x',
+            coord: bestX.c.x,
+            from: { x: bestX.c.x, z: z1 },
+            to: { x: bestX.c.x, z: z2 },
+            movingAnchorKind: bestX.m.kind,
+            candidateAnchorKind: bestX.c.kind,
+            candidateNodeId: bestX.c.nodeId,
+            distance: Math.abs(snappedMz - bestX.c.z),
+        });
+    }
+    if (bestZ) {
+        const snappedMx = bestZ.m.x + dxSnap;
+        const x1 = Math.min(bestZ.c.x, snappedMx);
+        const x2 = Math.max(bestZ.c.x, snappedMx);
+        guides.push({
+            axis: 'z',
+            coord: bestZ.c.z,
+            from: { x: x1, z: bestZ.c.z },
+            to: { x: x2, z: bestZ.c.z },
+            movingAnchorKind: bestZ.m.kind,
+            candidateAnchorKind: bestZ.c.kind,
+            candidateNodeId: bestZ.c.nodeId,
+            distance: Math.abs(snappedMx - bestZ.c.x),
+        });
+    }
+    return { guides, snap: { dx: dxSnap, dz: dzSnap } };
+}
+// ─── Anchor extractors (pure) ─────────────────────────────────────────
+/**
+ * Produces the 9 standard anchors for an axis-aligned bounding box on the
+ * floor plane: 4 corners, 4 edge midpoints, 1 center. Suitable for any
+ * floor-plan entity whose footprint can be expressed as a bbox.
+ *
+ * Caller is responsible for computing the bbox — the resolver doesn't
+ * care how (per-kind dimensions, SVG getBBox(), etc.).
+ */
+export function bboxAnchors(nodeId, minX, minZ, maxX, maxZ) {
+    const cx = (minX + maxX) / 2;
+    const cz = (minZ + maxZ) / 2;
+    return [
+        { nodeId, kind: 'corner', x: minX, z: minZ },
+        { nodeId, kind: 'corner', x: maxX, z: minZ },
+        { nodeId, kind: 'corner', x: maxX, z: maxZ },
+        { nodeId, kind: 'corner', x: minX, z: maxZ },
+        { nodeId, kind: 'edge-mid', x: cx, z: minZ },
+        { nodeId, kind: 'edge-mid', x: maxX, z: cz },
+        { nodeId, kind: 'edge-mid', x: cx, z: maxZ },
+        { nodeId, kind: 'edge-mid', x: minX, z: cz },
+        { nodeId, kind: 'center', x: cx, z: cz },
+    ];
+}
+/**
+ * The 4 corner anchors of a bbox — edges only, no edge-midpoints or center.
+ * Used where alignment should lock to an object's edges (left/right/front/
+ * back), never its centreline.
+ */
+export function bboxCornerAnchors(nodeId, minX, minZ, maxX, maxZ) {
+    return [
+        { nodeId, kind: 'corner', x: minX, z: minZ },
+        { nodeId, kind: 'corner', x: maxX, z: minZ },
+        { nodeId, kind: 'corner', x: maxX, z: maxZ },
+        { nodeId, kind: 'corner', x: minX, z: maxZ },
+    ];
+}