@pascal-app/nodes 0.1.1

package/dist/shared/floor-placement.js

@@ -0,0 +1,109 @@
+import { emitter, movingFootprintAnchors, resolveAlignment, sceneRegistry, snapPointToGrid, } from '@pascal-app/core';
+import { Vector3 } from 'three';
+export const FLOOR_PLACEMENT_ALIGNMENT_THRESHOLD_M = 0.08;
+export const FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS = [
+    'shelf',
+    'item',
+    'slab',
+    'ceiling',
+    'wall',
+    'fence',
+    'column',
+    'roof',
+    'roof-segment',
+    'stair',
+    'stair-segment',
+];
+const worldVector = new Vector3();
+export function getLevelLocalSnappedPosition(levelId, event, gridStep, bypassGrid = false) {
+    const levelObject = sceneRegistry.nodes.get(levelId);
+    if (!levelObject) {
+        const rawPoint = 'node' in event ? event.position : event.localPosition;
+        const [sx, sz] = bypassGrid
+            ? [rawPoint[0], rawPoint[2]]
+            : snapPointToGrid([rawPoint[0], rawPoint[2]], gridStep);
+        return [sx, 0, sz];
+    }
+    worldVector.set(event.position[0], event.position[1], event.position[2]);
+    levelObject.updateWorldMatrix(true, false);
+    levelObject.worldToLocal(worldVector);
+    const [sx, sz] = bypassGrid
+        ? [worldVector.x, worldVector.z]
+        : snapPointToGrid([worldVector.x, worldVector.z], gridStep);
+    return [sx, 0, sz];
+}
+export function resolveAlignedFloorPlacement({ node, rawX, rawZ, gridStep, candidates, showAlignment = true, applyAlignmentSnap = true, bypassGrid = false, rotationY = 0, }) {
+    const [sx, sz] = bypassGrid ? [rawX, rawZ] : snapPointToGrid([rawX, rawZ], gridStep);
+    let ax = sx;
+    let az = sz;
+    const result = showAlignment && candidates.length > 0
+        ? resolveAlignment({
+            moving: movingFootprintAnchors(node, sx, sz, rotationY),
+            candidates,
+            threshold: FLOOR_PLACEMENT_ALIGNMENT_THRESHOLD_M,
+        })
+        : null;
+    if (result?.snap && applyAlignmentSnap) {
+        ax += result.snap.dx;
+        az += result.snap.dz;
+    }
+    return {
+        position: [ax, 0, az],
+        guides: result?.guides ?? [],
+    };
+}
+// Node-surface clicks (wall/slab/…) are synthesized on pointerup; the
+// browser's real `click` fires right after and would re-trigger the same
+// placement through the canvas-level `grid:click` listener, which R3F
+// stopPropagation cannot reach. Eat that one follow-up click.
+function swallowFollowUpBrowserClick() {
+    if (typeof window === 'undefined')
+        return;
+    const swallow = (e) => {
+        e.stopPropagation();
+        e.preventDefault();
+    };
+    window.addEventListener('click', swallow, { capture: true, once: true });
+    setTimeout(() => window.removeEventListener('click', swallow, { capture: true }), 300);
+}
+export function stopPlacementCommitPropagation(event) {
+    const native = event.nativeEvent;
+    const nativeStopPropagation = native
+        ?.stopPropagation;
+    if (typeof nativeStopPropagation === 'function') {
+        nativeStopPropagation.call(native);
+    }
+    const direct = event.stopPropagation;
+    if (typeof direct === 'function')
+        direct.call(event);
+    if ('node' in event)
+        swallowFollowUpBrowserClick();
+}
+export function subscribeFloorPlacementClicks(onClick) {
+    emitter.on('grid:click', onClick);
+    for (const kind of FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS) {
+        const key = `${kind}:click`;
+        emitter.on(key, onClick);
+    }
+    return () => {
+        emitter.off('grid:click', onClick);
+        for (const kind of FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS) {
+            const key = `${kind}:click`;
+            emitter.off(key, onClick);
+        }
+    };
+}
+export function subscribeFloorPlacementDoubleClicks(onDoubleClick) {
+    emitter.on('grid:double-click', onDoubleClick);
+    for (const kind of FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS) {
+        const key = `${kind}:double-click`;
+        emitter.on(key, onDoubleClick);
+    }
+    return () => {
+        emitter.off('grid:double-click', onDoubleClick);
+        for (const kind of FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS) {
+            const key = `${kind}:double-click`;
+            emitter.off(key, onDoubleClick);
+        }
+    };
+}

