@pascal-app/nodes 0.1.1

package/dist/shared/auto-offset-tag.d.ts

@@ -0,0 +1,67 @@
+import type { AnyNode, AnyNodeId } from '@pascal-app/core';
+/**
+ * Tag + rewind bookkeeping for auto-routed vertical offsets.
+ *
+ * When a connected duct run is lifted with the run-center ±Y arrows, the
+ * planner welds it back to its stationary partner with an auto-routed Z/S
+ * offset — elbows + a plumb riser (see `vertical-offset.ts`). On commit we
+ * stamp the LIFTED RUN with an `autoOffset` tag in its `metadata` recording:
+ *   - the minted nodes (elbows + risers) that formed the offset, and
+ *   - the `base` patches that restore the run + its partners to the LOGICAL L
+ *     they sprang from (the canonical corner, before any offset).
+ *
+ * That tag lets a LATER drag dissolve the offset and replan from the clean L:
+ * at drag start we rewind (delete the minted nodes, apply the base patches),
+ * plan a fresh offset from the logical L, and commit the result — so dragging
+ * back toward the original height collapses the Z back to an L, and re-lifting
+ * forms a new one. The `base` moves when the whole tagged offset is translated
+ * and is refreshed when fitting edits retarget its collars; otherwise a later
+ * re-drag would rewind to stale geometry.
+ *
+ * The tag lives only on the run (detection keys off the dragged run), not on
+ * the minted fittings / risers.
+ */
+/** Key under a node's `metadata` JSON bag where the offset tag is stored. */
+export declare const AUTO_OFFSET_KEY = "autoOffset";
+/** A logical-L restore patch: a node id plus the field subset that returns it
+ *  to its pre-offset pose (a run's `path`, or a fitting's `position` /
+ *  `rotation` / `angle`). */
+export type AutoOffsetBasePatch = {
+    id: AnyNodeId;
+    data: Record<string, unknown>;
+};
+export type AutoOffsetTag = {
+    /** Stable id shared by every node in this offset (currently only the run
+     *  carries the tag, but the group id lets future selections relate them). */
+    group: string;
+    /** The vertical lift (meters, signed) from the logical L that formed this
+     *  offset. A re-drag plans from the L with `dy + delta`, so grabbing the run
+     *  with no movement reproduces this exact Z, and dragging it down by `dy`
+     *  lands back on the L. Invariant inputs (L + dy) make the re-plan match the
+     *  committed geometry. */
+    dy: number;
+    /** The elbows + risers minted to form this offset — deleted on rewind. */
+    minted: AnyNodeId[];
+    /** Patches restoring the run + partners to the current logical L. */
+    base: AutoOffsetBasePatch[];
+};
+type Point = [number, number, number];
+/** The offset tag on `node`, or null if it carries none / a malformed one. */
+export declare function readAutoOffsetTag(node: {
+    metadata?: unknown;
+} | null | undefined): AutoOffsetTag | null;
+/** `metadata` with the offset tag set (replacing any prior one). */
+export declare function withAutoOffsetTag(metadata: unknown, tag: AutoOffsetTag): Record<string, unknown>;
+/** `metadata` with the offset tag removed — the run is a clean L again. */
+export declare function withoutAutoOffsetTag(metadata: unknown): Record<string, unknown>;
+/** Translate the logical-L base when the whole tagged offset is moved rigidly. */
+export declare function translateAutoOffsetBase(tag: AutoOffsetTag, delta: Point): AutoOffsetTag;
+/** Scene updates that drop auto-offset ownership when a participating part is edited manually. */
+export declare function autoOffsetInvalidationUpdates(nodes: Record<string, AnyNode>, editedNodeId: AnyNodeId): {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+}[];
+/** A fresh, scene-unique-enough group id for a newly minted offset. */
+export declare function newAutoOffsetGroupId(): string;
+export {};
+//# sourceMappingURL=auto-offset-tag.d.ts.map

