@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/shared/run-hangers.d.ts

@@ -0,0 +1,25 @@
+import { type AnyNode, type AnyNodeId, type DuctSegmentNode, type FloorplanGeometry, type GeometryContext, type PipeSegmentNode } from '@pascal-app/core';
+import { ExtrudeGeometry, Group, Vector3 } from 'three';
+export type SupportedRun = DuctSegmentNode | PipeSegmentNode;
+export type RunHanger = {
+    center: Vector3;
+    anchor: Vector3;
+    direction: Vector3;
+    hostId: AnyNodeId;
+};
+export declare function hangerSceneNodes(ctx?: GeometryContext): Record<AnyNodeId, AnyNode>;
+export type RunHangerSlot = {
+    id: string;
+    segmentIndex: number;
+    fraction: number;
+    center: Vector3;
+    skipped: boolean;
+    hanger: RunHanger | null;
+};
+export declare function planRunHangerSlots(run: SupportedRun, nodes: Record<AnyNodeId, AnyNode>): RunHangerSlot[];
+export declare function planRunHangers(run: SupportedRun, nodes: Record<AnyNodeId, AnyNode>): RunHanger[];
+export declare function buildHangerBandGeometry(run: SupportedRun): ExtrudeGeometry;
+export declare function hangerSupportLines(run: SupportedRun, hanger: RunHanger): [Vector3, Vector3][];
+export declare function buildRunHangers(run: SupportedRun, ctx?: GeometryContext): Group;
+export declare function runHangerFloorplan(run: SupportedRun, ctx: GeometryContext): FloorplanGeometry[];
+//# sourceMappingURL=run-hangers.d.ts.map

package/dist/shared/run-hangers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-hangers.d.ts","sourceRoot":"","sources":["../../src/shared/run-hangers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAKpB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,eAAe,EACf,KAAK,EAOL,OAAO,EACR,MAAM,OAAO,CAAA;AAId,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG,eAAe,CAAA;AAC5D,MAAM,MAAM,SAAS,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AAEnG,wBAAgB,gBAAgB,CAAC,GAAG,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAqBlF;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,SAAS,GAAG,IAAI,CAAA;CACzB,CAAA;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,aAAa,EAAE,CA4EjB;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,CAEhG;AA0CD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,YAAY,GAAG,eAAe,CAQ1E;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CA+B7F;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,KAAK,CAsC/E;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,EAAE,CAqC/F"}

package/dist/shared/run-hangers.js