package/dist/shared/floorplan-cursor.d.ts

@@ -0,0 +1,11 @@
+import { type PlanarCursorPlacementMode, type PlanarPoint } from '@pascal-app/editor';
+type FloorplanCursorResolverOptions = {
+    snap?: (value: number) => number;
+};
+export declare function createFloorplanCursorResolver(args: {
+    original: readonly [number, number];
+    metadata?: unknown;
+    mode?: PlanarCursorPlacementMode;
+}): (planPoint: readonly [number, number], options?: FloorplanCursorResolverOptions) => PlanarPoint;
+export {};
+//# sourceMappingURL=floorplan-cursor.d.ts.map

package/dist/shared/floorplan-cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-cursor.d.ts","sourceRoot":"","sources":["../../src/shared/floorplan-cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,WAAW,EAEjB,MAAM,oBAAoB,CAAA;AAE3B,KAAK,8BAA8B,GAAG;IACpC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;CACjC,CAAA;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,yBAAyB,CAAA;CACjC,IAMG,WAAW,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,UAAS,8BAAmC,KAC3C,WAAW,CAWf"}

package/dist/shared/floorplan-cursor.js

@@ -0,0 +1,17 @@
+import { isFreshPlacementMetadata, resolvePlanarCursorPosition, } from '@pascal-app/editor';
+export function createFloorplanCursorResolver(args) {
+    const original = [args.original[0], args.original[1]];
+    const mode = args.mode ?? (isFreshPlacementMetadata(args.metadata) ? 'absolute' : 'relative');
+    let anchor = null;
+    return (planPoint, options = {}) => {
+        const resolved = resolvePlanarCursorPosition({
+            cursor: [planPoint[0], planPoint[1]],
+            original,
+            anchor,
+            mode,
+            ...(options.snap ? { snap: options.snap } : {}),
+        });
+        anchor = resolved.anchor;
+        return resolved.point;
+    };
+}

package/dist/shared/ghost-alignment.d.ts

@@ -0,0 +1,31 @@
+import { type AlignmentAnchor, type AnyNode, resolveAlignment } from '@pascal-app/core';
+/** XZ axis-aligned bounds (level-local meters). */
+export type Aabb2D = {
+    minX: number;
+    minZ: number;
+    maxX: number;
+    maxZ: number;
+};
+/**
+ * Figma-style alignment-snap threshold (meters), matching the generic
+ * `MoveRegistryNodeTool` and the 2D overlay — 8 cm gives a magnetic pull
+ * without fighting grid snap.
+ */
+export declare const GHOST_ALIGNMENT_THRESHOLD_M = 0.08;
+/**
+ * Alignment anchors of every OTHER node on the level — gathered once at
+ * drag-start (the scene graph is stable during an imperative ghost drag).
+ */
+export declare function collectGhostAlignmentCandidates(nodes: Readonly<Record<string, AnyNode>>, excludeId: string, levelId: string | null | undefined): AlignmentAnchor[];
+/**
+ * Resolve the alignment snap for a moving ghost whose footprint is the
+ * axis-aligned box `aabb`. Returns the XZ delta that snaps the box's edges
+ * onto a candidate plus the guide lines to publish (relative to the box's
+ * corners — "placement guideline shown relative to the bounding box").
+ */
+export declare function resolveGhostAlignment(nodeId: string, aabb: Aabb2D, candidates: AlignmentAnchor[]): {
+    dx: number;
+    dz: number;
+    guides: ReturnType<typeof resolveAlignment>['guides'];
+};
+//# sourceMappingURL=ghost-alignment.d.ts.map

package/dist/shared/ghost-alignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ghost-alignment.d.ts","sourceRoot":"","sources":["../../src/shared/ghost-alignment.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,OAAO,EAGZ,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAEzB,mDAAmD;AACnD,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/E;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,OAAO,CAAA;AAE/C;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACjC,eAAe,EAAE,CAEnB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,eAAe,EAAE,GAC5B;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAA;CAAE,CAQnF"}

