@pascal-app/nodes 0.1.1

package/dist/shared/wall-attach-target.d.ts

@@ -0,0 +1,109 @@
+import { type AnyNode, type AnyNodeId, type WallNode } from '@pascal-app/core';
+/**
+ * Shared helpers for the kinds whose 2D move snaps onto a wall in plan
+ * space (door, window, item with `attachTo === 'wall' | 'wall-side'`).
+ *
+ * The 3D move tools listen to R3F `WallEvent`s (mesh-hit with normal)
+ * for wall snapping. The 2D path doesn't have that — pointer events
+ * land on the SVG layer, not on the wall meshes. This helper does the
+ * equivalent plan-space projection: for each wall on the level, find
+ * the perpendicular projection of the pointer onto the wall line and
+ * pick the closest one within a reasonable range.
+ *
+ * Curved walls are excluded — the legacy door / window placement also
+ * rejects curved walls (mitering + arc + opening would tear in 3D).
+ */
+export type WallHit = {
+    wall: WallNode;
+    /** Distance along the wall from `start` (clamped to [0, length]). */
+    localX: number;
+    /** Signed perpendicular distance from the wall axis (+ on the "front" side). */
+    perpDistance: number;
+    /** Which face of the wall the pointer was on. */
+    side: 'front' | 'back';
+    /** Wall direction unit vector, x. */
+    dirX: number;
+    /** Wall direction unit vector, y (== z in plan). */
+    dirY: number;
+    /** Wall length in metres. */
+    wallLength: number;
+    /**
+     * Rotation around Y in **wall-local** space — 0 for the front face,
+     * π for the back. Matches the 3D `calculateItemRotation(normal)`
+     * convention (normal +Z → 0, normal -Z → π). Items / doors / windows
+     * are children of the wall mesh, so their `rotation.y` is in the
+     * wall's local frame; writing a world-space rotation here would mis-
+     * orient the node by `wallRotation` (off by 90° on vertical walls).
+     */
+    itemRotation: number;
+};
+export declare function projectWallLocalPointToPlan(wall: WallNode, localX: number, localZ?: number): [number, number];
+/**
+ * Return the single closest wall under `parentLevelId` to `planPoint` — the
+ * wall whose segment-Voronoi cell the point lies in — or `null` if nothing is
+ * within `WALL_SNAP_DISTANCE_M`. `excludeWallId` skips a specific wall.
+ *
+ * The nearest-segment scan + curved-wall filter live in core
+ * (`collectLevelWallSegments` / `nearestWallSegment`) so the editor's 2D
+ * Voronoi debug overlay classifies points with the exact same math — the
+ * overlay is then a faithful picture of where this snaps.
+ */
+export declare function findClosestWallInPlan(planPoint: readonly [number, number], nodes: Record<AnyNodeId, AnyNode>, parentLevelId: AnyNodeId | null, excludeWallId?: AnyNodeId): WallHit | null;
+/**
+ * Figma-style alignment for a wall-hosted opening / item, along the wall
+ * axis. Snaps the moving node's edges (or centre) to other attachments'
+ * edges/centres on the same wall, plus the wall ends. Edge-to-edge first,
+ * so two doors line up flush.
+ *
+ * Returns the adjusted `localX` when a neighbour stop is within threshold,
+ * or `null` when nothing aligns — callers treat `null` as "no alignment,
+ * fall back to the grid snap". This lets along-wall alignment COMPETE with
+ * the 0.5m grid (openings have arbitrary widths rarely on the grid, so
+ * layering on top of the grid snap would almost never trigger).
+ *
+ * Snap-only for v1 — no guide is published (the floor-plan guide layer
+ * renders XZ guides; an along-wall guide on a diagonal wall needs extra
+ * projection work, deferred).
+ */
+export declare function snapLocalXToNeighbors(args: {
+    wall: WallNode;
+    localX: number;
+    width: number;
+    selfId: AnyNodeId;
+    nodes: Record<AnyNodeId, AnyNode>;
+    threshold?: number;
+}): number | null;
+/**
+ * Does a wall-hosted opening of `width × height` centred at `(clampedX,
+ * clampedY)` (wall-local) overlap any OTHER child of `wallId` (door / window /
+ * wall-mounted item)? AABB test in the wall's local face plane. `ignoreId`
+ * excludes the moving node itself. Returns `true` (blocked) if the wall is
+ * gone.
+ *
+ * Single source of truth for door + window placement collision — door-math and
+ * window-math had byte-identical copies of this. Y conventions differ per kind
+ * (items store bottom Y; doors/windows store centre Y), handled inline.
+ */
+export declare function hasWallChildOverlap(wallId: string, clampedX: number, clampedY: number, width: number, height: number, ignoreId?: string): boolean;
+/** Placement state for a wall-hosted opening — the SINGLE decision the preview
+ *  tint and the commit gate both consume so they can never disagree. */
+export type OpeningPlacement = {
+    /** Geometric overlap with another wall child (independent of modifiers). */
+    collides: boolean;
+    /** May the opening be committed here? `true` unless it collides and the user
+     *  isn't force-placing. */
+    placeable: boolean;
+    /** Ghost tint: green when placeable, red when not. */
+    tint: 'valid' | 'invalid';
+};
+/**
+ * Resolve the placement state from the raw collision result and whether the
+ * user is force-placing (Shift). Force-place lifts the collision block, so the
+ * opening becomes placeable AND the tint goes green — the preview and the
+ * commit gate stay in lockstep because both read this one result.
+ */
+export declare function resolveOpeningPlacement(args: {
+    collides: boolean;
+    forcePlace: boolean;
+}): OpeningPlacement;
+//# sourceMappingURL=wall-attach-target.d.ts.map