@@ -0,0 +1,261 @@
+import { getWallBaseElevationForNodes, getWallCurveFrameAt, getWallEffectiveHeightForNodes, getWallThickness, pointInPolygon, resolveCeilingHeight, } from '@pascal-app/core';
+import { BoxGeometry, CylinderGeometry, ExtrudeGeometry, Group, Matrix4, Mesh, MeshStandardMaterial, Path, Shape, Vector2, Vector3, } from 'three';
+import { rectSectionAxes } from '../duct-segment/geometry';
+import { hasWallChildOverlap, resolveWallAttachmentAtPlanPoint } from './wall-attach-target';
+export function hangerSceneNodes(ctx) {
+    if (ctx?.sceneNodes)
+        return ctx.sceneNodes;
+    const nodes = {};
+    let root = ctx?.parent;
+    while (root?.parentId) {
+        const parent = ctx?.resolve(root.parentId);
+        if (!parent || parent.id === root.id)
+            break;
+        root = parent;
+    }
+    const visit = (node) => {
+        if (nodes[node.id])
+            return;
+        nodes[node.id] = node;
+        if ('children' in node && Array.isArray(node.children)) {
+            for (const id of node.children) {
+                const child = ctx?.resolve(id);
+                if (child)
+                    visit(child);
+            }
+        }
+    };
+    if (root)
+        visit(root);
+    return nodes;
+}
+export function planRunHangerSlots(run, nodes) {
+    if (!run.autoHangers || !run.parentId)
+        return [];
+    const spacing = run.hangerSpacing ?? 1.5;
+    const reach = run.hangerMaxReach ?? 2;
+    if (!(Number.isFinite(spacing) && spacing > 0 && Number.isFinite(reach) && reach > 0))
+        return [];
+    const hosts = Object.values(nodes).filter((n) => n.parentId === run.parentId && (n.type === 'wall' || n.type === 'ceiling'));
+    const result = [];
+    for (let i = 1; i < run.path.length; i++) {
+        const start = new Vector3(...run.path[i - 1]);
+        const delta = new Vector3(...run.path[i]).sub(start);
+        const length = delta.length();
+        if (length < 0.05)
+            continue;
+        const direction = delta.clone().normalize();
+        const count = Math.max(1, Math.ceil(length / spacing));
+        for (let j = 0; j < count; j++) {
+            const id = `${i - 1}:${j}`;
+            const override = run.hangerOverrides?.[id];
+            const fraction = override?.fraction ?? (j + 0.5) / count;
+            const center = start.clone().addScaledVector(delta, fraction);
+            let best = null;
+            let distance = reach;
+            for (const host of hosts) {
+                if (override?.skipped || (override?.hostId && override.hostId !== host.id))
+                    continue;
+                let anchor;
+                if (host.type === 'ceiling') {
+                    if (!pointInPolygon(center.x, center.z, host.polygon) ||
+                        host.holes.some((h) => pointInPolygon(center.x, center.z, h)))
+                        continue;
+                    const height = resolveCeilingHeight(host, nodes);
+                    if (height < center.y)
+                        continue;
+                    anchor = new Vector3(center.x, height, center.z);
+                }
+                else if (host.type === 'wall') {
+                    const thickness = getWallThickness(host);
+                    const hit = resolveWallAttachmentAtPlanPoint(host, [center.x, center.z], reach + thickness);
+                    if (!hit)
+                        continue;
+                    const base = getWallBaseElevationForNodes(host, nodes);
+                    const top = base + getWallEffectiveHeightForNodes(host, nodes);
+                    if (center.y < base || center.y > top)
+                        continue;
+                    if (hasWallChildOverlap(host.id, nodes, hit.localX, center.y - base, 0.08, 0.08))
+                        continue;
+                    const frame = getWallCurveFrameAt(host, hit.localX / hit.wallLength);
+                    const side = hit.perpDistance >= 0 ? 1 : -1;
+                    anchor = new Vector3(frame.point.x - (hit.dirY * side * thickness) / 2, center.y, frame.point.y + (hit.dirX * side * thickness) / 2);
+                    if (Math.abs(hit.perpDistance) < thickness / 2 - 0.001)
+                        continue;
+                }
+                else
+                    continue;
+                const d = anchor.distanceTo(center);
+                // A support along the run would overlap its body instead of holding it.
+                if (d < 1e-6 || Math.abs(anchor.clone().sub(center).normalize().dot(direction)) > 0.95)
+                    continue;
+                if (d <= distance) {
+                    best = { center, anchor, direction, hostId: host.id };
+                    distance = d;
+                }
+            }
+            result.push({
+                id,
+                segmentIndex: i - 1,
+                fraction,
+                center,
+                skipped: !!override?.skipped,
+                hanger: best,
+            });
+        }
+    }
+    return result;
+}
+export function planRunHangers(run, nodes) {
+    return planRunHangerSlots(run, nodes).flatMap((slot) => (slot.hanger ? [slot.hanger] : []));
+}
+const BAND_THICKNESS = 0.006;
+const BAND_WIDTH = 0.025;
+const BAND_CLEARANCE = 0.002;
+function hangerProfile(run) {
+    const insulation = run.type === 'duct-segment' && run.insulated && run.insulationR > 0
+        ? (0.5 + run.insulationR * 0.3125) * 0.0254
+        : 0;
+    const round = run.type === 'pipe-segment' || run.shape === 'round';
+    const shape = round ? 'round' : run.shape;
+    const w = ((round ? run.diameter : run.width) * 0.0254) / 2 + insulation + BAND_CLEARANCE;
+    const h = ((round ? run.diameter : run.height) * 0.0254) / 2 + insulation + BAND_CLEARANCE;
+    return { shape, w, h };
+}
+function profileContour(run, offset) {
+    const { shape, w, h } = hangerProfile(run);
+    if (shape === 'rect') {
+        return [
+            new Vector2(-w - offset, -h - offset),
+            new Vector2(w + offset, -h - offset),
+            new Vector2(w + offset, h + offset),
+            new Vector2(-w - offset, h + offset),
+        ];
+    }
+    const radius = Math.min(w, h) + offset;
+    const straight = Math.abs(w - h);
+    const points = [];
+    for (const half of [0, 1]) {
+        for (let i = 0; i <= 32; i++) {
+            const angle = -Math.PI / 2 + half * Math.PI + (i * Math.PI) / 32;
+            const major = Math.cos(angle) * radius + (half === 0 ? straight : -straight);
+            const minor = Math.sin(angle) * radius;
+            points.push(w >= h ? new Vector2(major, minor) : new Vector2(-minor, major));
+        }
+    }
+    return points;
+}
+export function buildHangerBandGeometry(run) {
+    // One annular extrusion shares the corner vertices, so the inside and
+    // outside edges meet at the same miter without overlapping end caps.
+    const shape = new Shape(profileContour(run, BAND_THICKNESS));
+    shape.holes.push(new Path(profileContour(run, 0).reverse()));
+    const geometry = new ExtrudeGeometry(shape, { depth: BAND_WIDTH, bevelEnabled: false, steps: 1 });
+    geometry.translate(0, 0, -BAND_WIDTH / 2);
+    return geometry;
+}
+export function hangerSupportLines(run, hanger) {
+    const { center, anchor, direction } = hanger;
+    const towardHost = anchor.clone().sub(center).normalize();
+    const { width, height } = rectSectionAxes(direction, run.type === 'duct-segment' ? run.roll : 0);
+    const { shape, w, h } = hangerProfile(run);
+    const contact = (axis) => {
+        const x = axis.dot(width);
+        const y = axis.dot(height);
+        if (shape === 'rect') {
+            return width
+                .clone()
+                .multiplyScalar(Math.abs(x) < 1e-8 ? 0 : Math.sign(x) * (w + BAND_THICKNESS / 2))
+                .addScaledVector(height, Math.abs(y) < 1e-8 ? 0 : Math.sign(y) * (h + BAND_THICKNESS / 2));
+        }
+        const radius = Math.min(w, h) + BAND_THICKNESS / 2;
+        const length = Math.hypot(x, y);
+        return width
+            .clone()
+            .multiplyScalar((x / length) * radius + (w > h ? Math.sign(x) * (w - h) : 0))
+            .addScaledVector(height, (y / length) * radius + (h > w ? Math.sign(y) * (h - w) : 0));
+    };
+    if (run.hangerStyle !== 'double')
+        return [[center.clone().add(contact(towardHost)), anchor]];
+    const side = new Vector3().crossVectors(direction, towardHost).normalize();
+    return [-1, 1].map((sign) => {
+        const offset = contact(side.clone().multiplyScalar(sign));
+        const from = center.clone().add(offset);
+        // Project each connection onto the host plane instead of translating
+        // the anchor toward/away from it when the duct cross-section is rolled.
+        const to = from.clone().addScaledVector(towardHost, anchor.clone().sub(from).dot(towardHost));
+        return [from, to];
+    });
+}
+export function buildRunHangers(run, ctx) {
+    const group = new Group();
+    group.name = 'auto-hangers';
+    if (!run.autoHangers)
+        return group;
+    const hangers = planRunHangers(run, hangerSceneNodes(ctx));
+    if (!hangers.length)
+        return group;
+    const material = new MeshStandardMaterial({ color: '#92989e', metalness: 0.75, roughness: 0.4 });
+    const rod = (a, b, radius = 0.006) => {
+        const delta = b.clone().sub(a);
+        if (delta.length() < 1e-6)
+            return;
+        const mesh = new Mesh(new CylinderGeometry(radius, radius, delta.length(), 8), material);
+        mesh.position.copy(a).add(b).multiplyScalar(0.5);
+        mesh.quaternion.setFromUnitVectors(new Vector3(0, 1, 0), delta.normalize());
+        group.add(mesh);
+    };
+    for (const hanger of hangers) {
+        const { center, anchor, direction } = hanger;
+        const { width, height } = rectSectionAxes(direction, run.type === 'duct-segment' ? run.roll : 0);
+        const band = new Mesh(buildHangerBandGeometry(run), material);
+        band.name = 'hanger-band';
+        band.position.copy(center);
+        band.quaternion.setFromRotationMatrix(new Matrix4().makeBasis(width, height, direction.clone().negate()));
+        group.add(band);
+        const lines = hangerSupportLines(run, hanger);
+        for (const [from, to] of lines) {
+            rod(from, to);
+            const plate = new Mesh(new BoxGeometry(0.08, 0.08, 0.008), material);
+            plate.position.copy(to);
+            plate.quaternion.setFromUnitVectors(new Vector3(0, 0, 1), anchor.clone().sub(center).normalize());
+            group.add(plate);
+        }
+    }
+    return group;
+}
+export function runHangerFloorplan(run, ctx) {
+    if (!run.autoHangers)
+        return [];
+    return planRunHangers(run, hangerSceneNodes(ctx)).flatMap((hanger) => {
+        const { center, direction } = hanger;
+        const side = new Vector3(-direction.z, 0, direction.x)
+            .normalize()
+            .multiplyScalar(((run.type === 'duct-segment' && run.shape !== 'round' ? run.width : run.diameter) *
+            0.0254) /
+            2 +
+            0.04);
+        return [
+            {
+                kind: 'polyline',
+                points: [
+                    [center.x - side.x, center.z - side.z],
+                    [center.x + side.x, center.z + side.z],
+                ],
+                stroke: '#92989e',
+                strokeWidth: 2,
+                vectorEffect: 'non-scaling-stroke',
+            },
+            ...hangerSupportLines(run, hanger).map(([from, to]) => ({
+                kind: 'polyline',
+                points: [
+                    [from.x, from.z],
+                    [to.x, to.z],
+                ],
+                stroke: '#92989e',
+                strokeWidth: 2,
+                vectorEffect: 'non-scaling-stroke',
+            })),
+        ];
+    });
+}

