@pascal-app/core 0.8.0 → 0.9.1

package/dist/schema/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAqBnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoBlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAkCnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiClB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/types.js

@@ -1,26 +1,40 @@
 import z from 'zod';
+import { BoxVentNode } from './nodes/box-vent';
 import { BuildingNode } from './nodes/building';
 import { CeilingNode } from './nodes/ceiling';
+import { ChimneyNode } from './nodes/chimney';
 import { ColumnNode } from './nodes/column';
+import { CupolaNode } from './nodes/cupola';
 import { DoorNode } from './nodes/door';
+import { DormerNode } from './nodes/dormer';
+import { DownspoutNode } from './nodes/downspout';
+import { ElevatorNode } from './nodes/elevator';
+import { EyebrowVentNode } from './nodes/eyebrow-vent';
 import { FenceNode } from './nodes/fence';
 import { GuideNode } from './nodes/guide';
+import { GutterNode } from './nodes/gutter';
 import { ItemNode } from './nodes/item';
 import { LevelNode } from './nodes/level';
+import { RidgeVentNode } from './nodes/ridge-vent';
 import { RoofNode } from './nodes/roof';
 import { RoofSegmentNode } from './nodes/roof-segment';
 import { ScanNode } from './nodes/scan';
+import { ShelfNode } from './nodes/shelf';
 import { SiteNode } from './nodes/site';
+import { SkylightNode } from './nodes/skylight';
 import { SlabNode } from './nodes/slab';
+import { SolarPanelNode } from './nodes/solar-panel';
 import { SpawnNode } from './nodes/spawn';
 import { StairNode } from './nodes/stair';
 import { StairSegmentNode } from './nodes/stair-segment';
