@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/shared/accessory-placement.js

@@ -0,0 +1,126 @@
+import { Euler, Matrix4, Quaternion, Vector3 } from 'three';
+import { adapterShape } from '../duct-fitting/ports';
+import { rectSectionAxes } from '../duct-segment/geometry';
+import { reducerOutletDiameter } from './reducer-size';
+export function inheritFittingProfile(node, port, nodes) {
+    const host = nodes[port.nodeId];
+    if (node.type === 'duct-fitting') {
+        const branch = port.id.startsWith('branch');
+        const shape = port.shape ?? (host?.type === 'duct-segment' ? host.shape : undefined);
+        const width = port.width ?? (host?.type === 'duct-segment' ? host.width : undefined);
+        const height = port.height ?? (host?.type === 'duct-segment' ? host.height : undefined);
+        const transitionOutlet = {};
+        if (node.fittingType === 'transition' && shape === adapterShape(node, true)) {
+            const inletShape = adapterShape(node);
+            transitionOutlet.outletShape =
+                inletShape !== shape ? inletShape : shape === 'round' ? 'rect' : 'round';
+            transitionOutlet.diameter2 = node.diameter;
+            transitionOutlet.width2 = node.width;
+            transitionOutlet.height2 = node.height;
+        }
+        return {
+            ...node,
+            ...transitionOutlet,
+            diameter: Math.min(48, Math.max(2, port.diameter)),
+            ...(node.fittingType === 'reducer'
+                ? {
+                    diameter2: reducerOutletDiameter(node.type, Math.min(48, Math.max(2, port.diameter)), node.diameter2),
+                }
+                : {}),
+            system: port.system === 'return' ? 'return' : 'supply',
+            ...(shape
+                ? {
+                    shape,
+                    ...(['reducer', 'transition'].includes(node.fittingType) ? { inletShape: shape } : {}),
+                }
+                : {}),
+            ...(width ? { width } : {}),
+            ...(height ? { height } : {}),
+            ...(host?.type === 'duct-fitting' && !shape
+                ? {
+                    shape: branch ? host.shape2 : host.shape,
+                    width: branch ? host.width2 : host.width,
+                    height: branch ? host.height2 : host.height,
+                }
+                : {}),
+        };
+    }
+    return {
+        ...node,
+        diameter: port.diameter,
+        ...(node.fittingType === 'reducer'
+            ? { diameter2: reducerOutletDiameter(node.type, port.diameter, node.diameter2) }
+            : {}),
+        system: port.system === 'vent' ? 'vent' : 'waste',
+        ...(host?.type === 'pipe-segment' || host?.type === 'pipe-fitting'
+            ? { pipeMaterial: host.pipeMaterial }
+            : {}),
+    };
+}
+export function placeAccessPanel(raw, node, nodes, levelId, in3D, gridStep) {
+    let best = null;
+    let distance = 0.65;
+    const cursor = new Vector3(...raw);
+    for (const host of Object.values(nodes)) {
+        if (host.type !== 'duct-segment' || host.parentId !== levelId || !host.visible)
+            continue;
+        for (let i = 0; i < host.path.length - 1; i++) {
+            const a = new Vector3(...host.path[i]);
+            const delta = new Vector3(...host.path[i + 1]).sub(a);
+            const length = delta.length();
+            if (length < node.panelWidth + 0.04)
+                continue;
+            const tangent = delta.clone().normalize();
+            const planar = new Vector3(delta.x, 0, delta.z);
+            if (!in3D && planar.lengthSq() < 1e-9)
+                continue;
+            let t = in3D
+                ? cursor.clone().sub(a).dot(delta) / delta.lengthSq()
+                : cursor.clone().sub(a).dot(planar) / planar.lengthSq();
+            if (gridStep > 0)
+                t = (Math.round((t * length) / gridStep) * gridStep) / length;
+            const pad = (node.panelWidth / 2 + 0.02) / length;
+            t = Math.max(pad, Math.min(1 - pad, t));
+            const center = a.clone().addScaledVector(delta, t);
+            const up = rectSectionAxes(tangent, host.roll).height;
+            const side = new Vector3().crossVectors(tangent, up).normalize();
+            const offset = cursor.clone().sub(center);
+            let normal = side.clone().multiplyScalar(offset.dot(side) >= 0 ? 1 : -1);
+            let extent = ((host.shape === 'round' ? host.diameter : host.width) * 0.0254) / 2;
+            let faceHeight = (host.shape === 'round' ? host.diameter : host.height) * 0.0254;
+            if (in3D && Math.abs(offset.dot(up)) > Math.abs(offset.dot(side))) {
+                normal = up.clone().multiplyScalar(offset.dot(up) >= 0 ? 1 : -1);
+                extent = ((host.shape === 'round' ? host.diameter : host.height) * 0.0254) / 2;
+                faceHeight = (host.shape === 'round' ? host.diameter : host.width) * 0.0254;
+            }
+            if (node.panelHeight + 0.04 > faceHeight)
+                continue;
+            const position = center.addScaledVector(normal, extent + 0.001);
+            const d = in3D
+                ? cursor.distanceTo(position)
+                : Math.hypot(cursor.x - position.x, cursor.z - position.z);
+            if (d >= distance)
+                continue;
+            distance = d;
+            const vertical = new Vector3().crossVectors(normal, tangent).normalize();
+            const euler = new Euler().setFromRotationMatrix(new Matrix4().makeBasis(tangent, vertical, normal));
+            best = { position: position.toArray(), rotation: [euler.x, euler.y, euler.z] };
+        }
+    }
+    return best;
+}
+export function accessoryMateQuaternion(node, port, nodes) {
+    const direction = new Vector3(...port.direction).normalize();
+    const host = nodes[port.nodeId];
+    if (host?.type === 'duct-segment' &&
+        node.shape !== 'round' &&
+        ['end-cap', 'damper', 'coupling', 'reducer', 'transition'].includes(node.fittingType)) {
+        const index = port.id === 'start' ? 0 : host.path.length - 2;
+        const a = host.path[index];
+        const b = host.path[index + 1];
+        const { width } = rectSectionAxes(new Vector3(...b).sub(new Vector3(...a)), host.roll);
+        const height = new Vector3().crossVectors(width, direction).normalize();
+        return new Quaternion().setFromRotationMatrix(new Matrix4().makeBasis(direction, height, width));
+    }
+    return new Quaternion().setFromUnitVectors(new Vector3(1, 0, 0), direction);
+}