package/dist/shared/ghost-alignment.js

@@ -0,0 +1,29 @@
+import { bboxCornerAnchors, collectAlignmentAnchors, resolveAlignment, } from '@pascal-app/core';
+/**
+ * Figma-style alignment-snap threshold (meters), matching the generic
+ * `MoveRegistryNodeTool` and the 2D overlay — 8 cm gives a magnetic pull
+ * without fighting grid snap.
+ */
+export const GHOST_ALIGNMENT_THRESHOLD_M = 0.08;
+/**
+ * Alignment anchors of every OTHER node on the level — gathered once at
+ * drag-start (the scene graph is stable during an imperative ghost drag).
+ */
+export function collectGhostAlignmentCandidates(nodes, excludeId, levelId) {
+    return collectAlignmentAnchors(nodes, excludeId, levelId);
+}
+/**
+ * Resolve the alignment snap for a moving ghost whose footprint is the
+ * axis-aligned box `aabb`. Returns the XZ delta that snaps the box's edges
+ * onto a candidate plus the guide lines to publish (relative to the box's
+ * corners — "placement guideline shown relative to the bounding box").
+ */
+export function resolveGhostAlignment(nodeId, aabb, candidates) {
+    const moving = bboxCornerAnchors(nodeId, aabb.minX, aabb.minZ, aabb.maxX, aabb.maxZ);
+    const result = resolveAlignment({
+        moving,
+        candidates,
+        threshold: GHOST_ALIGNMENT_THRESHOLD_M,
+    });
+    return { dx: result.snap?.dx ?? 0, dz: result.snap?.dz ?? 0, guides: result.guides };
+}

package/dist/shared/ghost-materials.d.ts

@@ -0,0 +1,29 @@
+import type { Object3D } from 'three';
+export declare const INVALID_GHOST_COLOR = 15680580;
+export declare const VALID_GHOST_COLOR = 2278750;
+/**
+ * Apply ghost material treatment to a preview mesh tree.
+ *
+ * Traverses the object tree, disables raycasting on all descendants (prevents
+ * cursor-ray starvation), and clones visible mesh materials to set translucency.
+ *
+ * Tint by state:
+ *   - `invalid` (red, opacity ~0.4): off-host or colliding — can't place here.
+ *   - `valid` (green, opacity ~0.45): on a host and placeable — the "go" cue.
+ *   - neither (opacity ~0.5, original color): a plain translucent preview.
+ * `invalid` wins if both are passed.
+ *
+ * Skips: meshes whose material.visible === false (door/window root hitbox) and
+ * children named 'cutout'.
+ *
+ * Returns cleanup that disposes only the cloned materials (never originals or geometry).
+ *
+ * @param root - The preview mesh tree (typically from buildDoorPreviewMesh / buildWindowPreviewMesh)
+ * @param opts - { invalid?, valid? } placement-state tint
+ * @returns Cleanup function that disposes the cloned materials
+ */
+export declare function applyGhost(root: Object3D, opts?: {
+    invalid?: boolean;
+    valid?: boolean;
+}): () => void;
+//# sourceMappingURL=ghost-materials.d.ts.map

package/dist/shared/ghost-materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ghost-materials.d.ts","sourceRoot":"","sources":["../../src/shared/ghost-materials.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,QAAQ,EAAa,MAAM,OAAO,CAAA;AAEhE,eAAO,MAAM,mBAAmB,WAAa,CAAA;AAC7C,eAAO,MAAM,iBAAiB,UAAa,CAAA;AAI3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,EACd,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAC5C,MAAM,IAAI,CAuDZ"}

package/dist/shared/ghost-materials.js