package/dist/shared/run-port-snap.d.ts

@@ -0,0 +1,11 @@
+import type { ScenePort } from './ports';
+export type PortScreenPoint = {
+    x: number;
+    y: number;
+    depth: number;
+};
+export declare function findScreenPort(ports: readonly ScenePort[], pointer: readonly [number, number], project: (point: ScenePort['position']) => PortScreenPoint | null, source: Pick<ScenePort, 'nodeId' | 'id'> | null, radius?: number): {
+    port: ScenePort;
+    screen: PortScreenPoint;
+} | null;
+//# sourceMappingURL=run-port-snap.d.ts.map

package/dist/shared/run-port-snap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-port-snap.d.ts","sourceRoot":"","sources":["../../src/shared/run-port-snap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,MAAM,MAAM,eAAe,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAErE,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,UAAU,CAAC,KAAK,eAAe,GAAG,IAAI,EACjE,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,GAAG,IAAI,CAAC,GAAG,IAAI,EAC/C,MAAM,SAAK,GACV;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAAG,IAAI,CAcrD"}

package/dist/shared/run-port-snap.js

@@ -0,0 +1,19 @@
+export function findScreenPort(ports, pointer, project, source, radius = 16) {
+    let best = null;
+    let distance = radius;
+    for (const port of ports) {
+        if (source?.nodeId === port.nodeId && source.id === port.id)
+            continue;
+        const screen = project(port.position);
+        if (!screen)
+            continue;
+        const nextDistance = Math.hypot(screen.x - pointer[0], screen.y - pointer[1]);
+        if (!Number.isFinite(nextDistance) || nextDistance > distance)
+            continue;
+        if (best && nextDistance === distance && screen.depth >= best.screen.depth)
+            continue;
+        best = { port, screen };
+        distance = nextDistance;
+    }
+    return best;
+}