package/dist/shared/accessory-snapping.d.ts

@@ -0,0 +1,5 @@
+import { type ScenePort } from './ports';
+export declare function subscribeAccessorySnapping(refresh: () => void): () => void;
+export declare function snapAccessoryPoint(point: [number, number, number], step: number, normal?: readonly [number, number, number]): [number, number, number];
+export declare function findAccessoryPort(point: [number, number, number], ports: ScenePort[], enabled: boolean, onSurface: boolean): ScenePort | null;
+//# sourceMappingURL=accessory-snapping.d.ts.map

package/dist/shared/accessory-snapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessory-snapping.d.ts","sourceRoot":"","sources":["../../src/shared/accessory-snapping.ts"],"names":[],"mappings":"AACA,OAAO,EAAwC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AAE9E,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAS1E;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACzC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAwB1B;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC/B,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,OAAO,GACjB,SAAS,GAAG,IAAI,CAGlB"}

package/dist/shared/accessory-snapping.js

@@ -0,0 +1,40 @@
+import { useEditor } from '@pascal-app/editor';
+import { findNearestPort3D, findNearestPortXZ } from './ports';
+export function subscribeAccessorySnapping(refresh) {
+    return useEditor.subscribe((state, previous) => {
+        if (state.snappingModeByContext !== previous.snappingModeByContext ||
+            state.gridSnapStep !== previous.gridSnapStep) {
+            refresh();
+        }
+    });
+}
+export function snapAccessoryPoint(point, step, normal) {
+    if (step <= 0)
+        return [...point];
+    const snapped = [
+        Math.round(point[0] / step) * step,
+        normal ? Math.round(point[1] / step) * step : point[1],
+        Math.round(point[2] / step) * step,
+    ];
+    if (normal) {
+        const lengthSq = normal[0] ** 2 + normal[1] ** 2 + normal[2] ** 2;
+        if (lengthSq > 0) {
+            // Project back onto the picked face so rounding never pushes a fitting into its host.
+            const distance = ((snapped[0] - point[0]) * normal[0] +
+                (snapped[1] - point[1]) * normal[1] +
+                (snapped[2] - point[2]) * normal[2]) /
+                lengthSq;
+            return [
+                snapped[0] - distance * normal[0],
+                snapped[1] - distance * normal[1],
+                snapped[2] - distance * normal[2],
+            ];
+        }
+    }
+    return snapped;
+}
+export function findAccessoryPort(point, ports, enabled, onSurface) {
+    if (!enabled)
+        return null;
+    return (onSurface ? findNearestPort3D : findNearestPortXZ)(point, ports, 0.5);
+}