package/dist/shared/auto-offset-tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-offset-tag.d.ts","sourceRoot":"","sources":["../../src/shared/auto-offset-tag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,6EAA6E;AAC7E,eAAO,MAAM,eAAe,eAAe,CAAA;AAE3C;;6BAE6B;AAC7B,MAAM,MAAM,mBAAmB,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAA;AAElF,MAAM,MAAM,aAAa,GAAG;IAC1B;iFAC6E;IAC7E,KAAK,EAAE,MAAM,CAAA;IACb;;;;8BAI0B;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,0EAA0E;IAC1E,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,qEAAqE;IACrE,IAAI,EAAE,mBAAmB,EAAE,CAAA;CAC5B,CAAA;AAED,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAoBrC,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GAC9C,aAAa,GAAG,IAAI,CAYtB;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEhG;AAED,2EAA2E;AAC3E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAG/E;AAED,kFAAkF;AAClF,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,GAAG,aAAa,CAgBvF;AAED,kGAAkG;AAClG,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,YAAY,EAAE,SAAS,GACtB;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,CAa7C;AAED,uEAAuE;AACvE,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}

package/dist/shared/auto-offset-tag.js

@@ -0,0 +1,94 @@
+/**
+ * Tag + rewind bookkeeping for auto-routed vertical offsets.
+ *
+ * When a connected duct run is lifted with the run-center ±Y arrows, the
+ * planner welds it back to its stationary partner with an auto-routed Z/S
+ * offset — elbows + a plumb riser (see `vertical-offset.ts`). On commit we
+ * stamp the LIFTED RUN with an `autoOffset` tag in its `metadata` recording:
+ *   - the minted nodes (elbows + risers) that formed the offset, and
+ *   - the `base` patches that restore the run + its partners to the LOGICAL L
+ *     they sprang from (the canonical corner, before any offset).
+ *
+ * That tag lets a LATER drag dissolve the offset and replan from the clean L:
+ * at drag start we rewind (delete the minted nodes, apply the base patches),
+ * plan a fresh offset from the logical L, and commit the result — so dragging
+ * back toward the original height collapses the Z back to an L, and re-lifting
+ * forms a new one. The `base` moves when the whole tagged offset is translated
+ * and is refreshed when fitting edits retarget its collars; otherwise a later
+ * re-drag would rewind to stale geometry.
+ *
+ * The tag lives only on the run (detection keys off the dragged run), not on
+ * the minted fittings / risers.
+ */
+/** Key under a node's `metadata` JSON bag where the offset tag is stored. */
+export const AUTO_OFFSET_KEY = 'autoOffset';
+function metaRecord(metadata) {
+    return metadata && typeof metadata === 'object' ? metadata : {};
+}
+function isPoint(value) {
+    return (Array.isArray(value) &&
+        value.length >= 3 &&
+        typeof value[0] === 'number' &&
+        typeof value[1] === 'number' &&
+        typeof value[2] === 'number');
+}
+function translatePoint(point, delta) {
+    return [point[0] + delta[0], point[1] + delta[1], point[2] + delta[2]];
+}
+/** The offset tag on `node`, or null if it carries none / a malformed one. */
+export function readAutoOffsetTag(node) {
+    const tag = metaRecord(node?.metadata)[AUTO_OFFSET_KEY];
+    if (!tag || typeof tag !== 'object')
+        return null;
+    if (typeof tag.group !== 'string' ||
+        typeof tag.dy !== 'number' ||
+        !Array.isArray(tag.minted) ||
+        !Array.isArray(tag.base)) {
+        return null;
+    }
+    return tag;
+}
+/** `metadata` with the offset tag set (replacing any prior one). */
+export function withAutoOffsetTag(metadata, tag) {
+    return { ...metaRecord(metadata), [AUTO_OFFSET_KEY]: tag };
+}
+/** `metadata` with the offset tag removed — the run is a clean L again. */
+export function withoutAutoOffsetTag(metadata) {
+    const { [AUTO_OFFSET_KEY]: _omit, ...rest } = metaRecord(metadata);
+    return rest;
+}
+/** Translate the logical-L base when the whole tagged offset is moved rigidly. */
+export function translateAutoOffsetBase(tag, delta) {
+    return {
+        ...tag,
+        base: tag.base.map((patch) => {
+            const data = { ...patch.data };
+            if (Array.isArray(data.path)) {
+                data.path = data.path.map((point) => isPoint(point) ? translatePoint(point, delta) : point);
+            }
+            if (isPoint(data.position)) {
+                data.position = translatePoint(data.position, delta);
+            }
+            return { ...patch, data };
+        }),
+    };
+}
+/** Scene updates that drop auto-offset ownership when a participating part is edited manually. */
+export function autoOffsetInvalidationUpdates(nodes, editedNodeId) {
+    const updates = [];
+    for (const node of Object.values(nodes)) {
+        const tag = readAutoOffsetTag(node);
+        const participates = tag?.minted.includes(editedNodeId) || tag?.base.some((patch) => patch.id === editedNodeId);
+        if (!participates)
+            continue;
+        updates.push({
+            id: node.id,
+            data: { metadata: withoutAutoOffsetTag(node.metadata) },
+        });
+    }
+    return updates;
+}
+/** A fresh, scene-unique-enough group id for a newly minted offset. */
+export function newAutoOffsetGroupId() {
+    return `aoff_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+}

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

@@ -0,0 +1,25 @@
+type Vec3 = [number, number, number];
+/**
+ * Layer Figma-style alignment guides onto a draw-tool cursor point so HVAC /
+ * DWV runs and equipment line up with each other (and every other node) while
+ * being drawn — the same feedback walls get.
+ *
+ * Treats the point as a single corner anchor, gathers candidates from the live
+ * scene (every kind contributes via `nodeAlignmentAnchors`), publishes the
+ * guides to `useAlignmentGuides` (rendered in BOTH the 2D floor plan and the
+ * 3D view), and returns the point with the snap applied. Y is preserved — only
+ * XZ is aligned.
+ *
+ * - `applySnap: false` publishes the guide passively without pulling the point
+ *   off a constrained ray (e.g. an angle-locked run continuation).
+ * - `bypass: true` clears guides and returns the point untouched (Alt, or when
+ *   a stronger port / run-body snap already won).
+ */
+export declare function alignDrawPoint(point: Vec3, opts: {
+    applySnap: boolean;
+    bypass?: boolean;
+}): Vec3;
+/** Drop any alignment guides this tool published (cancel / commit / unmount). */
+export declare function clearDrawAlignment(): void;
+export {};
+//# sourceMappingURL=draw-alignment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"draw-alignment.d.ts","sourceRoot":"","sources":["../../src/shared/draw-alignment.ts"],"names":[],"mappings":"AAIA,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAOhG;AAED,iFAAiF;AACjF,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/dist/shared/draw-alignment.js

@@ -0,0 +1,30 @@
+'use client';
+import { alignFloorplanDraftPoint, useAlignmentGuides } from '@pascal-app/editor';
+/**
+ * Layer Figma-style alignment guides onto a draw-tool cursor point so HVAC /
+ * DWV runs and equipment line up with each other (and every other node) while
+ * being drawn — the same feedback walls get.
+ *
+ * Treats the point as a single corner anchor, gathers candidates from the live
+ * scene (every kind contributes via `nodeAlignmentAnchors`), publishes the
+ * guides to `useAlignmentGuides` (rendered in BOTH the 2D floor plan and the
+ * 3D view), and returns the point with the snap applied. Y is preserved — only
+ * XZ is aligned.
+ *
+ * - `applySnap: false` publishes the guide passively without pulling the point
+ *   off a constrained ray (e.g. an angle-locked run continuation).
+ * - `bypass: true` clears guides and returns the point untouched (Alt, or when
+ *   a stronger port / run-body snap already won).
+ */
+export function alignDrawPoint(point, opts) {
+    if (opts.bypass) {
+        useAlignmentGuides.getState().clear();
+        return point;
+    }
+    const [x, z] = alignFloorplanDraftPoint([point[0], point[2]], { applySnap: opts.applySnap });
+    return [x, point[1], z];
+}
+/** Drop any alignment guides this tool published (cancel / commit / unmount). */
+export function clearDrawAlignment() {
+    useAlignmentGuides.getState().clear();
+}

package/dist/shared/duct-body-paint.d.ts

@@ -0,0 +1,6 @@
+import type { SlotDeclaration } from '@pascal-app/core';
+export declare const DUCT_BODY_SLOT_ID = "body";
+export declare const DUCT_BODY_SLOT_DEFAULT = "#ffffff";
+export declare function ductBodySlots(): SlotDeclaration[];
+export declare const ductBodyPaint: import("@pascal-app/core").PaintCapability;
+//# sourceMappingURL=duct-body-paint.d.ts.map

package/dist/shared/duct-body-paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duct-body-paint.d.ts","sourceRoot":"","sources":["../../src/shared/duct-body-paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGvD,eAAO,MAAM,iBAAiB,SAAS,CAAA;AACvC,eAAO,MAAM,sBAAsB,YAAY,CAAA;AAE/C,wBAAgB,aAAa,IAAI,eAAe,EAAE,CAEjD;AAED,eAAO,MAAM,aAAa,4CAMxB,CAAA"}

package/dist/shared/duct-body-paint.js

@@ -0,0 +1,13 @@
+import { createSlotPaintCapability, previewGeometrySlot } from './slot-paint';
+export const DUCT_BODY_SLOT_ID = 'body';
+export const DUCT_BODY_SLOT_DEFAULT = '#ffffff';
+export function ductBodySlots() {
+    return [{ slotId: DUCT_BODY_SLOT_ID, label: 'Body', default: DUCT_BODY_SLOT_DEFAULT }];
+}
+export const ductBodyPaint = createSlotPaintCapability({
+    resolveRole: ({ hitObject }) => {
+        const slotId = hitObject?.userData?.slotId;
+        return slotId === DUCT_BODY_SLOT_ID ? DUCT_BODY_SLOT_ID : null;
+    },
+    applyPreview: previewGeometrySlot,
+});

package/dist/shared/fitting-endpoint-reaim.d.ts

@@ -0,0 +1,72 @@
+import type { AnyNode, AnyNodeId, DuctFittingNode, PipeFittingNode } from '@pascal-app/core';
+/**
+ * Shared "drag a run end, the connected fitting re-aims" logic for the
+ * selection-time endpoint drag — duct (`duct-segment`) and DWV pipe
+ * (`pipe-segment`) alike, plus their 2D `move-path-point` twins.
+ *
+ * Two re-aim shapes share this path:
+ *
+ *  - **Elbow** (duct + pipe): when you grab the free end of a straight run
+ *    whose OTHER end sits on an elbow collar, the elbow's junction and far
+ *    (mated) collar stay put while the near collar swings to face the
+ *    dragged end — the bend `angle` adjusts to fit. Mirrors a wall corner.
+ *
+ *  - **Tee branch** (duct only): when you grab the free end of a run mated
+ *    to a tee's BRANCH collar, the tee's run legs stay locked to the trunk
+ *    and only its `branchAngle` swings, so the branch keeps pointing at the
+ *    dragged end.
+ *
+ * Detection runs ONCE at drag start (`detectFittingEndpoint`) against a
+ * snapshot of the fitting; the per-frame plan (`planFittingEndpointReaim`)
+ * always re-derives from that original snapshot, so live mutation of the
+ * fitting never compounds.
+ */
+type Point = [number, number, number];
+/** Which run kind we're editing decides which fitting kind to look for. */
+type ReaimFitting = DuctFittingNode | PipeFittingNode;
+export type FittingEndpoint = {
+    /** The fitting node as it stood at drag start (the stable reference). */
+    fitting: ReaimFitting;
+    /** Whether the re-aim re-orients the whole elbow body or just swings a
+     *  duct tee's branch lean. */
+    reaim: 'elbow' | 'tee-branch';
+    /** Which fitting collar the run's non-dragged end is mated to. */
+    portId: 'inlet' | 'outlet' | 'branch';
+    /** The fitting kind, so the per-frame plan calls the right realign. */
+    fittingType: 'duct-fitting' | 'pipe-fitting';
+    /** Patch that restores the fitting to its drag-start state, for the
+     *  single-undo dance's pre-resume revert. */
+    revert: {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    };
+};
+export type FittingEndpointReaimPlan = {
+    /** New path for the dragged run: the dragged end at the cursor, the
+     *  fitting end pulled onto the re-aimed collar. */
+    path: Point[];
+    /** Patch re-aiming the fitting (elbow: angle + rotation; tee: branchAngle). */
+    fittingUpdate: {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    };
+};
+/**
+ * If `runPath` is a straight two-point run whose NON-dragged end sits on a
+ * fitting collar that can re-aim, return that fitting snapshot + the mated
+ * port id and re-aim shape. `runKind` selects which fitting kind to scan
+ * for. Elbow inlet/outlet collars re-aim the whole elbow; a duct tee's
+ * branch collar swings only the branch. Otherwise null — the caller falls
+ * back to plain free-drag.
+ */
+export declare function detectFittingEndpoint(runKind: string, runPath: ReadonlyArray<readonly [number, number, number]>, draggedIndex: number, nodes: Record<string, AnyNode>): FittingEndpoint | null;
+/**
+ * Plan the run path + fitting re-aim for the dragged end at `draggedPoint`.
+ * The fitting swings its mated collar to face the junction→cursor direction;
+ * the run goes from that collar to the cursor. Returns null when the
+ * required turn falls outside the fitting's buildable range (caller keeps
+ * the plain free-drag for that frame).
+ */
+export declare function planFittingEndpointReaim(endpoint: FittingEndpoint, draggedIndex: number, draggedPoint: Point): FittingEndpointReaimPlan | null;
+export {};
+//# sourceMappingURL=fitting-endpoint-reaim.d.ts.map

package/dist/shared/fitting-endpoint-reaim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitting-endpoint-reaim.d.ts","sourceRoot":"","sources":["../../src/shared/fitting-endpoint-reaim.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAK5F;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAMrC,2EAA2E;AAC3E,KAAK,YAAY,GAAG,eAAe,GAAG,eAAe,CAAA;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,yEAAyE;IACzE,OAAO,EAAE,YAAY,CAAA;IACrB;kCAC8B;IAC9B,KAAK,EAAE,OAAO,GAAG,YAAY,CAAA;IAC7B,kEAAkE;IAClE,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAA;IACrC,uEAAuE;IACvE,WAAW,EAAE,cAAc,GAAG,cAAc,CAAA;IAC5C;iDAC6C;IAC7C,MAAM,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAA;CAClD,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC;uDACmD;IACnD,IAAI,EAAE,KAAK,EAAE,CAAA;IACb,+EAA+E;IAC/E,aAAa,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAA;CACzD,CAAA;AAiBD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EACzD,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,eAAe,GAAG,IAAI,CA+CxB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,eAAe,EACzB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,KAAK,GAClB,wBAAwB,GAAG,IAAI,CAkCjC"}

package/dist/shared/fitting-endpoint-reaim.js

@@ -0,0 +1,123 @@
+import { getDuctFittingPorts } from '../duct-fitting/ports';
+import { getPipeFittingPorts } from '../pipe-fitting/ports';
+import { planElbowRealign, planPipeElbowRealign, planTeeBranchRealign } from './auto-fitting';
+/** Distance (m) under which a run end counts as sitting on a fitting collar —
+ *  matches core's port-coincidence epsilon. */
+const COINCIDENT_EPS_M = 0.05;
+/** A run kind ('duct-segment' / 'pipe-segment') → the fitting kind it
+ *  mates to. Anything else has no re-aim. */
+function fittingTypeForRun(runKind) {
+    if (runKind === 'duct-segment')
+        return 'duct-fitting';
+    if (runKind === 'pipe-segment')
+        return 'pipe-fitting';
+    return null;
+}
+function distSq(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return dx * dx + dy * dy + dz * dz;
+}
+/**
+ * If `runPath` is a straight two-point run whose NON-dragged end sits on a
+ * fitting collar that can re-aim, return that fitting snapshot + the mated
+ * port id and re-aim shape. `runKind` selects which fitting kind to scan
+ * for. Elbow inlet/outlet collars re-aim the whole elbow; a duct tee's
+ * branch collar swings only the branch. Otherwise null — the caller falls
+ * back to plain free-drag.
+ */
+export function detectFittingEndpoint(runKind, runPath, draggedIndex, nodes) {
+    if (runPath.length !== 2)
+        return null;
+    const fittingType = fittingTypeForRun(runKind);
+    if (!fittingType)
+        return null;
+    const fittingEnd = runPath[draggedIndex === 0 ? 1 : 0];
+    const eps2 = COINCIDENT_EPS_M * COINCIDENT_EPS_M;
+    for (const node of Object.values(nodes)) {
+        if (!node || node.type !== fittingType)
+            continue;
+        const fitting = node;
+        const isElbow = fitting.fittingType === 'elbow';
+        // Tee-branch re-aim is duct-only (a sanitary tee has no adjustable
+        // branch lean).
+        const isDuctTee = fittingType === 'duct-fitting' && fitting.fittingType === 'tee';
+        if (!isElbow && !isDuctTee)
+            continue;
+        const ports = fittingType === 'duct-fitting'
+            ? getDuctFittingPorts(fitting)
+            : getPipeFittingPorts(fitting);
+        for (const port of ports) {
+            if (isElbow && port.id !== 'inlet' && port.id !== 'outlet')
+                continue;
+            if (isDuctTee && port.id !== 'branch')
+                continue;
+            if (distSq(port.position, fittingEnd) > eps2)
+                continue;
+            if (isElbow) {
+                return {
+                    fitting,
+                    reaim: 'elbow',
+                    portId: port.id,
+                    fittingType,
+                    revert: {
+                        id: fitting.id,
+                        data: { angle: fitting.angle, rotation: fitting.rotation },
+                    },
+                };
+            }
+            return {
+                fitting,
+                reaim: 'tee-branch',
+                portId: 'branch',
+                fittingType,
+                revert: {
+                    id: fitting.id,
+                    data: { branchAngle: fitting.branchAngle },
+                },
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Plan the run path + fitting re-aim for the dragged end at `draggedPoint`.
+ * The fitting swings its mated collar to face the junction→cursor direction;
+ * the run goes from that collar to the cursor. Returns null when the
+ * required turn falls outside the fitting's buildable range (caller keeps
+ * the plain free-drag for that frame).
+ */
+export function planFittingEndpointReaim(endpoint, draggedIndex, draggedPoint) {
+    const { fitting, reaim, portId, fittingType } = endpoint;
+    const j = fitting.position;
+    const away = [draggedPoint[0] - j[0], draggedPoint[1] - j[1], draggedPoint[2] - j[2]];
+    if (away[0] * away[0] + away[1] * away[1] + away[2] * away[2] < 1e-10)
+        return null;
+    if (reaim === 'tee-branch') {
+        const realign = planTeeBranchRealign(fitting, away);
+        if (!realign)
+            return null;
+        const path = draggedIndex === 0 ? [draggedPoint, realign.collarPoint] : [realign.collarPoint, draggedPoint];
+        return {
+            path,
+            fittingUpdate: {
+                id: realign.update.id,
+                data: realign.update.data,
+            },
+        };
+    }
+    const realign = fittingType === 'duct-fitting'
+        ? planElbowRealign(fitting, portId, away)
+        : planPipeElbowRealign(fitting, portId, away);
+    if (!realign)
+        return null;
+    const path = draggedIndex === 0 ? [draggedPoint, realign.collarPoint] : [realign.collarPoint, draggedPoint];
+    return {
+        path,
+        fittingUpdate: {
+            id: realign.update.id,
+            data: realign.update.data,
+        },
+    };
+}

package/dist/shared/fitting-rotation.d.ts

@@ -0,0 +1,21 @@
+import { type AnyNode } from '@pascal-app/core';
+import { Vector3 } from 'three';
+/** R/T rotation step — 45°, matching the editor's default rotate. */
+export declare const ROTATE_STEP_RAD: number;
+export type RotationAxis = 'x' | 'y' | 'z';
+export declare const AXIS_VECTORS: Record<RotationAxis, Vector3>;
+export declare const getRotationAxis: () => RotationAxis;
+export declare const cycleRotationAxis: () => RotationAxis;
+/**
+ * Compose a world-frame rotation around `axis` onto an existing euler.
+ * World-frame (premultiply) so the axes the user cycles through always
+ * mean the screen-space X/Y/Z they expect, regardless of how the fitting
+ * is already turned.
+ */
+export declare function rotateEulerWorld(rotation: readonly [number, number, number], axis: RotationAxis, steps: 1 | -1): [number, number, number];
+/**
+ * R / T keyboard action for a placed fitting — rotate ±45° around the
+ * shared active axis (Alt cycles it; see `selection.tsx`).
+ */
+export declare function rotateFittingNode(node: AnyNode, steps: 1 | -1): void;
+//# sourceMappingURL=fitting-rotation.d.ts.map

package/dist/shared/fitting-rotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitting-rotation.d.ts","sourceRoot":"","sources":["../../src/shared/fitting-rotation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAY,MAAM,kBAAkB,CAAA;AAEzD,OAAO,EAAqB,OAAO,EAAE,MAAM,OAAO,CAAA;AAGlD,qEAAqE;AACrE,eAAO,MAAM,eAAe,QAAc,CAAA;AAE1C,MAAM,MAAM,YAAY,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;AAE1C,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,OAAO,CAItD,CAAA;AAMD,eAAO,MAAM,eAAe,QAAO,YAAiD,CAAA;AACpF,eAAO,MAAM,iBAAiB,QAAO,YAAwD,CAAA;AAE7F;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC3C,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,GACZ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAK1B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAMpE"}

package/dist/shared/fitting-rotation.js

@@ -0,0 +1,39 @@
+import { useScene } from '@pascal-app/core';
+import { triggerSFX, useEditor } from '@pascal-app/editor';
+import { Euler, Quaternion, Vector3 } from 'three';
+/** R/T rotation step — 45°, matching the editor's default rotate. */
+export const ROTATE_STEP_RAD = Math.PI / 4;
+export const AXIS_VECTORS = {
+    x: new Vector3(1, 0, 0),
+    y: new Vector3(0, 1, 0),
+    z: new Vector3(0, 0, 1),
+};
+// The active axis lives on `useEditor` (not a module store) so the
+// floating action menu — which can't import this package — surfaces it
+// in the pill above a selected fitting. Tool + keyboard actions share
+// the same state, so Alt-cycling in either context drives both.
+export const getRotationAxis = () => useEditor.getState().rotationAxis;
+export const cycleRotationAxis = () => useEditor.getState().cycleRotationAxis();
+/**
+ * Compose a world-frame rotation around `axis` onto an existing euler.
+ * World-frame (premultiply) so the axes the user cycles through always
+ * mean the screen-space X/Y/Z they expect, regardless of how the fitting
+ * is already turned.
+ */
+export function rotateEulerWorld(rotation, axis, steps) {
+    const current = new Quaternion().setFromEuler(new Euler(rotation[0], rotation[1], rotation[2]));
+    const turn = new Quaternion().setFromAxisAngle(AXIS_VECTORS[axis], steps * ROTATE_STEP_RAD);
+    const euler = new Euler().setFromQuaternion(turn.multiply(current));
+    return [euler.x, euler.y, euler.z];
+}
+/**
+ * R / T keyboard action for a placed fitting — rotate ±45° around the
+ * shared active axis (Alt cycles it; see `selection.tsx`).
+ */
+export function rotateFittingNode(node, steps) {
+    const fitting = node;
+    useScene.getState().updateNode(fitting.id, {
+        rotation: rotateEulerWorld(fitting.rotation, getRotationAxis(), steps),
+    });
+    triggerSFX('sfx:item-rotate');
+}

package/dist/shared/floor-placement.d.ts

@@ -0,0 +1,25 @@
+import { type AnyNode, type GridEvent, type NodeEvent, resolveAlignment } from '@pascal-app/core';
+export declare const FLOOR_PLACEMENT_ALIGNMENT_THRESHOLD_M = 0.08;
+export declare const FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS: readonly ["shelf", "item", "slab", "ceiling", "wall", "fence", "column", "roof", "roof-segment", "stair", "stair-segment"];
+export type FloorPlacementClickTriggerEvent = GridEvent | NodeEvent<AnyNode>;
+type FloorPlacementAlignmentArgs = {
+    node: AnyNode;
+    rawX: number;
+    rawZ: number;
+    gridStep: number;
+    candidates: Parameters<typeof resolveAlignment>[0]['candidates'];
+    showAlignment?: boolean;
+    applyAlignmentSnap?: boolean;
+    bypassGrid?: boolean;
+    rotationY?: number;
+};
+export declare function getLevelLocalSnappedPosition(levelId: string, event: FloorPlacementClickTriggerEvent, gridStep: number, bypassGrid?: boolean): [number, number, number];
+export declare function resolveAlignedFloorPlacement({ node, rawX, rawZ, gridStep, candidates, showAlignment, applyAlignmentSnap, bypassGrid, rotationY, }: FloorPlacementAlignmentArgs): {
+    position: [number, number, number];
+    guides: import("@pascal-app/core").AlignmentGuide[];
+};
+export declare function stopPlacementCommitPropagation(event: FloorPlacementClickTriggerEvent): void;
+export declare function subscribeFloorPlacementClicks(onClick: (event: FloorPlacementClickTriggerEvent) => void): () => void;
+export declare function subscribeFloorPlacementDoubleClicks(onDoubleClick: (event: FloorPlacementClickTriggerEvent) => void): () => void;
+export {};
+//# sourceMappingURL=floor-placement.d.ts.map

package/dist/shared/floor-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-placement.d.ts","sourceRoot":"","sources":["../../src/shared/floor-placement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,SAAS,EAEd,KAAK,SAAS,EACd,gBAAgB,EAGjB,MAAM,kBAAkB,CAAA;AAGzB,eAAO,MAAM,qCAAqC,OAAO,CAAA;AAEzD,eAAO,MAAM,mCAAmC,4HAYtC,CAAA;AAEV,MAAM,MAAM,+BAA+B,GAAG,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,CAAA;AAE5E,KAAK,2BAA2B,GAAG;IACjC,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAA;IAChE,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAID,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,+BAA+B,EACtC,QAAQ,EAAE,MAAM,EAChB,UAAU,UAAQ,GACjB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAiB1B;AAED,wBAAgB,4BAA4B,CAAC,EAC3C,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,aAAoB,EACpB,kBAAyB,EACzB,UAAkB,EAClB,SAAa,GACd,EAAE,2BAA2B;cAoBD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;;EAGpD;AAgBD,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,+BAA+B,QAUpF;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,CAAC,KAAK,EAAE,+BAA+B,KAAK,IAAI,cAiB1D;AAED,wBAAgB,mCAAmC,CACjD,aAAa,EAAE,CAAC,KAAK,EAAE,+BAA+B,KAAK,IAAI,cAiBhE"}