package/dist/shared/run-screen-direction.d.ts

@@ -0,0 +1,5 @@
+type Point2 = readonly [number, number];
+export declare function screenDirectionScore(origin: Point2, tip: Point2, pointer: Point2): number;
+export declare function chooseScreenDirection(scores: readonly number[], previous: number): number;
+export {};
+//# sourceMappingURL=run-screen-direction.d.ts.map

package/dist/shared/run-screen-direction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-screen-direction.d.ts","sourceRoot":"","sources":["../../src/shared/run-screen-direction.ts"],"names":[],"mappings":"AAAA,KAAK,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEvC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAYzF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAazF"}

package/dist/shared/run-screen-direction.js

@@ -0,0 +1,24 @@
+export function screenDirectionScore(origin, tip, pointer) {
+    const dx = tip[0] - origin[0], dy = tip[1] - origin[1];
+    const length = Math.hypot(dx, dy);
+    if (length < 2)
+        return Infinity;
+    const px = pointer[0] - origin[0], py = pointer[1] - origin[1];
+    const distance = Math.hypot(px, py);
+    if (px * dx + py * dy <= 0 || distance < 4)
+        return Infinity;
+    return (Math.hypot(px / distance - dx / length, py / distance - dy / length) * Math.min(distance, 100));
+}
+export function chooseScreenDirection(scores, previous) {
+    let best = -1;
+    for (let i = 0; i < scores.length; i++) {
+        if (Number.isFinite(scores[i]) && (best < 0 || scores[i] < scores[best]))
+            best = i;
+    }
+    if (best >= 0 &&
+        previous >= 0 &&
+        Number.isFinite(scores[previous]) &&
+        scores[previous] <= scores[best] + 4)
+        return previous;
+    return best;
+}

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