package/dist/shared/automatic-run-end-cap.d.ts

@@ -0,0 +1,12 @@
+import { type AnyNode, type AnyNodeId, DuctFittingNode, type DuctSegmentNode, PipeFittingNode, type PipeSegmentNode } from '@pascal-app/core';
+import type { ScenePort } from './ports';
+export declare function createDuctRunEndCap(duct: DuctSegmentNode, endpoint?: 'start' | 'end'): DuctFittingNode | null;
+export declare function createPipeRunEndCap(pipe: PipeSegmentNode, endpoint?: 'start' | 'end'): PipeFittingNode | null;
+export declare function isRunEndCapPort(port: ScenePort, nodes: Readonly<Record<string, AnyNode>>): boolean;
+export declare function findMatedRunEndCapIds(source: ScenePort | null, nodes: Readonly<Record<string, AnyNode>>, fittingKind: 'duct-fitting' | 'pipe-fitting'): AnyNodeId[];
+export declare function findAutomaticRunEndCapIds(runId: AnyNodeId, nodes: Readonly<Record<string, AnyNode>>, fittingKind: 'duct-fitting' | 'pipe-fitting'): AnyNodeId[];
+export declare function planRunEndCapFollowUpdates(originalRun: DuctSegmentNode | PipeSegmentNode, nextRun: DuctSegmentNode | PipeSegmentNode, endpoint: 'start' | 'end', nodes: Readonly<Record<string, AnyNode>>): {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+}[];
+//# sourceMappingURL=automatic-run-end-cap.d.ts.map

package/dist/shared/automatic-run-end-cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automatic-run-end-cap.d.ts","sourceRoot":"","sources":["../../src/shared/automatic-run-end-cap.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,eAAe,EACf,KAAK,eAAe,EACpB,eAAe,EACf,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAMzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAyCxC,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,eAAe,EACrB,QAAQ,GAAE,OAAO,GAAG,KAAa,GAChC,eAAe,GAAG,IAAI,CAwCxB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,eAAe,EACrB,QAAQ,GAAE,OAAO,GAAG,KAAa,GAChC,eAAe,GAAG,IAAI,CAgCxB;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,OAAO,CAMT;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,GAAG,IAAI,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,WAAW,EAAE,cAAc,GAAG,cAAc,GAC3C,SAAS,EAAE,CAgBb;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,WAAW,EAAE,cAAc,GAAG,cAAc,GAC3C,SAAS,EAAE,CAWb;AAED,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,eAAe,GAAG,eAAe,EAC9C,OAAO,EAAE,eAAe,GAAG,eAAe,EAC1C,QAAQ,EAAE,OAAO,GAAG,KAAK,EACzB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,CAwB7C"}

