@pascal-app/nodes 0.1.1

package/dist/shared/roof-wall-opening-placement.js

@@ -0,0 +1,58 @@
+import { clampRectToRoofWallFace, roofFacePointToSegment, sceneRegistry, } from '@pascal-app/core';
+import { hasRoofFaceChildOverlap, resolveRoofWallHit } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Vector3 } from 'three';
+/**
+ * Resolve a roof pointer event to an opening placement on a segment
+ * wall face: hit → vertical policy → profile clamp → overlap check.
+ * Null when the pointer isn't over a placeable face or the rect cannot
+ * fit at that spot.
+ */
+export function resolveRoofWallOpeningTarget(args) {
+    const { event, width, height, ignoreId, vertical } = args;
+    const hit = resolveRoofWallHit(event.node, event.position, event.normal, event.object);
+    if (!hit)
+        return null;
+    const centerV = vertical.kind === 'bottom-locked' ? height / 2 : (vertical.snap?.(hit.v) ?? hit.v);
+    const clamped = clampRectToRoofWallFace(hit.face, hit.u, centerV, width, height, vertical.kind === 'bottom-locked' ? { lockV: true } : undefined);
+    if (!clamped)
+        return null;
+    const valid = !hasRoofFaceChildOverlap(hit.segment, hit.face.id, clamped.u, clamped.v, width, height, ignoreId);
+    return {
+        segment: hit.segment,
+        face: hit.face,
+        position: [clamped.u, clamped.v, 0],
+        valid,
+    };
+}
+const cursorPoint = new Vector3();
+/**
+ * World → building-local. Tool cursor groups render inside the
+ * building's frame (same conversion as the roof accessory tools).
+ */
+export function worldToSelectedBuildingLocal(point) {
+    const buildingId = useViewer.getState().selection.buildingId;
+    const buildingObj = buildingId ? sceneRegistry.nodes.get(buildingId) : undefined;
+    if (buildingObj) {
+        buildingObj.updateWorldMatrix(true, false);
+        buildingObj.worldToLocal(point);
+    }
+    return [point.x, point.y, point.z];
+}
+/**
+ * Cursor pose for a resolved target: building-local position of the
+ * opening center + total yaw (roof ∘ segment ∘ face).
+ */
+export function getRoofWallOpeningCursorPose(target, roof) {
+    const segObj = sceneRegistry.nodes.get(target.segment.id);
+    if (!segObj)
+        return null;
+    segObj.updateWorldMatrix(true, false);
+    const segLocal = roofFacePointToSegment(target.segment, target.face.id, target.position);
+    cursorPoint.set(segLocal[0], segLocal[1], segLocal[2]);
+    segObj.localToWorld(cursorPoint);
+    return {
+        position: worldToSelectedBuildingLocal(cursorPoint),
+        rotationY: (roof.rotation ?? 0) + (target.segment.rotation ?? 0) + target.face.yaw,
+    };
+}

package/dist/shared/rotate-affordance.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared rotation delta for the 2D corner rotate-arrow affordances (column /
+ * elevator / roof-segment / shelf / spawn / stair — all structurally
+ * identical). Measures the pointer's angular sweep from the grab bearing
+ * around the node center, wrapped to [-π, π] so a drag crossing ±π keeps its
+ * sign, then snaps it to the 15° increment unless `free` (the held Shift the
+ * contextual HUD advertises). The 2D twin of the 3D gizmo's
+ * `snapDirectRotationDelta`, so rotating a node reads the same in both views.
+ */
+export declare function rotateAffordanceDelta(args: {
+    center: readonly [number, number];
+    initialAngle: number;
+    planPoint: readonly [number, number];
+    free: boolean;
+}): number;
+//# sourceMappingURL=rotate-affordance.d.ts.map