@@ -47,5 +47,9 @@ export declare function RotateArc({ position, rotation, cursor, onPointerDown, }
     cursor?: Cursor;
     onPointerDown: (e: ThreeEvent<PointerEvent>) => void;
 }): import("react").JSX.Element;
+export declare function ContinuePlusHandle({ position, onActivate, }: {
+    position: Point;
+    onActivate: () => void;
+}): import("react").JSX.Element;
 export {};
 //# sourceMappingURL=selection-handles.d.ts.map

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

@@ -1 +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"}
+{"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;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,UAAU,GACX,EAAE;IACD,QAAQ,EAAE,KAAK,CAAA;IACf,UAAU,EAAE,MAAM,IAAI,CAAA;CACvB,+BAmBA"}

package/dist/shared/selection-handles.js

@@ -72,3 +72,13 @@ export function RotateArc({ position, rotation, cursor = 'grab', onPointerDown,
             onPointerDown(event);
         }, placement: { position, rotation, baseScale }, shape: "curved-arrow" }));
 }
+export function ContinuePlusHandle({ position, onActivate, }) {
+    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: "grab", hover: hovered, hoverScale: 1.15, onHoverChange: setHovered, onPointerDown: (event) => {
+            consumeHandlePress(event);
+            onActivate();
+        }, placement: { position, rotation: [-Math.PI / 2, 0, 0], baseScale }, shape: "plus" }));
+}

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

@@ -1,5 +1,12 @@
-import { type AnyNode, type MaterialSchema, type MaterialTarget, type PaintCapability, type PaintPreviewArgs, type PaintResolveArgs } from '@pascal-app/core';
+import { type AnyNode, type MaterialSchema, type MaterialTarget, type PaintCapability, type PaintPreviewArgs, type PaintResolveArgs, type SceneMaterial, type SceneMaterialId } from '@pascal-app/core';
 import { type Material } from 'three';