package/dist/shared/automatic-run-end-cap.js

@@ -0,0 +1,169 @@
+import { DuctFittingNode, PipeFittingNode, } from '@pascal-app/core';
+import { Euler, Quaternion, Vector3 } from 'three';
+import { localFittingPorts } from '../duct-fitting/ports';
+import { ductPortDiameterIn } from '../duct-segment/geometry';
+import { localPipeFittingPorts } from '../pipe-fitting/ports';
+import { accessoryMateQuaternion } from './accessory-placement';
+const END_CAP_OWNER_ID_KEY = 'automaticRunEndCapOwnerId';
+const END_CAP_ENDPOINT_KEY = 'automaticRunEndCapEndpoint';
+function runEndpoint(path, endpoint) {
+    if (path.length < 2)
+        return null;
+    const index = endpoint === 'start' ? 0 : path.length - 1;
+    const neighborIndex = endpoint === 'start' ? 1 : path.length - 2;
+    const position = [...path[index]];
+    const neighbor = path[neighborIndex];
+    const delta = [
+        position[0] - neighbor[0],
+        position[1] - neighbor[1],
+        position[2] - neighbor[2],
+    ];
+    const length = Math.hypot(...delta);
+    return {
+        position,
+        direction: length < 1e-9 ? [1, 0, 0] : [delta[0] / length, delta[1] / length, delta[2] / length],
+    };
+}
+function placeInletAtPort(port, inletPosition, rotation) {
+    const offset = inletPosition.clone().applyQuaternion(rotation);
+    const position = new Vector3(...port.position).sub(offset);
+    const euler = new Euler().setFromQuaternion(rotation);
+    return {
+        position: [position.x, position.y, position.z],
+        rotation: [euler.x, euler.y, euler.z],
+    };
+}
+export function createDuctRunEndCap(duct, endpoint = 'end') {
+    const end = runEndpoint(duct.path, endpoint);
+    if (!end)
+        return null;
+    const port = {
+        ...end,
+        id: endpoint,
+        nodeId: duct.id,
+        diameter: ductPortDiameterIn(duct),
+        shape: duct.shape,
+        width: duct.width,
+        height: duct.height,
+        system: duct.system,
+    };
+    const cap = DuctFittingNode.parse({
+        name: 'End Cap',
+        metadata: {
+            [END_CAP_OWNER_ID_KEY]: duct.id,
+            [END_CAP_ENDPOINT_KEY]: endpoint,
+        },
+        fittingType: 'end-cap',
+        shape: duct.shape,
+        shape2: duct.shape,
+        width: duct.width,
+        height: duct.height,
+        width2: duct.width,
+        height2: duct.height,
+        diameter: port.diameter,
+        diameter2: port.diameter,
+        ductMaterial: duct.ductMaterial,
+        system: duct.system,
+    });
+    const rotation = accessoryMateQuaternion(cap, port, {
+        [duct.id]: duct,
+    });
+    const inlet = localFittingPorts(cap)[0];
+    if (!inlet)
+        return null;
+    return DuctFittingNode.parse({
+        ...cap,
+        ...placeInletAtPort(port, inlet.position, rotation),
+    });
+}
+export function createPipeRunEndCap(pipe, endpoint = 'end') {
+    const end = runEndpoint(pipe.path, endpoint);
+    if (!end)
+        return null;
+    const port = {
+        ...end,
+        id: endpoint,
+        nodeId: pipe.id,
+        diameter: pipe.diameter,
+        system: pipe.system,
+    };
+    const cap = PipeFittingNode.parse({
+        name: 'End Cap',
+        metadata: {
+            [END_CAP_OWNER_ID_KEY]: pipe.id,
+            [END_CAP_ENDPOINT_KEY]: endpoint,
+        },
+        fittingType: 'end-cap',
+        diameter: pipe.diameter,
+        diameter2: pipe.diameter,
+        pipeMaterial: pipe.pipeMaterial,
+        system: pipe.system,
+    });
+    const rotation = new Quaternion().setFromUnitVectors(new Vector3(1, 0, 0), new Vector3(...port.direction).normalize());
+    const inlet = localPipeFittingPorts(cap)[0];
+    if (!inlet)
+        return null;
+    return PipeFittingNode.parse({
+        ...cap,
+        ...placeInletAtPort(port, inlet.position, rotation),
+    });
+}
+export function isRunEndCapPort(port, nodes) {
+    const owner = nodes[port.nodeId];
+    return ((owner?.type === 'duct-fitting' || owner?.type === 'pipe-fitting') &&
+        owner.fittingType === 'end-cap');
+}
+export function findMatedRunEndCapIds(source, nodes, fittingKind) {
+    if (!source)
+        return [];
+    const ids = [];
+    for (const node of Object.values(nodes)) {
+        if (!node || node.type !== fittingKind || node.fittingType !== 'end-cap')
+            continue;
+        if (node.id === source.nodeId) {
+            ids.push(node.id);
+            continue;
+        }
+        if (node.metadata[END_CAP_OWNER_ID_KEY] === source.nodeId &&
+            node.metadata[END_CAP_ENDPOINT_KEY] === source.id)
+            ids.push(node.id);
+    }
+    return ids;
+}
+export function findAutomaticRunEndCapIds(runId, nodes, fittingKind) {
+    return Object.values(nodes).flatMap((node) => {
+        if (!node ||
+            node.type !== fittingKind ||
+            node.fittingType !== 'end-cap' ||
+            node.metadata[END_CAP_OWNER_ID_KEY] !== runId)
+            return [];
+        return [node.id];
+    });
+}
+export function planRunEndCapFollowUpdates(originalRun, nextRun, endpoint, nodes) {
+    if (originalRun.type !== nextRun.type)
+        return [];
+    const originalEnd = runEndpoint(originalRun.path, endpoint);
+    if (!originalEnd)
+        return [];
+    const fittingKind = originalRun.type === 'duct-segment' ? 'duct-fitting' : 'pipe-fitting';
+    const source = {
+        ...originalEnd,
+        id: endpoint,
+        nodeId: originalRun.id,
+        diameter: originalRun.type === 'duct-segment' ? ductPortDiameterIn(originalRun) : originalRun.diameter,
+        system: originalRun.system,
+    };
+    const capIds = findMatedRunEndCapIds(source, nodes, fittingKind);
+    if (capIds.length === 0)
+        return [];
+    const placed = nextRun.type === 'duct-segment'
+        ? createDuctRunEndCap(nextRun, endpoint)
+        : createPipeRunEndCap(nextRun, endpoint);
+    if (!placed)
+        return [];
+    return capIds.map((id) => ({
+        id,
+        data: { position: placed.position, rotation: placed.rotation },
+    }));
+}