@@ -0,0 +1,81 @@
+'use client';
+export const INVALID_GHOST_COLOR = 0xef_44_44;
+export const VALID_GHOST_COLOR = 0x22_c5_5e;
+const NO_RAYCAST = (_raycaster, _intersects) => { };
+/**
+ * Apply ghost material treatment to a preview mesh tree.
+ *
+ * Traverses the object tree, disables raycasting on all descendants (prevents
+ * cursor-ray starvation), and clones visible mesh materials to set translucency.
+ *
+ * Tint by state:
+ *   - `invalid` (red, opacity ~0.4): off-host or colliding — can't place here.
+ *   - `valid` (green, opacity ~0.45): on a host and placeable — the "go" cue.
+ *   - neither (opacity ~0.5, original color): a plain translucent preview.
+ * `invalid` wins if both are passed.
+ *
+ * Skips: meshes whose material.visible === false (door/window root hitbox) and
+ * children named 'cutout'.
+ *
+ * Returns cleanup that disposes only the cloned materials (never originals or geometry).
+ *
+ * @param root - The preview mesh tree (typically from buildDoorPreviewMesh / buildWindowPreviewMesh)
+ * @param opts - { invalid?, valid? } placement-state tint
+ * @returns Cleanup function that disposes the cloned materials
+ */
+export function applyGhost(root, opts) {
+    const invalid = opts?.invalid ?? false;
+    const valid = !invalid && (opts?.valid ?? false);
+    const cloned = [];
+    root.traverse((obj) => {
+        // Disable raycast on every descendant to prevent cursor-ray starvation.
+        obj.raycast = NO_RAYCAST;
+        const mesh = obj;
+        if (!mesh.isMesh)
+            return;
+        if (mesh.name === 'cutout')
+            return;
+        const original = mesh.material;
+        const wasArray = Array.isArray(original);
+        const cloneOne = (mat) => {
+            // Skip invisible materials (door/window root hitbox).
+            if (mat.visible === false)
+                return null;
+            const clone = mat.clone();
+            clone.transparent = true;
+            clone.depthWrite = false;
+            if (invalid) {
+                ;
+                clone.color?.setHex(INVALID_GHOST_COLOR);
+                clone.emissive?.setHex(INVALID_GHOST_COLOR);
+                clone.opacity = 0.4;
+            }
+            else if (valid) {
+                ;
+                clone.color?.setHex(VALID_GHOST_COLOR);
+                clone.emissive?.setHex(VALID_GHOST_COLOR);
+                clone.opacity = 0.45;
+            }
+            else {
+                clone.opacity = 0.5;
+            }
+            cloned.push(clone);
+            return clone;
+        };
+        if (wasArray) {
+            const clonedMats = original.map(cloneOne).filter((m) => m !== null);
+            if (clonedMats.length > 0)
+                mesh.material = clonedMats;
+        }
+        else {
+            const clone = cloneOne(original);
+            if (clone)
+                mesh.material = clone;
+        }
+    });
+    return () => {
+        for (const mat of cloned) {
+            mat.dispose();
+        }
+    };
+}