+export declare function isSlotPaintPreviewActive(nodeId: string): boolean;
+export declare function subscribeSlotPaintPreviews(listener: (nodeId: string) => void): () => void;
+export type SlotPaintMaterialResolution = {
+    ref: string | undefined;
+    newSceneMaterial: SceneMaterial | null;
+};
+export declare function resolveSlotPaintMaterialRef(materials: Record<SceneMaterialId, SceneMaterial>, material: MaterialSchema | undefined, materialPreset: string | undefined): SlotPaintMaterialResolution | null;
 /** Preview material for a slot paint — mirrors the commit's resolution. */
 export declare function buildSlotPreviewMaterial(material: MaterialSchema | undefined, materialPreset: string | undefined): Material | null;
 /**

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

@@ -1 +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"}
+{"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,EAErB,KAAK,aAAa,EAClB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAQzB,OAAO,EAAE,KAAK,QAAQ,EAAuC,MAAM,OAAO,CAAA;AAsB1E,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CAKzF;AA4DD,MAAM,MAAM,2BAA2B,GAAG;IACxC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;IACvB,gBAAgB,EAAE,aAAa,GAAG,IAAI,CAAA;CACvC,CAAA;AAED,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,EACjD,QAAQ,EAAE,cAAc,GAAG,SAAS,EACpC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,2BAA2B,GAAG,IAAI,CAmBpC;AA2CD,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,CA4B/E;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CA0BjF;AAMD;;;;;;;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,CAmDlF"}

package/dist/shared/slot-paint.js

@@ -1,6 +1,58 @@
 import { generateSceneMaterialId, parseMaterialRef, sceneRegistry, toSceneMaterialRef, useScene, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, useViewer } from '@pascal-app/viewer';
+import { createMaterial, createMaterialFromPresetRef, registerMaterialCacheCleanup, setSurfaceRaycastLayers, useViewer, } from '@pascal-app/viewer';
 import { Raycaster } from 'three';
+/**
+ * Shared paint capability for procedural kinds on the unified slot model
+ * (`node.slots: Record<slotId, MaterialRef>` + the shared scene-material
+ * palette) — the same data shape items derive from their GLB and the shelf
+ * declares via `capabilities.slots`. `surface-paint.ts` configures this helper
+ * for kinds whose entire rendered subtree is one paintable surface.
+ *
+ * The commit / resolve / effective-material logic is identical across kinds;
+ * only the slot-resolution from a pointer hit and the mesh preview differ, so
+ * those are injected per kind.
+ */
+let materialCacheGeneration = 0;
+registerMaterialCacheCleanup(() => {
+    materialCacheGeneration++;
+});
+const previewCounts = new Map();
+const previewListeners = new Set();
+export function isSlotPaintPreviewActive(nodeId) {
+    return previewCounts.has(nodeId);
+}
+export function subscribeSlotPaintPreviews(listener) {
+    previewListeners.add(listener);
+    return () => {
+        previewListeners.delete(listener);
+    };
+}
+function beginSlotPaintPreview(nodeId) {
+    const count = previewCounts.get(nodeId) ?? 0;
+    previewCounts.set(nodeId, count + 1);
+    try {
+        if (count === 0)
+            for (const listener of previewListeners)
+                listener(nodeId);
+    }
+    catch (error) {
+        if (count === 0)
+            previewCounts.delete(nodeId);
+        else
+            previewCounts.set(nodeId, count);
+        throw error;
+    }
+    return () => {
+        const remaining = (previewCounts.get(nodeId) ?? 1) - 1;
+        if (remaining > 0)
+            previewCounts.set(nodeId, remaining);
+        else {
+            previewCounts.delete(nodeId);
+            for (const listener of previewListeners)
+                listener(nodeId);
+        }
+    };
+}
 function deepEqual(a, b) {
     if (Object.is(a, b))
         return true;
@@ -41,36 +93,35 @@ function findMatchingSceneMaterial(materials, material) {
     }
     return null;
 }