package/dist/shared/block-face-host.d.ts

@@ -0,0 +1,15 @@
+import { type BlockNode, type BlockTopology } from '@pascal-app/core';
+import type { ReactNode } from 'react';
+import { Quaternion } from 'three';
+type BlockFaceHostTransform = {
+    position: [number, number, number];
+    quaternion: Quaternion;
+};
+export declare function resolveBlockFaceHostTransform(host: BlockNode | undefined, liveTopology: BlockTopology | undefined, faceId: string): BlockFaceHostTransform | null;
+export declare function BlockFaceHostFrame({ children, blockId, faceId, }: {
+    children: ReactNode;
+    blockId: string;
+    faceId: string;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+export {};
+//# sourceMappingURL=block-face-host.d.ts.map

package/dist/shared/block-face-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-face-host.d.ts","sourceRoot":"","sources":["../../src/shared/block-face-host.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,aAAa,EAInB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC,OAAO,EAAW,UAAU,EAAW,MAAM,OAAO,CAAA;AAEpD,KAAK,sBAAsB,GAAG;IAC5B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAID,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,SAAS,GAAG,SAAS,EAC3B,YAAY,EAAE,aAAa,GAAG,SAAS,EACvC,MAAM,EAAE,MAAM,GACb,sBAAsB,GAAG,IAAI,CA0B/B;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,OAAO,EACP,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,SAAS,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf,+TAgBA"}

package/dist/shared/block-face-host.js

@@ -0,0 +1,36 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getBlockFaceFrame, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { useMemo } from 'react';
+import { Matrix4, Quaternion, Vector3 } from 'three';
+const transformCache = new WeakMap();
+export function resolveBlockFaceHostTransform(host, liveTopology, faceId) {
+    if (host?.type !== 'block')
+        return null;
+    const topology = liveTopology ?? host.topology;
+    let byFace = transformCache.get(topology);
+    if (!byFace) {
+        byFace = new Map();
+        transformCache.set(topology, byFace);
+    }
+    const cached = byFace.get(faceId);
+    if (cached !== undefined || byFace.has(faceId))
+        return cached ?? null;
+    const frame = getBlockFaceFrame(topology, faceId);
+    if (!frame) {
+        byFace.set(faceId, null);
+        return null;
+    }
+    const quaternion = new Quaternion().setFromRotationMatrix(new Matrix4().makeBasis(new Vector3(...frame.xAxis), new Vector3(...frame.yAxis), new Vector3(...frame.normal)));
+    const transform = { position: frame.origin, quaternion };
+    byFace.set(faceId, transform);
+    return transform;
+}
+export function BlockFaceHostFrame({ children, blockId, faceId, }) {
+    const host = useScene((state) => state.nodes[blockId]);
+    const liveTopology = useLiveNodeOverrides((state) => state.get(blockId)?.topology);
+    const transform = useMemo(() => resolveBlockFaceHostTransform(host, liveTopology, faceId), [faceId, host, liveTopology]);
+    if (!transform)
+        return children;
+    return (_jsx("group", { position: transform.position, quaternion: transform.quaternion, children: children }));
+}

package/dist/shared/connection-compatibility.d.ts

@@ -0,0 +1,8 @@
+import type { NodePort } from '@pascal-app/core';
+export type ConnectionProfile = Pick<NodePort, 'system' | 'diameter' | 'shape' | 'width' | 'height'>;
+export type ConnectionCompatibility = {
+    status: 'match' | 'adapter' | 'incompatible' | 'unknown';
+    label: string;
+};
+export declare function connectionCompatibility(source: ConnectionProfile, target: ConnectionProfile): ConnectionCompatibility;
+//# sourceMappingURL=connection-compatibility.d.ts.map

package/dist/shared/connection-compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-compatibility.d.ts","sourceRoot":"","sources":["../../src/shared/connection-compatibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC,CAAA;AACpG,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,cAAc,GAAG,SAAS,CAAA;IACxD,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,iBAAiB,GACxB,uBAAuB,CA+BzB"}

package/dist/shared/connection-compatibility.js

@@ -0,0 +1,28 @@
+export function connectionCompatibility(source, target) {
+    if (source.system && target.system && source.system !== target.system) {
+        return {
+            status: 'incompatible',
+            label: `Different systems: ${source.system} / ${target.system}`,
+        };
+    }
+    const sourceShape = source.shape ?? 'round';
+    const targetShape = target.shape ?? 'round';
+    if (sourceShape !== targetShape) {
+        return { status: 'adapter', label: `Transition needed: ${sourceShape} / ${targetShape}` };
+    }
+    const sourceSize = sourceShape === 'round' ? [source.diameter] : [source.width, source.height];
+    const targetSize = targetShape === 'round' ? [target.diameter] : [target.width, target.height];
+    if ([...sourceSize, ...targetSize].some((value) => value === undefined || !Number.isFinite(value) || value <= 0)) {
+        return { status: 'unknown', label: 'Connection size unavailable' };
+    }
+    if (sourceSize.some((value, index) => Math.abs(value - targetSize[index]) > 0.001)) {
+        return {
+            status: 'adapter',
+            label: `Reducer needed: ${sourceSize.join(' × ')}″ / ${targetSize.join(' × ')}″`,
+        };
+    }
+    if (!source.system || !target.system) {
+        return { status: 'unknown', label: 'Size matches; system unspecified' };
+    }
+    return { status: 'match', label: `Matching system and size: ${target.system}` };
+}

package/dist/shared/connection-feedback.d.ts

@@ -0,0 +1,10 @@
+import type { AnyNodeId } from '@pascal-app/core';
+import { type ConnectionProfile } from './connection-compatibility';
+import { type ScenePort } from './ports';
+export declare function ConnectionFeedback({ point, profile, levelId, target, }: {
+    point: [number, number, number] | null;
+    profile: ConnectionProfile;
+    levelId: AnyNodeId;
+    target?: ScenePort | null;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=connection-feedback.d.ts.map

package/dist/shared/connection-feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-feedback.d.ts","sourceRoot":"","sources":["../../src/shared/connection-feedback.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAQjD,OAAO,EAAE,KAAK,iBAAiB,EAA2B,MAAM,4BAA4B,CAAA;AAC5F,OAAO,EAAwC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AAI9E,wBAAgB,kBAAkB,CAAC,EACjC,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,GACP,EAAE;IACD,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IACtC,OAAO,EAAE,iBAAiB,CAAA;IAC1B,OAAO,EAAE,SAAS,CAAA;IAClB,MAAM,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;CAC1B,sCAgBA"}

package/dist/shared/connection-feedback.js

@@ -0,0 +1,17 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, useEditor, } from '@pascal-app/editor';
+import { connectionCompatibility } from './connection-compatibility';
+import { collectScenePorts, findNearestPort3D } from './ports';
+const COLORS = { match: '#16a34a', adapter: '#d97706', incompatible: '#dc2626', unknown: '#d97706' };
+export function ConnectionFeedback({ point, profile, levelId, target, }) {
+    useEditor((state) => state.snappingModeByContext);
+    if (!point || !(isGridSnapActive() || isMagneticSnapActive() || isAngleSnapActive()))
+        return null;
+    const port = target === undefined ? findNearestPort3D(point, collectScenePorts({ levelId }), 0.5) : target;
+    if (!port)
+        return null;
+    const feedback = connectionCompatibility(profile, port);
+    const color = COLORS[feedback.status];
+    return (_jsx("group", { position: [...port.position], children: _jsxs("mesh", { layers: EDITOR_LAYER, raycast: () => { }, children: [_jsx("sphereGeometry", { args: [0.12, 16, 12] }), _jsx("meshBasicMaterial", { color: color, depthTest: false, transparent: true, opacity: 0.55 })] }) }));
+}

package/dist/shared/distribution-run-contract.d.ts

@@ -0,0 +1,49 @@
+import type { AnyNodeId } from '@pascal-app/core';
+export type RunPoint = [number, number, number];
+export type RunWallSide = 'front' | 'back';
+export type RunSurfaceFrame = {
+    origin: RunPoint;
+    normal: RunPoint;
+    tangent: RunPoint;
+    bitangent: RunPoint;
+};
+export type RunSurfaceBounds = {
+    minU: number;
+    maxU: number;
+    minV: number;
+    maxV: number;
+};
+export type RunWallAttachment = {
+    wallId: Extract<AnyNodeId, `wall_${string}`>;
+    side: RunWallSide;
+    startUV: [number, number];
+    endUV: [number, number];
+    offset: number;
+};
+/**
+ * The surface selected for the current run. A wall target is semantic: the
+ * host id and side are required so later snapping cannot fall back to any
+ * other object that happens to be close in the viewport.
+ */
+export type RunSurfaceTarget = {
+    kind: 'floor' | 'ceiling' | 'surface';
+    hostId?: AnyNodeId;
+    levelId: AnyNodeId;
+    frame: RunSurfaceFrame;
+} | {
+    kind: 'wall';
+    levelId: AnyNodeId;
+    hostId: AnyNodeId;
+    side: RunWallSide;
+    frame: RunSurfaceFrame;
+    bounds: RunSurfaceBounds;
+};
+/** Move a run centerline clear of a wall face along the captured normal. */
+export declare function offsetRunPointFromSurface(point: RunPoint, target: RunSurfaceTarget | null, offset: number): RunPoint;
+export declare function runPointToSurfaceUV(point: RunPoint, target: Extract<RunSurfaceTarget, {
+    kind: 'wall';
+}>): [number, number];
+export declare function createRunWallAttachment(wallId: Extract<AnyNodeId, `wall_${string}`>, side: RunWallSide, start: RunPoint, end: RunPoint, target: Extract<RunSurfaceTarget, {
+    kind: 'wall';
+}>, offset: number): RunWallAttachment;
+//# sourceMappingURL=distribution-run-contract.d.ts.map

package/dist/shared/distribution-run-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distribution-run-contract.d.ts","sourceRoot":"","sources":["../../src/shared/distribution-run-contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,MAAM,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE/C,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,MAAM,CAAA;AAE1C,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,QAAQ,CAAA;IAChB,OAAO,EAAE,QAAQ,CAAA;IACjB,SAAS,EAAE,QAAQ,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE,QAAQ,MAAM,EAAE,CAAC,CAAA;IAC5C,IAAI,EAAE,WAAW,CAAA;IACjB,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACzB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GACxB;IACE,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAA;IACrC,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,eAAe,CAAA;CACvB,GACD;IACE,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,SAAS,CAAA;IAClB,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,WAAW,CAAA;IACjB,KAAK,EAAE,eAAe,CAAA;IACtB,MAAM,EAAE,gBAAgB,CAAA;CACzB,CAAA;AAEL,4EAA4E;AAC5E,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,gBAAgB,GAAG,IAAI,EAC/B,MAAM,EAAE,MAAM,GACb,QAAQ,CAOV;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GAClD,CAAC,MAAM,EAAE,MAAM,CAAC,CAUlB;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE,QAAQ,MAAM,EAAE,CAAC,EAC5C,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,QAAQ,EACf,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACnD,MAAM,EAAE,MAAM,GACb,iBAAiB,CAQnB"}

package/dist/shared/distribution-run-contract.js

@@ -0,0 +1,30 @@
+/** Move a run centerline clear of a wall face along the captured normal. */
+export function offsetRunPointFromSurface(point, target, offset) {
+    if (!target || offset === 0)
+        return [...point];
+    return [
+        point[0] + target.frame.normal[0] * offset,
+        point[1] + target.frame.normal[1] * offset,
+        point[2] + target.frame.normal[2] * offset,
+    ];
+}
+export function runPointToSurfaceUV(point, target) {
+    const dx = point[0] - target.frame.origin[0];
+    const dy = point[1] - target.frame.origin[1];
+    const dz = point[2] - target.frame.origin[2];
+    return [
+        dx * target.frame.tangent[0] + dy * target.frame.tangent[1] + dz * target.frame.tangent[2],
+        dx * target.frame.bitangent[0] +
+            dy * target.frame.bitangent[1] +
+            dz * target.frame.bitangent[2],
+    ];
+}
+export function createRunWallAttachment(wallId, side, start, end, target, offset) {
+    return {
+        wallId,
+        side,
+        startUV: runPointToSurfaceUV(start, target),
+        endUV: runPointToSurfaceUV(end, target),
+        offset,
+    };
+}