package/dist/shared/level-offset-group.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from 'react';
+/**
+ * Wraps a placement tool's preview/ghost so it rides the active level's
+ * stacked elevation.
+ *
+ * Placement tools are mounted inside the building-local group (see the editor's
+ * ToolManager), which carries no per-floor elevation. But their points, ports,
+ * and committed paths are level-local (Y=0 = the floor) and the committed nodes
+ * parent to the level mesh, which DOES carry the stacked Y offset. Without this
+ * the ghost renders at world ground on upper floors while the cursor raycast
+ * rides the floor plane — they drift apart. Tracking the level mesh's Y here
+ * (the same value the grid plane follows) keeps the preview on the floor being
+ * drawn, with no change to any tool's level-local math.
+ */
+export declare function LevelOffsetGroup({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=level-offset-group.d.ts.map

package/dist/shared/level-offset-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-offset-group.d.ts","sourceRoot":"","sources":["../../src/shared/level-offset-group.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,SAAS,EAAU,MAAM,OAAO,CAAA;AAG9C;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,+BAYrE"}

package/dist/shared/level-offset-group.js

@@ -0,0 +1,31 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { sceneRegistry } from '@pascal-app/core';
+import { useViewer } from '@pascal-app/viewer';
+import { useFrame } from '@react-three/fiber';
+import { useRef } from 'react';
+/**
+ * Wraps a placement tool's preview/ghost so it rides the active level's
+ * stacked elevation.
+ *
+ * Placement tools are mounted inside the building-local group (see the editor's
+ * ToolManager), which carries no per-floor elevation. But their points, ports,
+ * and committed paths are level-local (Y=0 = the floor) and the committed nodes
+ * parent to the level mesh, which DOES carry the stacked Y offset. Without this
+ * the ghost renders at world ground on upper floors while the cursor raycast
+ * rides the floor plane — they drift apart. Tracking the level mesh's Y here
+ * (the same value the grid plane follows) keeps the preview on the floor being
+ * drawn, with no change to any tool's level-local math.
+ */
+export function LevelOffsetGroup({ children }) {
+    const activeLevelId = useViewer((s) => s.selection.levelId);
+    const ref = useRef(null);
+    useFrame(() => {
+        const group = ref.current;
+        if (!group)
+            return;
+        const levelMesh = activeLevelId ? sceneRegistry.nodes.get(activeLevelId) : null;
+        group.position.y = levelMesh ? levelMesh.position.y : 0;
+    });
+    return _jsx("group", { ref: ref, children: children });
+}

package/dist/shared/mep-ghost.d.ts

@@ -0,0 +1,37 @@
+import type { DuctFittingNode, DuctSegmentNode, PipeFittingNode, PipeSegmentNode } from '@pascal-app/core';
+/** Indigo-400 — the shared MEP preview accent (matches the draw-tool ghost). */
+export declare const GHOST_COLOR = "#818cf8";
+export declare const GHOST_OPACITY = 0.55;
+/** Tint state for an auto-routed offset preview: green = a buildable offset
+ *  that will mint on release, red = no valid offset at this height (the run
+ *  lifts as a preview only and snaps back). Undefined = the neutral indigo
+ *  preview used everywhere else. */
+export type GhostTint = 'valid' | 'invalid' | undefined;
+/**
+ * Translucent ghost of a duct fitting, built from the same geometry the
+ * placed node uses so the preview matches the result. The node carries its
+ * level-local `position` / `rotation`, applied here on the group (the
+ * renderer normally bakes that in).
+ */
+export declare function FittingGhost({ fitting, tint }: {
+    fitting: DuctFittingNode;
+    tint?: GhostTint;
+}): import("react").JSX.Element;
+/**
+ * Translucent ghost of a duct-segment run. Path coords are level-local and
+ * the node's transform is identity, so the built group renders at the origin
+ * — the same frame the fitting ghosts use.
+ */
+export declare function DuctSegmentGhost({ duct, tint }: {
+    duct: DuctSegmentNode;
+    tint?: GhostTint;
+}): import("react").JSX.Element;
+export declare function PipeFittingGhost({ fitting, tint, }: {
+    fitting: PipeFittingNode;
+    tint?: GhostTint;
+}): import("react").JSX.Element;
+export declare function PipeSegmentGhost({ pipe, tint }: {
+    pipe: PipeSegmentNode;
+    tint?: GhostTint;
+}): import("react").JSX.Element;
+//# sourceMappingURL=mep-ghost.d.ts.map

package/dist/shared/mep-ghost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mep-ghost.d.ts","sourceRoot":"","sources":["../../src/shared/mep-ghost.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,eAAe,EACf,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAUzB,gFAAgF;AAChF,eAAO,MAAM,WAAW,YAAY,CAAA;AACpC,eAAO,MAAM,aAAa,OAAO,CAAA;AAEjC;;;oCAGoC;AACpC,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAA;AAyBvD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;IAAE,OAAO,EAAE,eAAe,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAA;CAAE,+BAS7F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAA;CAAE,+BAO3F;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,OAAO,EACP,IAAI,GACL,EAAE;IACD,OAAO,EAAE,eAAe,CAAA;IACxB,IAAI,CAAC,EAAE,SAAS,CAAA;CACjB,+BASA;AAED,wBAAgB,gBAAgB,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAA;CAAE,+BAO3F"}

package/dist/shared/mep-ghost.js

@@ -0,0 +1,83 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { useMemo } from 'react';
+import { Mesh, MeshBasicMaterial } from 'three';
+import { buildDuctFittingGeometry } from '../duct-fitting/geometry';
+import { buildDuctSegmentGeometry } from '../duct-segment/geometry';
+import { buildPipeFittingGeometry } from '../pipe-fitting/geometry';
+import { buildPipeSegmentGeometry } from '../pipe-segment/geometry';
+import { INVALID_GHOST_COLOR, VALID_GHOST_COLOR } from './ghost-materials';
+/** Indigo-400 — the shared MEP preview accent (matches the draw-tool ghost). */
+export const GHOST_COLOR = '#818cf8';
+export const GHOST_OPACITY = 0.55;
+function ghostColor(tint) {
+    if (tint === 'valid')
+        return VALID_GHOST_COLOR;
+    if (tint === 'invalid')
+        return INVALID_GHOST_COLOR;
+    return GHOST_COLOR;
+}
+/** Repaint every mesh in `group` as a translucent, depth-test-free preview. */
+function ghostify(group, tint) {
+    const color = ghostColor(tint);
+    group.traverse((child) => {
+        if (child instanceof Mesh) {
+            child.layers.set(EDITOR_LAYER);
+            child.material = new MeshBasicMaterial({
+                color,
+                depthTest: false,
+                transparent: true,
+                opacity: GHOST_OPACITY,
+            });
+            child.renderOrder = 999;
+        }
+    });
+}
+/**
+ * Translucent ghost of a duct fitting, built from the same geometry the
+ * placed node uses so the preview matches the result. The node carries its
+ * level-local `position` / `rotation`, applied here on the group (the
+ * renderer normally bakes that in).
+ */
+export function FittingGhost({ fitting, tint }) {
+    const ghost = useMemo(() => {
+        const group = buildDuctFittingGeometry(fitting);
+        group.position.set(...fitting.position);
+        group.rotation.set(fitting.rotation[0], fitting.rotation[1], fitting.rotation[2]);
+        ghostify(group, tint);
+        return group;
+    }, [fitting, tint]);
+    return _jsx("primitive", { object: ghost });
+}
+/**
+ * Translucent ghost of a duct-segment run. Path coords are level-local and
+ * the node's transform is identity, so the built group renders at the origin
+ * — the same frame the fitting ghosts use.
+ */
+export function DuctSegmentGhost({ duct, tint }) {
+    const ghost = useMemo(() => {
+        const group = buildDuctSegmentGeometry(duct);
+        ghostify(group, tint);
+        return group;
+    }, [duct, tint]);
+    return _jsx("primitive", { object: ghost });
+}
+export function PipeFittingGhost({ fitting, tint, }) {
+    const ghost = useMemo(() => {
+        const group = buildPipeFittingGeometry(fitting);
+        group.position.set(...fitting.position);
+        group.rotation.set(fitting.rotation[0], fitting.rotation[1], fitting.rotation[2]);
+        ghostify(group, tint);
+        return group;
+    }, [fitting, tint]);
+    return _jsx("primitive", { object: ghost });
+}
+export function PipeSegmentGhost({ pipe, tint }) {
+    const ghost = useMemo(() => {
+        const group = buildPipeSegmentGeometry(pipe);
+        ghostify(group, tint);
+        return group;
+    }, [pipe, tint]);
+    return _jsx("primitive", { object: ghost });
+}

package/dist/shared/move-roof-tool.d.ts

@@ -0,0 +1,6 @@
+import { type RoofNode, type RoofSegmentNode, type StairNode, type StairSegmentNode } from '@pascal-app/core';
+export declare const MoveRoofTool: React.FC<{
+    node: RoofNode | RoofSegmentNode | StairNode | StairSegmentNode;
+}>;
+export default MoveRoofTool;
+//# sourceMappingURL=move-roof-tool.d.ts.map

package/dist/shared/move-roof-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-roof-tool.d.ts","sourceRoot":"","sources":["../../src/shared/move-roof-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,QAAQ,EACb,KAAK,eAAe,EAEpB,KAAK,SAAS,EACd,KAAK,gBAAgB,EAMtB,MAAM,kBAAkB,CAAA;AAwDzB,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAClC,IAAI,EAAE,QAAQ,GAAG,eAAe,GAAG,SAAS,GAAG,gBAAgB,CAAA;CAChE,CAqeA,CAAA;AAED,eAAe,YAAY,CAAA"}