+import { TurbineVentNode } from './nodes/turbine-vent';
 import { WallNode } from './nodes/wall';
 import { WindowNode } from './nodes/window';
 import { ZoneNode } from './nodes/zone';
 export const AnyNode = z.discriminatedUnion('type', [
     SiteNode,
     BuildingNode,
+    ElevatorNode,
     LevelNode,
     ColumnNode,
     WallNode,
@@ -31,6 +45,7 @@ export const AnyNode = z.discriminatedUnion('type', [
     CeilingNode,
     RoofNode,
     RoofSegmentNode,
+    ShelfNode,
     StairNode,
     StairSegmentNode,
     ScanNode,
@@ -38,4 +53,15 @@ export const AnyNode = z.discriminatedUnion('type', [
     SpawnNode,
     WindowNode,
     DoorNode,
+    BoxVentNode,
+    RidgeVentNode,
+    TurbineVentNode,
+    CupolaNode,
+    EyebrowVentNode,
+    GutterNode,
+    ChimneyNode,
+    SolarPanelNode,
+    SkylightNode,
+    DormerNode,
+    DownspoutNode,
 ]);

package/dist/services/alignment-anchors.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Node → alignment-anchor adapters.
+ *
+ * `alignment.ts` is pure geometry and knows nothing about nodes. This
+ * module bridges the scene graph to it: it reads a floor-placed kind's
+ * footprint from the registry and turns it into the bbox anchors the
+ * resolver matches against. Kept out of `alignment.ts` so that file stays
+ * registry-free.
+ *
+ * All coordinates are XZ meters in the same frame as `node.position`
+ * (building-local for nodes inside a building). The 3D move producer works
+ * entirely in that frame, so the resulting guides line up with the cursor.
+ */
+import type { AnyNode } from '../schema/types';
+import { type AlignmentAnchor } from './alignment';
+export type FootprintAABB = {
+    minX: number;
+    minZ: number;
+    maxX: number;
+    maxZ: number;
+};
+/**
+ * Axis-aligned XZ bounding box of a rotated rectangle centred at
+ * `position`. Mirrors the rotated-corner math the spatial-grid manager
+ * uses (`getItemFootprint`) so alignment anchors coincide with the
+ * footprint used for collision / slab elevation.
+ */
+export declare function footprintAABBFrom(position: readonly [number, number, number], dimensions: readonly [number, number, number], rotationY: number): FootprintAABB;
+/** XZ footprint AABB of a floor-placed node at its current position, or
+ *  null for kinds without a usable footprint. */
+export declare function footprintAABB(node: AnyNode): FootprintAABB | null;
+/** XZ footprint AABB of a floor-placed node relocated so its centre sits at
+ *  the proposed (x, z). `rotationY` overrides the node's footprint rotation
+ *  (R/T bumps it before the scene commit lands). Null when no footprint. */
+export declare function footprintAABBAt(node: AnyNode, x: number, z: number, rotationY?: number): FootprintAABB | null;
+/**
+ * Corner anchors for the moving node's footprint relocated so its centre
+ * sits at the proposed (x, z). Corners only — the moving item aligns by its
+ * edges, never its centreline. Returns [] when the kind has no footprint.
+ */
+export declare function movingFootprintAnchors(node: AnyNode, x: number, z: number, rotationY?: number): AlignmentAnchor[];
+/**
+ * Corner anchors for a moving node relocated to the proposed plan position.
+ * Covers both the centred-box path (`floorPlaced.footprint` /
+ * `alignmentFootprint: box`) and explicit AABB footprints such as stairs,
+ * whose occupied plan bounds depend on children or curved/spiral geometry.
+ */
+export declare function movingAlignmentAnchors(node: AnyNode, nodes: Readonly<Record<string, AnyNode>> | undefined, x: number, z: number, rotationY?: number): AlignmentAnchor[];
+/**
+ * Alignment anchors for a wall segment: the two centerline endpoints + chord
+ * midpoint, plus — when `thickness` is known — four **face** corner anchors,
+ * each endpoint offset by ±thickness/2 perpendicular to the wall axis.
+ *
+ * The face anchors are what let a footprint align to a wall's *face* rather
+ * than its centerline: for an axis-aligned wall the two same-side face
+ * anchors share a constant X (vertical wall) or Z (horizontal wall) running
+ * the wall's full length, so the point-to-point resolver snaps a moving
+ * corner flush to the face anywhere along the wall (the perpendicular
+ * tie-break connects the guide to the nearer face endpoint). A diagonal wall
+ * gets only its face/centerline endpoints — point-to-point can't represent a
+ * sloped face line; that's an accepted v1 limitation.
+ *
+ * Curve offset is ignored — endpoints are exact and the chord midpoint is
+ * good enough for v1. Coordinates are the wall's `start` / `end`
+ * (building-local XZ meters).
+ */
+export declare function wallSegmentAnchors(id: string, start: readonly [number, number], end: readonly [number, number], thickness?: number): AlignmentAnchor[];
+/** Each vertex of a polygon (slab / ceiling footprint) as a `corner` anchor. */
+export declare function polygonAnchors(id: string, points: readonly (readonly [number, number])[]): AlignmentAnchor[];
+/**
+ * Alignment anchors a node contributes to the candidate pool, dispatched by
+ * kind: walls / fences → segment endpoints + midpoint; slabs / ceilings →
+ * polygon vertices; everything else → the corners of its plan bounding box
+ * (`alignmentAABB`, which covers floor-placed kinds, the elevator's
+ * alignment box, and the stair's chain / sector footprint). Kinds with no
+ * usable footprint contribute nothing.
+ *
+ * `nodes` is needed only by kinds whose footprint walks siblings / children
+ * (a straight stair's `stair-segment` chain); every other kind derives its
+ * anchors from `node` alone.
+ */
+export declare function nodeAlignmentAnchors(node: AnyNode, nodes?: Readonly<Record<string, AnyNode>>): AlignmentAnchor[];
+/**
+ * Anchors from every alignable node except `excludeId` — the unified
+ * candidate pool every move / placement tool resolves against, so any
+ * draggable object can align to any other (items, walls, fences, slabs,
+ * ceilings, columns).
+ *
+ * When `levelId` is given, nodes that belong to a *different* level are
+ * dropped. Alignment is XZ-only, so without this a node directly below on
+ * another floor (e.g. the ground floor while you place on the first) would
+ * snap and draw a guide even though the two sit at different heights.
+ * Building-/site-scoped nodes with no level ancestor (e.g. an elevator
+ * shaft, which is parented to the building and spans every floor) resolve to
+ * null and stay in the pool so they align on any floor. The 2D floor-plan
+ * deliberately omits the filter — aligning a wall to the one directly below
+ * in plan is the whole point of the reference floor.
+ */
+export declare function collectAlignmentAnchors(nodes: Readonly<Record<string, AnyNode>>, excludeId: string, levelId?: string | null): AlignmentAnchor[];
+//# sourceMappingURL=alignment-anchors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"alignment-anchors.d.ts","sourceRoot":"","sources":["../../src/services/alignment-anchors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAE9C,OAAO,EAAE,KAAK,eAAe,EAAqB,MAAM,aAAa,CAAA;AAErE,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtF;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC3C,UAAU,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7C,SAAS,EAAE,MAAM,GAChB,aAAa,CA4Bf;AAwDD;iDACiD;AACjD,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,aAAa,GAAG,IAAI,CAKjE;AAED;;4EAE4E;AAC5E,wBAAgB,eAAe,CAC7B,IAAI,EAAE,OAAO,EACb,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,CAAC,EAAE,MAAM,GACjB,aAAa,GAAG,IAAI,CAItB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,OAAO,EACb,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,CAAC,EAAE,MAAM,GACjB,eAAe,EAAE,CAInB;AAoBD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,EACpD,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,CAAC,EAAE,MAAM,GACjB,eAAe,EAAE,CAuBnB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,SAAS,CAAC,EAAE,MAAM,GACjB,eAAe,EAAE,CAwBnB;AAED,gFAAgF;AAChF,wBAAgB,cAAc,CAC5B,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,GAC7C,eAAe,EAAE,CAEnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,EACb,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,eAAe,EAAE,CAkBnB;AAoBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GACtB,eAAe,EAAE,CAWnB"}

package/dist/services/alignment-anchors.js

@@ -0,0 +1,283 @@
+/**
+ * Node → alignment-anchor adapters.
+ *
+ * `alignment.ts` is pure geometry and knows nothing about nodes. This
+ * module bridges the scene graph to it: it reads a floor-placed kind's
+ * footprint from the registry and turns it into the bbox anchors the
+ * resolver matches against. Kept out of `alignment.ts` so that file stays
+ * registry-free.
+ *
+ * All coordinates are XZ meters in the same frame as `node.position`
+ * (building-local for nodes inside a building). The 3D move producer works
+ * entirely in that frame, so the resulting guides line up with the cursor.
+ */
+import { nodeRegistry } from '../registry';
+import { DEFAULT_WALL_THICKNESS } from '../systems/wall/wall-footprint';
+import { bboxCornerAnchors } from './alignment';
+/**
+ * Axis-aligned XZ bounding box of a rotated rectangle centred at
+ * `position`. Mirrors the rotated-corner math the spatial-grid manager
+ * uses (`getItemFootprint`) so alignment anchors coincide with the
+ * footprint used for collision / slab elevation.
+ */
+export function footprintAABBFrom(position, dimensions, rotationY) {
+    const [x, , z] = position;
+    const [w, , d] = dimensions;
+    const halfW = w / 2;
+    const halfD = d / 2;
+    const cos = Math.cos(rotationY);
+    const sin = Math.sin(rotationY);
+    let minX = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const [lx, lz] of [
+        [-halfW, -halfD],
+        [halfW, -halfD],
+        [halfW, halfD],
+        [-halfW, halfD],
+    ]) {
+        const wx = x + (lx * cos - lz * sin);
+        const wz = z + (lx * sin + lz * cos);
+        if (wx < minX)
+            minX = wx;
+        if (wx > maxX)
+            maxX = wx;
+        if (wz < minZ)
+            minZ = wz;
+        if (wz > maxZ)
+            maxZ = wz;
+    }
+    return { minX, minZ, maxX, maxZ };
+}
+/** The relocatable box footprint for a node, or null when it has none
+ *  (walls / slabs / polygon kinds) or the kind's predicate excludes it
+ *  (e.g. a wall-attached item that doesn't rest on the floor).
+ *
+ *  Box footprints come from one of two capabilities: `floorPlaced` (kinds
+ *  whose Y is also slab-lifted — columns, items) or `alignmentFootprint`
+ *  with a `box` shape (kinds that align by their footprint but aren't
+ *  floor-coupled — the elevator's outer shaft). A kind whose
+ *  `alignmentFootprint` is an `aabb` (stair) has no centred box, so it's
+ *  resolved directly in `nodeAlignmentAnchors`, not here. */
+function floorFootprint(node) {
+    const capabilities = nodeRegistry.get(node.type)?.capabilities;
+    const floorPlaced = capabilities?.floorPlaced;
+    // `footprint` is optional now that floor-placed kinds may instead declare
+    // composite `footprints` (e.g. stairs); those have no single centred box
+    // here, so fall through to `alignmentFootprint`.
+    if (floorPlaced?.footprint) {
+        if (floorPlaced.applies && !floorPlaced.applies(node))
+            return null;
+        return floorPlaced.footprint(node);
+    }
+    const alignment = capabilities?.alignmentFootprint?.(node);
+    if (alignment?.shape === 'box') {
+        return { dimensions: alignment.dimensions, rotation: alignment.rotation };
+    }
+    return null;
+}
+/**
+ * XZ bounding box a node occupies in plan, unifying the two non-structural
+ * sources: a relocatable box (`floorFootprint`, covering floor-placed kinds
+ * and the elevator's alignment box) and a kind that hands back an explicit
+ * `aabb` because its plan shape isn't a centred rectangle (stair). Returns
+ * null for kinds with neither.
+ */
+function alignmentAABB(node, nodes) {
+    const box = footprintAABB(node);
+    if (box)
+        return box;
+    const alignment = nodeRegistry.get(node.type)?.capabilities?.alignmentFootprint?.(node, nodes);
+    if (alignment?.shape === 'aabb') {
+        return {
+            minX: alignment.minX,
+            minZ: alignment.minZ,
+            maxX: alignment.maxX,
+            maxZ: alignment.maxZ,
+        };
+    }
+    return null;
+}
+/** XZ footprint AABB of a floor-placed node at its current position, or
+ *  null for kinds without a usable footprint. */
+export function footprintAABB(node) {
+    const fp = floorFootprint(node);
+    if (!fp)
+        return null;
+    const position = node.position ?? [0, 0, 0];
+    return footprintAABBFrom(position, fp.dimensions, fp.rotation[1] ?? 0);
+}
+/** XZ footprint AABB of a floor-placed node relocated so its centre sits at
+ *  the proposed (x, z). `rotationY` overrides the node's footprint rotation
+ *  (R/T bumps it before the scene commit lands). Null when no footprint. */
+export function footprintAABBAt(node, x, z, rotationY) {
+    const fp = floorFootprint(node);
+    if (!fp)
+        return null;
+    return footprintAABBFrom([x, 0, z], fp.dimensions, rotationY ?? fp.rotation[1] ?? 0);
+}
+/**
+ * Corner anchors for the moving node's footprint relocated so its centre
+ * sits at the proposed (x, z). Corners only — the moving item aligns by its
+ * edges, never its centreline. Returns [] when the kind has no footprint.
+ */
+export function movingFootprintAnchors(node, x, z, rotationY) {
+    const aabb = footprintAABBAt(node, x, z, rotationY);
+    if (!aabb)
+        return [];
+    return bboxCornerAnchors(node.id, aabb.minX, aabb.minZ, aabb.maxX, aabb.maxZ);
+}
+function relocatedPlanNode(node, x, z, rotationY) {
+    const position = node.position;
+    const y = Array.isArray(position) && typeof position[1] === 'number' ? position[1] : 0;
+    const relocated = {
+        ...node,
+        position: [x, y, z],
+    };
+    if (rotationY !== undefined && 'rotation' in node) {
+        const rotation = node.rotation;
+        relocated.rotation = Array.isArray(rotation)
+            ? [rotation[0] ?? 0, rotationY, rotation[2] ?? 0]
+            : rotationY;
+    }
+    return relocated;
+}
+/**
+ * Corner anchors for a moving node relocated to the proposed plan position.
+ * Covers both the centred-box path (`floorPlaced.footprint` /
+ * `alignmentFootprint: box`) and explicit AABB footprints such as stairs,
+ * whose occupied plan bounds depend on children or curved/spiral geometry.
+ */
+export function movingAlignmentAnchors(node, nodes, x, z, rotationY) {
+    const box = footprintAABBAt(node, x, z, rotationY);
+    if (box)
+        return bboxCornerAnchors(node.id, box.minX, box.minZ, box.maxX, box.maxZ);
+    const alignment = nodeRegistry
+        .get(node.type)
+        ?.capabilities?.alignmentFootprint?.(relocatedPlanNode(node, x, z, rotationY), nodes);
+    if (alignment?.shape === 'box') {
+        const aabb = footprintAABBFrom([x, 0, z], alignment.dimensions, alignment.rotation[1] ?? 0);
+        return bboxCornerAnchors(node.id, aabb.minX, aabb.minZ, aabb.maxX, aabb.maxZ);
+    }
+    if (alignment?.shape === 'aabb') {
+        return bboxCornerAnchors(node.id, alignment.minX, alignment.minZ, alignment.maxX, alignment.maxZ);
+    }
+    return [];
+}
+/**
+ * Alignment anchors for a wall segment: the two centerline endpoints + chord
+ * midpoint, plus — when `thickness` is known — four **face** corner anchors,
+ * each endpoint offset by ±thickness/2 perpendicular to the wall axis.
+ *
+ * The face anchors are what let a footprint align to a wall's *face* rather
+ * than its centerline: for an axis-aligned wall the two same-side face
+ * anchors share a constant X (vertical wall) or Z (horizontal wall) running
+ * the wall's full length, so the point-to-point resolver snaps a moving
+ * corner flush to the face anywhere along the wall (the perpendicular
+ * tie-break connects the guide to the nearer face endpoint). A diagonal wall
+ * gets only its face/centerline endpoints — point-to-point can't represent a
+ * sloped face line; that's an accepted v1 limitation.
+ *
+ * Curve offset is ignored — endpoints are exact and the chord midpoint is
+ * good enough for v1. Coordinates are the wall's `start` / `end`
+ * (building-local XZ meters).
+ */
+export function wallSegmentAnchors(id, start, end, thickness) {
+    const anchors = [
+        { nodeId: id, kind: 'corner', x: start[0], z: start[1] },
+        { nodeId: id, kind: 'corner', x: end[0], z: end[1] },
+        { nodeId: id, kind: 'center', x: (start[0] + end[0]) / 2, z: (start[1] + end[1]) / 2 },
+    ];
+    if (thickness && thickness > 0) {
+        const dx = end[0] - start[0];
+        const dz = end[1] - start[1];
+        const len = Math.hypot(dx, dz);
+        if (len > 1e-6) {
+            // Perpendicular to the wall axis, scaled to half-thickness.
+            const half = thickness / 2;
+            const px = (-dz / len) * half;
+            const pz = (dx / len) * half;
+            for (const [bx, bz] of [start, end]) {
+                anchors.push({ nodeId: id, kind: 'corner', x: bx + px, z: bz + pz });
+                anchors.push({ nodeId: id, kind: 'corner', x: bx - px, z: bz - pz });
+            }
+        }
+    }
+    return anchors;
+}
+/** Each vertex of a polygon (slab / ceiling footprint) as a `corner` anchor. */
+export function polygonAnchors(id, points) {
+    return points.map(([x, z]) => ({ nodeId: id, kind: 'corner', x, z }));
+}
+/**
+ * Alignment anchors a node contributes to the candidate pool, dispatched by
+ * kind: walls / fences → segment endpoints + midpoint; slabs / ceilings →
+ * polygon vertices; everything else → the corners of its plan bounding box
+ * (`alignmentAABB`, which covers floor-placed kinds, the elevator's
+ * alignment box, and the stair's chain / sector footprint). Kinds with no
+ * usable footprint contribute nothing.
+ *
+ * `nodes` is needed only by kinds whose footprint walks siblings / children
+ * (a straight stair's `stair-segment` chain); every other kind derives its
+ * anchors from `node` alone.
+ */
+export function nodeAlignmentAnchors(node, nodes) {
+    if (node.type === 'wall' || node.type === 'fence') {
+        const seg = node;
+        // Wall thickness is schema-optional (falls back to the geometry default);
+        // fence always carries one. Either way, pass it through so faces align.
+        return wallSegmentAnchors(seg.id, seg.start, seg.end, seg.thickness ?? DEFAULT_WALL_THICKNESS);
+    }
+    if (node.type === 'slab' || node.type === 'ceiling') {
+        const poly = node.polygon;
+        return poly ? polygonAnchors(node.id, poly) : [];
+    }
+    const aabb = alignmentAABB(node, nodes);
+    return aabb ? bboxCornerAnchors(node.id, aabb.minX, aabb.minZ, aabb.maxX, aabb.maxZ) : [];
+}
+/**
+ * Resolve the level a node belongs to by walking its `parentId` chain, or
+ * null when it isn't under a level. Inlined here (rather than importing the
+ * spatial-grid `resolveLevelId`) to keep this services module free of
+ * hook / store dependencies.
+ */
+function resolveNodeLevelId(node, nodes) {
+    let current = node;
+    while (current) {
+        if (current.type === 'level')
+            return current.id;
+        current = current.parentId ? nodes[current.parentId] : undefined;
+    }
+    return null;
+}
+/**
+ * Anchors from every alignable node except `excludeId` — the unified
+ * candidate pool every move / placement tool resolves against, so any
+ * draggable object can align to any other (items, walls, fences, slabs,
+ * ceilings, columns).
+ *
+ * When `levelId` is given, nodes that belong to a *different* level are
+ * dropped. Alignment is XZ-only, so without this a node directly below on
+ * another floor (e.g. the ground floor while you place on the first) would
+ * snap and draw a guide even though the two sit at different heights.
+ * Building-/site-scoped nodes with no level ancestor (e.g. an elevator
+ * shaft, which is parented to the building and spans every floor) resolve to
+ * null and stay in the pool so they align on any floor. The 2D floor-plan
+ * deliberately omits the filter — aligning a wall to the one directly below
+ * in plan is the whole point of the reference floor.
+ */
+export function collectAlignmentAnchors(nodes, excludeId, levelId) {
+    const anchors = [];
+    for (const node of Object.values(nodes)) {
+        if (!node || node.id === excludeId)
+            continue;
+        if (levelId) {
+            const nodeLevelId = resolveNodeLevelId(node, nodes);
+            if (nodeLevelId !== null && nodeLevelId !== levelId)
+                continue;
+        }
+        anchors.push(...nodeAlignmentAnchors(node, nodes));
+    }
+    return anchors;
+}

package/dist/services/alignment-anchors.test.d.ts

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

package/dist/services/alignment-anchors.test.d.ts.map

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