package/dist/shared/wall-attach-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-attach-target.d.ts","sourceRoot":"","sources":["../../src/shared/wall-attach-target.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAOd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,QAAQ,CAAA;IACd,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAA;IACd,gFAAgF;IAChF,YAAY,EAAE,MAAM,CAAA;IACpB,iDAAiD;IACjD,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;IACtB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;;OAOG;IACH,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,EACd,MAAM,SAAI,GACT,CAAC,MAAM,EAAE,MAAM,CAAC,CAKlB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,SAAS,GAAG,IAAI,EAC/B,aAAa,CAAC,EAAE,SAAS,GACxB,OAAO,GAAG,IAAI,CA+BhB;AAwBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,MAAM,GAAG,IAAI,CAiChB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAmDT;AAED;wEACwE;AACxE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAA;IACjB;+BAC2B;IAC3B,SAAS,EAAE,OAAO,CAAA;IAClB,sDAAsD;IACtD,IAAI,EAAE,OAAO,GAAG,SAAS,CAAA;CAC1B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,QAAQ,EAAE,OAAO,CAAA;IACjB,UAAU,EAAE,OAAO,CAAA;CACpB,GAAG,gBAAgB,CAOnB"}

package/dist/shared/wall-attach-target.js

@@ -0,0 +1,192 @@
+import { collectLevelWallSegments, getScaledDimensions, nearestWallSegment, useScene, WALL_SNAP_DISTANCE_M, } from '@pascal-app/core';
+export function projectWallLocalPointToPlan(wall, localX, localZ = 0) {
+    const angle = -Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return [wall.start[0] + localX * c + localZ * s, wall.start[1] - localX * s + localZ * c];
+}
+/**
+ * Return the single closest wall under `parentLevelId` to `planPoint` — the
+ * wall whose segment-Voronoi cell the point lies in — or `null` if nothing is
+ * within `WALL_SNAP_DISTANCE_M`. `excludeWallId` skips a specific wall.
+ *
+ * The nearest-segment scan + curved-wall filter live in core
+ * (`collectLevelWallSegments` / `nearestWallSegment`) so the editor's 2D
+ * Voronoi debug overlay classifies points with the exact same math — the
+ * overlay is then a faithful picture of where this snaps.
+ */
+export function findClosestWallInPlan(planPoint, nodes, parentLevelId, excludeWallId) {
+    const segments = collectLevelWallSegments(nodes, parentLevelId);
+    const closest = nearestWallSegment(segments, planPoint[0], planPoint[1], WALL_SNAP_DISTANCE_M, excludeWallId);
+    if (!closest)
+        return null;
+    const { segment, along, perp } = closest;
+    // Side determination, calibrated to the 3D wall convention. In wall-local
+    // space the wall extends along +X and its +Z axis is the front-face normal;
+    // `perp >= 0` is consistently the front side (see `closestOnSegment`).
+    const side = perp >= 0 ? 'front' : 'back';
+    // Wall-local rotation matching 3D `calculateItemRotation`: 0 front, π back.
+    // The node is parented to the wall, so this composes with the wall's own
+    // rotation at render — never a world-space rotation here.
+    const itemRotation = side === 'front' ? 0 : Math.PI;
+    return {
+        wall: segment.wall,
+        localX: along,
+        perpDistance: perp,
+        side,
+        dirX: segment.dirX,
+        dirY: segment.dirY,
+        wallLength: segment.length,
+        itemRotation,
+    };
+}
+/** Figma-style along-wall alignment threshold (meters) — parity with the
+ *  XZ placement / move threshold. */
+const ALONG_WALL_ALIGN_THRESHOLD_M = 0.08;
+/** The along-wall span of a wall-hosted node (door / window / wall item):
+ *  its centre `localX` and half-width. `null` for kinds with no along-wall
+ *  footprint. */
+function wallAttachmentSpan(node) {
+    if (node.type === 'door' || node.type === 'window') {
+        const n = node;
+        return { center: n.position[0], half: n.width / 2 };
+    }
+    if (node.type === 'item') {
+        const item = node;
+        const attachTo = item.asset.attachTo;
+        if (attachTo !== 'wall' && attachTo !== 'wall-side')
+            return null;
+        const [w] = getScaledDimensions(item);
+        return { center: item.position[0], half: w / 2 };
+    }
+    return null;
+}
+/**
+ * Figma-style alignment for a wall-hosted opening / item, along the wall
+ * axis. Snaps the moving node's edges (or centre) to other attachments'
+ * edges/centres on the same wall, plus the wall ends. Edge-to-edge first,
+ * so two doors line up flush.
+ *
+ * Returns the adjusted `localX` when a neighbour stop is within threshold,
+ * or `null` when nothing aligns — callers treat `null` as "no alignment,
+ * fall back to the grid snap". This lets along-wall alignment COMPETE with
+ * the 0.5m grid (openings have arbitrary widths rarely on the grid, so
+ * layering on top of the grid snap would almost never trigger).
+ *
+ * Snap-only for v1 — no guide is published (the floor-plan guide layer
+ * renders XZ guides; an along-wall guide on a diagonal wall needs extra
+ * projection work, deferred).
+ */
+export function snapLocalXToNeighbors(args) {
+    const { wall, localX, width, selfId, nodes, threshold = ALONG_WALL_ALIGN_THRESHOLD_M } = args;
+    const half = width / 2;
+    const wallLength = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    // Candidate stops along the wall: both ends + every other attachment's
+    // edges and centre.
+    const candidateStops = [0, wallLength];
+    for (const node of Object.values(nodes)) {
+        if (!node || node.id === selfId)
+            continue;
+        if (node.parentId !== wall.id)
+            continue;
+        const span = wallAttachmentSpan(node);
+        if (!span)
+            continue;
+        candidateStops.push(span.center - span.half, span.center, span.center + span.half);
+    }
+    // Moving stops: our two edges (edge-to-edge alignment) + centre.
+    const movingStops = [localX - half, localX, localX + half];
+    let bestDelta = null;
+    let bestAbs = threshold;
+    for (const ms of movingStops) {
+        for (const cs of candidateStops) {
+            const d = cs - ms;
+            const ad = Math.abs(d);
+            if (ad <= bestAbs && (bestDelta === null || ad < bestAbs)) {
+                bestAbs = ad;
+                bestDelta = d;
+            }
+        }
+    }
+    return bestDelta === null ? null : localX + bestDelta;
+}
+/**
+ * Does a wall-hosted opening of `width × height` centred at `(clampedX,
+ * clampedY)` (wall-local) overlap any OTHER child of `wallId` (door / window /
+ * wall-mounted item)? AABB test in the wall's local face plane. `ignoreId`
+ * excludes the moving node itself. Returns `true` (blocked) if the wall is
+ * gone.
+ *
+ * Single source of truth for door + window placement collision — door-math and
+ * window-math had byte-identical copies of this. Y conventions differ per kind
+ * (items store bottom Y; doors/windows store centre Y), handled inline.
+ */
+export function hasWallChildOverlap(wallId, clampedX, clampedY, width, height, ignoreId) {
+    const nodes = useScene.getState().nodes;
+    const wallNode = nodes[wallId];
+    if (!wallNode)
+        return true;
+    const halfW = width / 2;
+    const halfH = height / 2;
+    const newBottom = clampedY - halfH;
+    const newTop = clampedY + halfH;
+    const newLeft = clampedX - halfW;
+    const newRight = clampedX + halfW;
+    for (const childId of Array.isArray(wallNode.children) ? wallNode.children : []) {
+        if (childId === ignoreId)
+            continue;
+        const child = nodes[childId];
+        if (!child)
+            continue;
+        let childLeft;
+        let childRight;
+        let childBottom;
+        let childTop;
+        if (child.type === 'item') {
+            const item = child;
+            if (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side')
+                continue;
+            const [w, h] = getScaledDimensions(item);
+            childLeft = item.position[0] - w / 2;
+            childRight = item.position[0] + w / 2;
+            childBottom = item.position[1]; // items store bottom Y
+            childTop = item.position[1] + h;
+        }
+        else if (child.type === 'window') {
+            const win = child;
+            childLeft = win.position[0] - win.width / 2;
+            childRight = win.position[0] + win.width / 2;
+            childBottom = win.position[1] - win.height / 2; // windows store centre Y
+            childTop = win.position[1] + win.height / 2;
+        }
+        else if (child.type === 'door') {
+            const door = child;
+            childLeft = door.position[0] - door.width / 2;
+            childRight = door.position[0] + door.width / 2;
+            childBottom = door.position[1] - door.height / 2; // doors store centre Y
+            childTop = door.position[1] + door.height / 2;
+        }
+        else {
+            continue;
+        }
+        const xOverlap = newLeft < childRight && newRight > childLeft;
+        const yOverlap = newBottom < childTop && newTop > childBottom;
+        if (xOverlap && yOverlap)
+            return true;
+    }
+    return false;
+}
+/**
+ * Resolve the placement state from the raw collision result and whether the
+ * user is force-placing (Shift). Force-place lifts the collision block, so the
+ * opening becomes placeable AND the tint goes green — the preview and the
+ * commit gate stay in lockstep because both read this one result.
+ */
+export function resolveOpeningPlacement(args) {
+    const placeable = !args.collides || args.forcePlace;
+    return {
+        collides: args.collides,
+        placeable,
+        tint: placeable ? 'valid' : 'invalid',
+    };
+}

package/dist/shared/wall-opening-alignment.d.ts

@@ -0,0 +1,34 @@
+import { type AlignmentAnchor, type AnyNode, type WallNode } from '@pascal-app/core';
+/** Figma-style alignment-snap threshold (meters), matching the move tools. */
+export declare const WALL_OPENING_ALIGNMENT_THRESHOLD_M = 0.08;
+/**
+ * Alignment candidates for a wall opening (door / window): only OTHER things
+ * hosted ON a wall — sibling openings and wall-mounted items. Floor/ground
+ * objects are excluded so an opening's along-wall guides line up with what's on
+ * the walls, never with furniture sitting on the floor below.
+ */
+export declare function collectWallOpeningAlignmentCandidates(nodes: Readonly<Record<string, AnyNode>>, excludeId: string): AlignmentAnchor[];
+/**
+ * Resolve a wall opening's along-wall position with Figma-style alignment to
+ * other objects, publishing the matching guide as a side effect.
+ *
+ * The probe is the RAW cursor position on the wall (not the grid snap) so
+ * off-grid anchors are caught; we then keep only the guide on an axis the wall
+ * runs along and map it to the along-wall coordinate that lands the opening on
+ * it. Falls back to the grid snap when nothing aligns, and clears the guide on
+ * bypass / no-match. Returns the localX to use (X-clamped to the wall given
+ * `width`). `bypass` disables alignment entirely (guide + pull). `applySnap`
+ * splits display from pull: the guide is always published while alignment is
+ * active, but the along-wall pull is applied only when `applySnap` (magnetic
+ * "lines" mode) — pass `false` to show the guide passively without moving the
+ * opening. The grid component lives in `snapToHalf`, itself mode-aware.
+ */
+export declare function resolveWallSlideAlignment(args: {
+    wallNode: WallNode;
+    rawLocalX: number;
+    width: number;
+    candidates: readonly AlignmentAnchor[];
+    bypass?: boolean;
+    applySnap?: boolean;
+}): number;
+//# sourceMappingURL=wall-opening-alignment.d.ts.map

package/dist/shared/wall-opening-alignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-opening-alignment.d.ts","sourceRoot":"","sources":["../../src/shared/wall-opening-alignment.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,OAAO,EAGZ,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,8EAA8E;AAC9E,eAAO,MAAM,kCAAkC,OAAO,CAAA;AAEtD;;;;;GAKG;AACH,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,SAAS,EAAE,MAAM,GAChB,eAAe,EAAE,CAKnB;AAUD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,QAAQ,EAAE,QAAQ,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,SAAS,eAAe,EAAE,CAAA;IACtC,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,GAAG,MAAM,CA4ET"}

package/dist/shared/wall-opening-alignment.js

@@ -0,0 +1,113 @@
+import { collectAlignmentAnchors, resolveAlignment, } from '@pascal-app/core';
+import { snapToHalf, useAlignmentGuides } from '@pascal-app/editor';
+/** Figma-style alignment-snap threshold (meters), matching the move tools. */
+export const WALL_OPENING_ALIGNMENT_THRESHOLD_M = 0.08;
+/**
+ * Alignment candidates for a wall opening (door / window): only OTHER things
+ * hosted ON a wall — sibling openings and wall-mounted items. Floor/ground
+ * objects are excluded so an opening's along-wall guides line up with what's on
+ * the walls, never with furniture sitting on the floor below.
+ */
+export function collectWallOpeningAlignmentCandidates(nodes, excludeId) {
+    return collectAlignmentAnchors(nodes, excludeId).filter((anchor) => {
+        const parentId = nodes[anchor.nodeId]?.parentId;
+        return !!parentId && nodes[parentId]?.type === 'wall';
+    });
+}
+/**
+ * A wall opening (door / window) can only slide ALONG its host wall, so it can
+ * only satisfy an x- or z-guide when the wall runs along that axis. Below this
+ * |component| (≈ wall within 60° of the axis) the along-wall move needed to
+ * reach the guide blows up, so we skip it rather than jump the opening across
+ * the wall.
+ */
+const MIN_AXIS_COMPONENT = 0.5;
+/**
+ * Resolve a wall opening's along-wall position with Figma-style alignment to
+ * other objects, publishing the matching guide as a side effect.
+ *
+ * The probe is the RAW cursor position on the wall (not the grid snap) so
+ * off-grid anchors are caught; we then keep only the guide on an axis the wall
+ * runs along and map it to the along-wall coordinate that lands the opening on
+ * it. Falls back to the grid snap when nothing aligns, and clears the guide on
+ * bypass / no-match. Returns the localX to use (X-clamped to the wall given
+ * `width`). `bypass` disables alignment entirely (guide + pull). `applySnap`
+ * splits display from pull: the guide is always published while alignment is
+ * active, but the along-wall pull is applied only when `applySnap` (magnetic
+ * "lines" mode) — pass `false` to show the guide passively without moving the
+ * opening. The grid component lives in `snapToHalf`, itself mode-aware.
+ */
+export function resolveWallSlideAlignment(args) {
+    const { wallNode, rawLocalX, width, candidates, bypass, applySnap } = args;
+    const base = snapToHalf(rawLocalX);
+    if (bypass || candidates.length === 0) {
+        useAlignmentGuides.getState().clear();
+        return base;
+    }
+    const dx = wallNode.end[0] - wallNode.start[0];
+    const dz = wallNode.end[1] - wallNode.start[1];
+    const wallLength = Math.sqrt(dx * dx + dz * dz);
+    if (wallLength < 1e-6) {
+        useAlignmentGuides.getState().clear();
+        return base;
+    }
+    const cos = dx / wallLength;
+    const sin = dz / wallLength;
+    const clampX = (localX) => Math.max(width / 2, Math.min(wallLength - width / 2, localX));
+    const probe = resolveAlignment({
+        moving: [
+            {
+                nodeId: '__wall-opening-draft__',
+                kind: 'corner',
+                x: wallNode.start[0] + rawLocalX * cos,
+                z: wallNode.start[1] + rawLocalX * sin,
+            },
+        ],
+        candidates,
+        threshold: WALL_OPENING_ALIGNMENT_THRESHOLD_M,
+    });
+    // Keep only a guide on an axis the wall runs along, mapped to the along-wall
+    // position that satisfies it; pick the nearest such.
+    let bestLocalX = null;
+    let bestDelta = Number.POSITIVE_INFINITY;
+    for (const guide of probe.guides) {
+        const denom = guide.axis === 'x' ? cos : sin;
+        if (Math.abs(denom) < MIN_AXIS_COMPONENT)
+            continue;
+        const origin = guide.axis === 'x' ? wallNode.start[0] : wallNode.start[1];
+        const targetLocalX = (guide.coord - origin) / denom;
+        const delta = Math.abs(targetLocalX - rawLocalX);
+        if (delta < bestDelta) {
+            bestDelta = delta;
+            bestLocalX = targetLocalX;
+        }
+    }
+    if (bestLocalX === null) {
+        useAlignmentGuides.getState().clear();
+        return base;
+    }
+    const clampedX = clampX(bestLocalX);
+    // Re-resolve from where the opening actually lands (post-clamp) so the
+    // published guide connects to the opening, not the raw cursor.
+    const published = resolveAlignment({
+        moving: [
+            {
+                nodeId: '__wall-opening-draft__',
+                kind: 'corner',
+                x: wallNode.start[0] + clampedX * cos,
+                z: wallNode.start[1] + clampedX * sin,
+            },
+        ],
+        candidates,
+        threshold: WALL_OPENING_ALIGNMENT_THRESHOLD_M,
+    });
+    if (published.guides.length === 0) {
+        useAlignmentGuides.getState().clear();
+    }
+    else {
+        useAlignmentGuides.getState().set(published.guides);
+    }
+    // Guides are published above in every alignment-active mode; the along-wall
+    // pull onto them only lands in magnetic ("lines") mode.
+    return applySnap === false ? base : clampedX;
+}

package/dist/shelf/definition.d.ts

@@ -0,0 +1,4 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { ShelfNode } from './schema';
+export declare const shelfDefinition: NodeDefinition<typeof ShelfNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/shelf/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAQpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA4HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAuJ5D,CAAA"}