package/dist/shared/rotate-affordance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotate-affordance.d.ts","sourceRoot":"","sources":["../../src/shared/rotate-affordance.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,IAAI,EAAE,OAAO,CAAA;CACd,GAAG,MAAM,CAOT"}

package/dist/shared/rotate-affordance.js

@@ -0,0 +1,20 @@
+import { DEFAULT_ANGLE_STEP } from '@pascal-app/core';
+/**
+ * Shared rotation delta for the 2D corner rotate-arrow affordances (column /
+ * elevator / roof-segment / shelf / spawn / stair — all structurally
+ * identical). Measures the pointer's angular sweep from the grab bearing
+ * around the node center, wrapped to [-π, π] so a drag crossing ±π keeps its
+ * sign, then snaps it to the 15° increment unless `free` (the held Shift the
+ * contextual HUD advertises). The 2D twin of the 3D gizmo's
+ * `snapDirectRotationDelta`, so rotating a node reads the same in both views.
+ */
+export function rotateAffordanceDelta(args) {
+    const { center, initialAngle, planPoint, free } = args;
+    const currentAngle = Math.atan2(planPoint[1] - center[1], planPoint[0] - center[0]);
+    let delta = currentAngle - initialAngle;
+    while (delta > Math.PI)
+        delta -= 2 * Math.PI;
+    while (delta < -Math.PI)
+        delta += 2 * Math.PI;
+    return free ? delta : Math.round(delta / DEFAULT_ANGLE_STEP) * DEFAULT_ANGLE_STEP;
+}

package/dist/shared/run-move-connectivity.d.ts