+export function resolveSlotPaintMaterialRef(materials, material, materialPreset) {
+    if (material === undefined && materialPreset === undefined) {
+        return { ref: undefined, newSceneMaterial: null };
+    }
+    if (materialPreset)
+        return { ref: materialPreset, newSceneMaterial: null };
+    if (!material)
+        return null;
+    const existing = findMatchingSceneMaterial(materials, material);
+    if (existing)
+        return { ref: toSceneMaterialRef(existing.id), newSceneMaterial: null };
+    const id = generateSceneMaterialId();
+    return {
+        ref: toSceneMaterialRef(id),
+        newSceneMaterial: {
+            id,
+            name: `Material ${Object.keys(materials).length + 1}`,
+            material,
+        },
+    };
+}
 function commitSlotPaint(node, role, material, materialPreset) {
     const nodeId = node.id;
     const state = useScene.getState();
     const currentNode = state.nodes[nodeId] ?? node;
-    let ref;
-    let newSceneMaterial = null;
-    if (material === undefined && materialPreset === undefined) {
-        ref = undefined;
-    }
-    else if (materialPreset) {
-        ref = materialPreset;
-    }
-    else if (material) {
-        const existing = findMatchingSceneMaterial(state.materials, material);
-        if (existing) {
-            ref = toSceneMaterialRef(existing.id);
-        }
-        else {
-            const id = generateSceneMaterialId();
-            newSceneMaterial = {
-                id,
-                name: `Material ${Object.keys(state.materials).length + 1}`,
-                material,
-            };
-            ref = toSceneMaterialRef(id);
-        }
-    }
-    else {
+    const resolution = resolveSlotPaintMaterialRef(state.materials, material, materialPreset);
+    if (!resolution)
         return;
-    }
+    const { ref, newSceneMaterial } = resolution;
     const nextSlots = { ...(currentNode.slots ?? {}) };
     if (ref)
         nextSlots[role] = ref;
@@ -126,6 +177,7 @@ export function previewGeometrySlot(args) {
     const preview = buildSlotPreviewMaterial(material, materialPreset);
     if (!preview)
         return () => { };
+    const generation = materialCacheGeneration;
     const restores = [];
     root.traverse((object) => {
         const mesh = object;
@@ -145,6 +197,10 @@ export function previewGeometrySlot(args) {
     if (restores.length === 0)
         return null;
     return () => {
+        if (generation !== materialCacheGeneration) {
+            useScene.getState().markDirty(args.node.id);
+            return;
+        }
         for (let index = restores.length - 1; index >= 0; index -= 1)
             restores[index]?.();
     };
@@ -159,6 +215,7 @@ export function previewSlotByUserData(args) {
     const preview = buildSlotPreviewMaterial(material, materialPreset);
     if (!preview)
         return () => { };
+    const generation = materialCacheGeneration;
     const restores = [];
     root.traverse((object) => {
         const mesh = object;
@@ -175,12 +232,17 @@ export function previewSlotByUserData(args) {
     if (restores.length === 0)
         return null;
     return () => {
+        if (generation !== materialCacheGeneration) {
+            useScene.getState().markDirty(args.node.id);
+            return;
+        }
         for (let index = restores.length - 1; index >= 0; index -= 1)
             restores[index]?.();
     };
 }
 // Reused across calls — set from the pointer ray each time.
 const subtreeRaycaster = new Raycaster();
+setSurfaceRaycastLayers(subtreeRaycaster.layers);
 /**
  * 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
@@ -218,7 +280,38 @@ export function createSlotPaintCapability(config) {
             return { slots };
         },
         commit: ({ node, role, material, materialPreset }) => commitSlotPaint(node, role, material, materialPreset),
-        applyPreview: config.applyPreview,
+        applyPreview: (args) => {
+            // Release before swapping materials, including each room/all-matching target.
+            const end = beginSlotPaintPreview(args.node.id);
+            let restore;
+            try {
+                restore = config.applyPreview(args);
+            }
+            catch (error) {
+                end();
+                throw error;
+            }
+            if (!restore) {
+                end();
+                return null;
+            }
+            let ended = false;
+            const finish = (committed) => {
+                if (ended)
+                    return;
+                ended = true;
+                try {
+                    if (committed)
+                        useScene.getState().markDirty(args.node.id);
+                    else
+                        restore();
+                }
+                finally {
+                    end();
+                }
+            };
+            return Object.assign(() => finish(false), { commit: () => finish(true) });
+        },
         getEffectiveMaterial: ({ node, role }) => {
             const ref = node.slots?.[role];
             const parsed = parseMaterialRef(ref);

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

@@ -1,3 +1,2 @@
-import type { PaintCapability } from '@pascal-app/core';
-export declare const surfacePaintCapability: PaintCapability;
+export declare const surfacePaintCapability: import("@pascal-app/core").PaintCapability;
 //# sourceMappingURL=surface-paint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"surface-paint.d.ts","sourceRoot":"","sources":["../../src/shared/surface-paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA2B,eAAe,EAAE,MAAM,kBAAkB,CAAA;AA0BhF,eAAO,MAAM,sBAAsB,EAAE,eA4BpC,CAAA"}
+{"version":3,"file":"surface-paint.d.ts","sourceRoot":"","sources":["../../src/shared/surface-paint.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,sBAAsB,4CAwBjC,CAAA"}