@@ -0,0 +1,52 @@
+import { type AnyNode, type AnyNodeId, type PortConnectivity } from '@pascal-app/core';
+type Vec3 = [number, number, number];
+/** Live transform of the moved node for a given drag frame — whichever of
+ *  `path` (runs) or `position` (fittings) the node moves by. */
+type MovedTransform = {
+    path?: Vec3[];
+    position?: Vec3;
+};
+/**
+ * Connectivity follow for whole-node ghost move tools (duct / pipe /
+ * lineset `MoveTool`, and the duct-fitting `MoveTool`). When you grab a
+ * committed run or fitting by its floating move button and slide it, the
+ * shared port-connectivity service walks the joint graph and produces the
+ * patches that keep neighbours welded:
+ *
+ * - Moving a **run**: both endpoints translate by the same delta, so any
+ *   fitting mated to either end follows rigidly and the OTHER runs on those
+ *   fittings stretch / translate per the axis-decomposition rules.
+ * - Moving a **fitting**: its collars push the connected runs — the part of
+ *   the move along a run's axis stretches it, the part across translates the
+ *   whole run (preserving its direction), and that perpendicular part carries
+ *   on to whatever is mated to the run's far end.
+ *
+ * The moved node's own transform drives the snapshot. Followers preview
+ * through `useLiveNodeOverrides` (transient — no history churn;
+ * `getEffectiveNode` merges overrides so the connected geometry rebuilds at
+ * pointer rate), then fold into the commit's single tracked `updateNodes`
+ * batch.
+ *
+ * Returns `null` when nothing is connected, so callers skip all the work.
+ */
+export declare function startRunMoveConnectivity(node: AnyNode): RunMoveConnectivity | null;
+export declare class RunMoveConnectivity {
+    private readonly node;
+    private readonly connectivity;
+    private overriddenIds;
+    constructor(node: AnyNode, connectivity: PortConnectivity);
+    /** Patches that keep the connected nodes attached for a given live transform. */
+    private updatesFor;
+    /** Live-preview the followers for the moved node's current drag transform. */
+    preview(transform: MovedTransform): void;
+    /** Follower patches to fold into the commit `updateNodes` batch. */
+    commitUpdates(transform: MovedTransform): {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }[];
+    /** Drop all live overrides (commit clears them once the scene write lands;
+     *  cancel / unmount clears them to reveal the unchanged followers). */
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=run-move-connectivity.d.ts.map

package/dist/shared/run-move-connectivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-move-connectivity.d.ts","sourceRoot":"","sources":["../../src/shared/run-move-connectivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,KAAK,gBAAgB,EAItB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpC;gEACgE;AAChE,KAAK,cAAc,GAAG;IAAE,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CAIlF;AAED,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAJ/B,OAAO,CAAC,aAAa,CAAkB;gBAGpB,IAAI,EAAE,OAAO,EACb,YAAY,EAAE,gBAAgB;IAGjD,iFAAiF;IACjF,OAAO,CAAC,UAAU;IAOlB,8EAA8E;IAC9E,OAAO,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAqBxC,oEAAoE;IACpE,aAAa,CAAC,SAAS,EAAE,cAAc,GAAG;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE;IAIrF;2EACuE;IACvE,KAAK,IAAI,IAAI;CAQd"}

package/dist/shared/run-move-connectivity.js

@@ -0,0 +1,82 @@
+import { analyzePortConnectivity, resolveConnectivityUpdates, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+/**
+ * Connectivity follow for whole-node ghost move tools (duct / pipe /
+ * lineset `MoveTool`, and the duct-fitting `MoveTool`). When you grab a
+ * committed run or fitting by its floating move button and slide it, the
+ * shared port-connectivity service walks the joint graph and produces the
+ * patches that keep neighbours welded:
+ *
+ * - Moving a **run**: both endpoints translate by the same delta, so any
+ *   fitting mated to either end follows rigidly and the OTHER runs on those
+ *   fittings stretch / translate per the axis-decomposition rules.
+ * - Moving a **fitting**: its collars push the connected runs — the part of
+ *   the move along a run's axis stretches it, the part across translates the
+ *   whole run (preserving its direction), and that perpendicular part carries
+ *   on to whatever is mated to the run's far end.
+ *
+ * The moved node's own transform drives the snapshot. Followers preview
+ * through `useLiveNodeOverrides` (transient — no history churn;
+ * `getEffectiveNode` merges overrides so the connected geometry rebuilds at
+ * pointer rate), then fold into the commit's single tracked `updateNodes`
+ * batch.
+ *
+ * Returns `null` when nothing is connected, so callers skip all the work.
+ */
+export function startRunMoveConnectivity(node) {
+    const snapshot = analyzePortConnectivity(node, useScene.getState().nodes);
+    if (snapshot.connections.length === 0)
+        return null;
+    return new RunMoveConnectivity(node, snapshot);
+}
+export class RunMoveConnectivity {
+    node;
+    connectivity;
+    overriddenIds = [];
+    constructor(node, connectivity) {
+        this.node = node;
+        this.connectivity = connectivity;
+    }
+    /** Patches that keep the connected nodes attached for a given live transform. */
+    updatesFor(transform) {
+        const preview = { ...this.node, ...transform };
+        return resolveConnectivityUpdates(this.connectivity, preview).filter((u) => useScene.getState().nodes[u.id]);
+    }
+    /** Live-preview the followers for the moved node's current drag transform. */
+    preview(transform) {
+        const updates = this.updatesFor(transform);
+        const overrides = useLiveNodeOverrides.getState();
+        const nextIds = updates.map((u) => u.id);
+        // Drop overrides on nodes that fell out of this frame's update set (e.g. a
+        // follower that returned to its origin resolves to a no-op delta).
+        for (const id of this.overriddenIds) {
+            if (!nextIds.includes(id)) {
+                overrides.clear(id);
+                if (useScene.getState().nodes[id])
+                    useScene.getState().markDirty(id);
+            }
+        }
+        if (updates.length > 0) {
+            overrides.setMany(updates.map((u) => [u.id, u.data]));
+            for (const u of updates) {
+                if (useScene.getState().nodes[u.id])
+                    useScene.getState().markDirty(u.id);
+            }
+        }
+        this.overriddenIds = nextIds;
+    }
+    /** Follower patches to fold into the commit `updateNodes` batch. */
+    commitUpdates(transform) {
+        return this.updatesFor(transform);
+    }
+    /** Drop all live overrides (commit clears them once the scene write lands;
+     *  cancel / unmount clears them to reveal the unchanged followers). */
+    clear() {
+        const overrides = useLiveNodeOverrides.getState();
+        for (const id of this.overriddenIds) {
+            overrides.clear(id);
+            if (useScene.getState().nodes[id])
+                useScene.getState().markDirty(id);
+        }
+        this.overriddenIds = [];
+    }
+}

package/dist/shared/run-translation-offset.d.ts

@@ -0,0 +1,24 @@
+import { type AnyNode, type AnyNodeId, DuctSegmentNode, type PortConnection } from '@pascal-app/core';
+import type { DuctFittingNode } from '../duct-fitting/schema';
+import { type DuctProfile } from './auto-fitting';
+import type { ScenePort } from './ports';
+type Point = [number, number, number];
+export type RunTranslationOffsetPlan = {
+    ductPath: Point[];
+    fittings: DuctFittingNode[];
+    connectors: DuctSegmentNode[];
+    updates: {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }[];
+};
+export declare function planRunTranslationOffsets(args: {
+    duct: DuctSegmentNode;
+    translatedPath: Point[];
+    profile: DuctProfile;
+    connections: PortConnection[];
+    scenePorts: ScenePort[];
+    nodesById: Record<string, AnyNode>;
+}): RunTranslationOffsetPlan | null;
+export {};
+//# sourceMappingURL=run-translation-offset.d.ts.map

package/dist/shared/run-translation-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-translation-offset.d.ts","sourceRoot":"","sources":["../../src/shared/run-translation-offset.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,eAAe,EACf,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EACL,KAAK,WAAW,EAIjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAKrC,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,KAAK,EAAE,CAAA;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,UAAU,EAAE,eAAe,EAAE,CAAA;IAC7B,OAAO,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;CACrD,CAAA;AAuED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,IAAI,EAAE,eAAe,CAAA;IACrB,cAAc,EAAE,KAAK,EAAE,CAAA;IACvB,OAAO,EAAE,WAAW,CAAA;IACpB,WAAW,EAAE,cAAc,EAAE,CAAA;IAC7B,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC,GAAG,wBAAwB,GAAG,IAAI,CAqFlC"}

package/dist/shared/run-translation-offset.js

@@ -0,0 +1,140 @@
+import { DuctSegmentNode, } from '@pascal-app/core';
+import { fittingLegLength } from '../duct-fitting/ports';
+import { planElbowAtPort, planElbowRealign, profileDiameterIn, } from './auto-fitting';
+const COINCIDENT_EPS_M = 0.05;
+const MIN_CONNECTOR_M = 0.05;
+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;
+}
+function sub(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function neg(v) {
+    return [-v[0], -v[1], -v[2]];
+}
+function unit(v) {
+    const len = Math.hypot(v[0], v[1], v[2]);
+    if (len < 1e-9)
+        return null;
+    return [v[0] / len, v[1] / len, v[2] / len];
+}
+function endpointOutwardDir(path, idx) {
+    const last = path.length - 1;
+    const [a, b] = idx === 0 ? [path[0], path[1]] : [path[last], path[last - 1]];
+    return unit([a[0] - b[0], a[1] - b[1], a[2] - b[2]]) ?? [1, 0, 0];
+}
+function portLike(position, direction, system) {
+    return {
+        id: 'x',
+        nodeId: 'x',
+        position,
+        direction,
+        diameter: 0,
+        system,
+    };
+}
+function connectorRun(from, to, duct) {
+    return DuctSegmentNode.parse({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        name: duct.name ?? 'Duct run',
+        path: [from, to],
+        shape: duct.shape,
+        diameter: duct.diameter,
+        width: duct.width,
+        height: duct.height,
+        roll: duct.roll,
+        ductMaterial: duct.ductMaterial,
+        insulated: duct.insulated,
+        insulationR: duct.insulationR,
+        system: duct.system,
+    });
+}
+function elbowProfilePatch(profile) {
+    const diameter = profileDiameterIn(profile);
+    return {
+        shape: profile.shape,
+        width: profile.width,
+        height: profile.height,
+        diameter,
+        diameter2: diameter,
+    };
+}
+export function planRunTranslationOffsets(args) {
+    const { duct, translatedPath, profile, connections, scenePorts, nodesById } = args;
+    if (duct.path.length < 2 || translatedPath.length !== duct.path.length)
+        return null;
+    if (connections.length === 0)
+        return null;
+    const leg = fittingLegLength(profileDiameterIn(profile));
+    const minOffset = 2 * leg + MIN_CONNECTOR_M;
+    const eps2 = COINCIDENT_EPS_M * COINCIDENT_EPS_M;
+    const ductPath = translatedPath.map((p) => [...p]);
+    const fittings = [];
+    const connectors = [];
+    const updates = [];
+    let routedAny = false;
+    for (const endIdx of duct.path.length > 1 ? [0, duct.path.length - 1] : [0]) {
+        const startEnd = duct.path[endIdx];
+        const movedEnd = translatedPath[endIdx];
+        const delta = sub(movedEnd, startEnd);
+        const offsetDir = unit(delta);
+        if (!offsetDir || Math.hypot(delta[0], delta[1], delta[2]) < minOffset)
+            continue;
+        const partnerPort = scenePorts.find((sp) => distSq(sp.position, startEnd) <= eps2 &&
+            connections.some((conn) => conn.nodeId === sp.nodeId));
+        if (!partnerPort)
+            continue;
+        const conn = connections.find((c) => c.nodeId === partnerPort.nodeId);
+        if (!conn)
+            continue;
+        const ductPortDir = endpointOutwardDir(translatedPath, endIdx);
+        const top = planElbowAtPort(portLike(movedEnd, ductPortDir, duct.system), neg(offsetDir), profile);
+        if (!top)
+            return null;
+        if (conn.kind === 'run') {
+            const bottom = planElbowAtPort(portLike([startEnd[0], startEnd[1], startEnd[2]], [partnerPort.direction[0], partnerPort.direction[1], partnerPort.direction[2]], duct.system), offsetDir, profile);
+            if (!bottom)
+                return null;
+            fittings.push(bottom.fitting, top.fitting);
+            connectors.push(connectorRun(bottom.collarPoint, top.collarPoint, duct));
+            ductPath[endIdx] = top.trimmedPortPoint;
+            const path = conn.startPath.map((p) => [...p]);
+            const tip = path.findIndex((p) => distSq(p, startEnd) <= eps2);
+            if (tip !== -1) {
+                path[tip] = bottom.trimmedPortPoint;
+                updates.push({ id: conn.nodeId, data: { path } });
+            }
+            routedAny = true;
+            continue;
+        }
+        const partner = nodesById[conn.nodeId];
+        if (partner?.type !== 'duct-fitting')
+            return null;
+        const elbow = {
+            ...partner,
+            ...elbowProfilePatch(profile),
+        };
+        if (elbow.fittingType !== 'elbow')
+            return null;
+        const realign = planElbowRealign(elbow, partnerPort.id, offsetDir);
+        if (!realign)
+            return null;
+        fittings.push(top.fitting);
+        connectors.push(connectorRun(realign.collarPoint, top.collarPoint, duct));
+        ductPath[endIdx] = top.trimmedPortPoint;
+        updates.push({
+            id: elbow.id,
+            data: { ...elbowProfilePatch(profile), ...realign.update.data },
+        });
+        routedAny = true;
+    }
+    if (!routedAny)
+        return null;
+    return { ductPath, fittings, connectors, updates };
+}

package/dist/shared/selection-handles.d.ts

@@ -0,0 +1,51 @@
+import type { Cursor } from '@pascal-app/core';
+import type { ThreeEvent } from '@react-three/fiber';
+type Point = [number, number, number];
+/**
+ * Small persistent cube the user CLICKS to latch a directional handle cluster
+ * open (click again to close). A `tracker` HandleArrow (a tiny cube) reused so
+ * it shares the rig's hit-area / depth / outline treatment, sized to match the
+ * roof-segment pitch cube (`baseScale = zoom`, full `TRACKER_CUBE_SIZE`).
+ * `hoverScale = 1.15` grows it 15% on hover / while its cluster is open so it
+ * reads as clickable. Shared by the duct-segment and duct-fitting selection
+ * rigs so every editing cube is the same size.
+ */
+export declare function HandleCube({ position, active, onClick, onPointerDown, rotationY, cursor, }: {
+    position: Point;
+    active: boolean;
+    onClick?: () => void;
+    onPointerDown?: (e: ThreeEvent<PointerEvent>) => void;
+    /** Yaw (radians) so the cube can align with the run it sits on. */
+    rotationY?: number;
+    cursor?: Cursor;
+}): import("react").JSX.Element;
+/**
+ * In-world chevron arrow handle — a thin wrapper over the editor's shared
+ * `HandleArrow` so directional move arrows render as the same solid violet
+ * plate (depth-written, ink-edge outlined) the wall arrows use. Lays flat in
+ * the XZ plane pointing along +X (yawed by `rotationY`); `vertical` tips the
+ * chevron up / down for the riser pair. Scales with ortho zoom for a constant
+ * on-screen size.
+ */
+export declare function MoveChevron({ position, rotationY, vertical, cursor, onPointerDown, }: {
+    position: Point;
+    rotationY?: number;
+    vertical?: 'up' | 'down';
+    cursor?: Cursor;
+    onPointerDown: (e: ThreeEvent<PointerEvent>) => void;
+}): import("react").JSX.Element;
+/**
+ * Rotation arc handle — the editor's `curved-arrow` (which wraps world +Y by
+ * default) re-oriented by an arbitrary `rotation` euler. Scales with ortho zoom
+ * for a constant on-screen size. The caller supplies the position + orientation
+ * so the same component serves a duct's single roll arc and a fitting's three
+ * per-axis arcs.
+ */
+export declare function RotateArc({ position, rotation, cursor, onPointerDown, }: {
+    position: Point;
+    rotation: [number, number, number];
+    cursor?: Cursor;
+    onPointerDown: (e: ThreeEvent<PointerEvent>) => void;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=selection-handles.d.ts.map

package/dist/shared/selection-handles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-handles.d.ts","sourceRoot":"","sources":["../../src/shared/selection-handles.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAKpD,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AASrC;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,MAAM,EACN,OAAO,EACP,aAAa,EACb,SAAa,EACb,MAAe,GAChB,EAAE;IACD,QAAQ,EAAE,KAAK,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,aAAa,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC,KAAK,IAAI,CAAA;IACrD,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,+BAoBA;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,SAAa,EACb,QAAQ,EACR,MAAe,EACf,aAAa,GACd,EAAE;IACD,QAAQ,EAAE,KAAK,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;IACxB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC,KAAK,IAAI,CAAA;CACrD,+BA0BA;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,EACxB,QAAQ,EACR,QAAQ,EACR,MAAe,EACf,aAAa,GACd,EAAE;IACD,QAAQ,EAAE,KAAK,CAAA;IACf,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC,KAAK,IAAI,CAAA;CACrD,+BAkBA"}

package/dist/shared/selection-handles.js

@@ -0,0 +1,74 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ARROW_SCALE, HandleArrow, swallowNextClick } from '@pascal-app/editor';
+import { useThree } from '@react-three/fiber';
+import { useState } from 'react';
+import { OrthographicCamera } from 'three';
+function consumeHandlePress(event) {
+    event.stopPropagation();
+    event.nativeEvent.stopPropagation();
+    event.nativeEvent.stopImmediatePropagation();
+    swallowNextClick();
+}
+/**
+ * Small persistent cube the user CLICKS to latch a directional handle cluster
+ * open (click again to close). A `tracker` HandleArrow (a tiny cube) reused so
+ * it shares the rig's hit-area / depth / outline treatment, sized to match the
+ * roof-segment pitch cube (`baseScale = zoom`, full `TRACKER_CUBE_SIZE`).
+ * `hoverScale = 1.15` grows it 15% on hover / while its cluster is open so it
+ * reads as clickable. Shared by the duct-segment and duct-fitting selection
+ * rigs so every editing cube is the same size.
+ */
+export function HandleCube({ position, active, onClick, onPointerDown, rotationY = 0, cursor = 'grab', }) {
+    const [hovered, setHovered] = useState(false);
+    const { camera } = useThree();
+    const zoom = camera instanceof OrthographicCamera ? 1 / camera.zoom : 1;
+    const baseScale = zoom;
+    return (_jsx(HandleArrow, { cursor: cursor, hover: hovered || active, hoverScale: 1.15, onHoverChange: setHovered, onPointerDown: (e) => {
+            consumeHandlePress(e);
+            if (onPointerDown)
+                onPointerDown(e);
+            else
+                onClick?.();
+        }, placement: { position, rotation: [0, rotationY, 0], baseScale }, shape: "tracker" }));
+}
+/**
+ * In-world chevron arrow handle — a thin wrapper over the editor's shared
+ * `HandleArrow` so directional move arrows render as the same solid violet
+ * plate (depth-written, ink-edge outlined) the wall arrows use. Lays flat in
+ * the XZ plane pointing along +X (yawed by `rotationY`); `vertical` tips the
+ * chevron up / down for the riser pair. Scales with ortho zoom for a constant
+ * on-screen size.
+ */
+export function MoveChevron({ position, rotationY = 0, vertical, cursor = 'grab', onPointerDown, }) {
+    const [hovered, setHovered] = useState(false);
+    const { camera } = useThree();
+    const zoom = camera instanceof OrthographicCamera ? 1 / camera.zoom : 1;
+    const baseScale = zoom * ARROW_SCALE;
+    // Tip the flat chevron up / down to point along ±Y — the same inner-rotation
+    // chain the wall height arrow uses.
+    const indicatorRotation = vertical
+        ? [0, Math.PI / 2, vertical === 'up' ? Math.PI / 2 : -Math.PI / 2]
+        : undefined;
+    return (_jsx(HandleArrow, { cursor: cursor, hover: hovered, indicatorRotation: indicatorRotation, onHoverChange: setHovered, onPointerDown: (event) => {
+            consumeHandlePress(event);
+            onPointerDown(event);
+        }, placement: { position, rotation: [0, rotationY, 0], baseScale }, shape: "chevron", thin: true }));
+}
+/**
+ * Rotation arc handle — the editor's `curved-arrow` (which wraps world +Y by
+ * default) re-oriented by an arbitrary `rotation` euler. Scales with ortho zoom
+ * for a constant on-screen size. The caller supplies the position + orientation
+ * so the same component serves a duct's single roll arc and a fitting's three
+ * per-axis arcs.
+ */
+export function RotateArc({ position, rotation, cursor = 'grab', onPointerDown, }) {
+    const [hovered, setHovered] = useState(false);
+    const { camera } = useThree();
+    const zoom = camera instanceof OrthographicCamera ? 1 / camera.zoom : 1;
+    const baseScale = zoom * ARROW_SCALE;
+    return (_jsx(HandleArrow, { cursor: cursor, hover: hovered, onHoverChange: setHovered, onPointerDown: (event) => {
+            consumeHandlePress(event);
+            onPointerDown(event);
+        }, placement: { position, rotation, baseScale }, shape: "curved-arrow" }));
+}

package/dist/shared/slot-paint.d.ts

@@ -0,0 +1,46 @@
+import { type AnyNode, type MaterialSchema, type MaterialTarget, type PaintCapability, type PaintPreviewArgs, type PaintResolveArgs } from '@pascal-app/core';
+import { type Material } from 'three';
+/** Preview material for a slot paint — mirrors the commit's resolution. */
+export declare function buildSlotPreviewMaterial(material: MaterialSchema | undefined, materialPreset: string | undefined): Material | null;
+/**
+ * Preview for kinds whose meshes are produced by `def.geometry` and tagged
+ * with `userData.slotId` (+ `__fromGeometry`). Swaps every builder mesh whose
+ * slot matches `role`, leaving hosted-child meshes (which can carry a colliding
+ * `userData.slotId` from their own GLB) untouched.
+ */
+export declare function previewGeometrySlot(args: PaintPreviewArgs): (() => void) | null;
+/**
+ * Preview for kinds whose meshes are built by a viewer system (window, door)
+ * and tagged with `userData.slotId` — no `__fromGeometry` marker and no hosted
+ * children to guard against, so it swaps every mesh whose slot matches `role`.
+ */
+export declare function previewSlotByUserData(args: PaintPreviewArgs): (() => void) | null;
+/**
+ * Resolve the slot for a kind whose paint hit lands on a proud opening proxy
+ * (door/window: a 1m-deep invisible cutout that wins the scene raycast over the
+ * wall in front of the recessed body) rather than the part itself. Re-raycasts
+ * the kind's OWN registered subtree (ignoring everything else) and returns the
+ * first tagged sub-mesh under the cursor; falls back to the direct hit's slot
+ * (e.g. a proud part the scene raycast hit directly).
+ */
+export declare function resolveSlotByReRaycast(args: PaintResolveArgs): string | null;
+export type SlotPaintConfig = {
+    materialTarget?: MaterialTarget;
+    /** Resolve the slot id for a pointer hit (`null` = not paintable here). */
+    resolveRole: (args: PaintResolveArgs) => string | null;
+    /** Apply a preview to the registered mesh subtree for `role`. */
+    applyPreview: (args: PaintPreviewArgs) => (() => void) | null;
+    /**
+     * Optional legacy fallback for the picker's current-value indicator — read
+     * when no `node.slots[role]` ref exists yet (e.g. a scene painted before the
+     * kind moved onto the slot model still carries inline `material`/`preset`).
+     */
+    legacyEffective?: (node: AnyNode, role: string) => {
+        material: MaterialSchema | undefined;
+        materialPreset: string | undefined;
+    } | null;
+    /** Opt into the painter's `room` application scope (walls, slabs). */
+    roomScope?: boolean;
+};
+export declare function createSlotPaintCapability(config: SlotPaintConfig): PaintCapability;
+//# sourceMappingURL=slot-paint.d.ts.map

package/dist/shared/slot-paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-paint.d.ts","sourceRoot":"","sources":["../../src/shared/slot-paint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EAOtB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,KAAK,QAAQ,EAAuC,MAAM,OAAO,CAAA;AAkH1E,2EAA2E;AAC3E,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,cAAc,GAAG,SAAS,EACpC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,QAAQ,GAAG,IAAI,CAYjB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAuB/E;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAqBjF;AAKD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAW5E;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,2EAA2E;IAC3E,WAAW,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,MAAM,GAAG,IAAI,CAAA;IACtD,iEAAiE;IACjE,YAAY,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA;IAC7D;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,KACT;QAAE,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAC;QAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAAG,IAAI,CAAA;IACxF,sEAAsE;IACtE,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAyBlF"}