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

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"}

package/dist/shared/surface-paint.js

@@ -1,21 +1,10 @@
-import { createMaterial, createMaterialFromPresetRef } from '@pascal-app/viewer';
-function buildPreviewMaterial(material, materialPreset) {
-    if (materialPreset)
-        return createMaterialFromPresetRef(materialPreset);
-    if (material)
-        return createMaterial(material);
-    return null;
-}
-export const surfacePaintCapability = {
-    // One paintable surface — every face resolves to it.
+import { buildSlotPreviewMaterial, createSlotPaintCapability } from './slot-paint';
+export const surfacePaintCapability = createSlotPaintCapability({
     resolveRole: () => 'surface',
-    buildPatch: ({ material, materialPreset }) => ({ material, materialPreset }),
     applyPreview: ({ material, materialPreset, root }) => {
-        const preview = buildPreviewMaterial(material, materialPreset);
+        const preview = buildSlotPreviewMaterial(material, materialPreset);
         if (!preview)
             return null;
-        // The kinds register a group, so walk the subtree and swap every child
-        // mesh's material, recording a restore for each.
         const restores = [];
         root.traverse((object) => {
             const mesh = object;
@@ -30,12 +19,12 @@ export const surfacePaintCapability = {
         if (restores.length === 0)
             return null;
         return () => {
-            for (let i = restores.length - 1; i >= 0; i -= 1)
-                restores[i]?.();
+            for (let index = restores.length - 1; index >= 0; index -= 1)
+                restores[index]?.();
         };
     },
-    getEffectiveMaterial: ({ node }) => {
-        const n = node;
-        return { material: n.material, materialPreset: n.materialPreset };
+    legacyEffective: (node) => {
+        const legacy = node;
+        return { material: legacy.material, materialPreset: legacy.materialPreset };
     },
-};
+});

package/dist/shared/system-check-panel.d.ts

@@ -0,0 +1,6 @@
+import { type AnyNode, type AnyNodeId } from '@pascal-app/core';
+export default function SystemCheckPanel({ nodeId, nodes, }: {
+    nodeId: AnyNodeId;
+    nodes: Record<AnyNodeId, AnyNode>;
+}): import("react").JSX.Element;
+//# sourceMappingURL=system-check-panel.d.ts.map

package/dist/shared/system-check-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-check-panel.d.ts","sourceRoot":"","sources":["../../src/shared/system-check-panel.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AA0BzB,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,EACvC,MAAM,EACN,KAAK,GACN,EAAE;IACD,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;CAClC,+BAyMA"}

package/dist/shared/system-check-panel.js

@@ -0,0 +1,62 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, getLevelElevations, summarizeSystemFor, } from '@pascal-app/core';
+import { useViewer } from '@pascal-app/viewer';
+import { AlertTriangle, CheckCircle2, ChevronDown, ChevronRight, Crosshair, ShieldCheck, XCircle, } from 'lucide-react';
+import { useId, useMemo, useState } from 'react';
+import { checkDistributionSystems } from './system-checks';
+const CATEGORIES = [
+    { id: 'all', label: 'All findings' },
+    { id: 'open-end', label: 'Open ends' },
+    { id: 'connection-mismatch', label: 'Connections' },
+    { id: 'disconnected-branch', label: 'Separate branches' },
+    { id: 'possible-intersection', label: 'Intersections' },
+    { id: 'drainage', label: 'Drainage' },
+    { id: 'unsupported-hanger', label: 'Hangers' },
+];
+const categoryFor = (code) => ['slope-too-flat', 'slope-too-steep', 'trap-arm-too-long'].includes(code) ? 'drainage' : code;
+export default function SystemCheckPanel({ nodeId, nodes, }) {
+    const contentId = useId();
+    const [open, setOpen] = useState(false);
+    const [filter, setFilter] = useState('all');
+    const summary = useMemo(() => (open ? summarizeSystemFor(nodeId, nodes) : null), [nodeId, nodes, open]);
+    const findings = useMemo(() => (open ? checkDistributionSystems(nodes) : []), [nodes, open]);
+    const visibleFindings = findings.filter((finding) => filter === 'all' || categoryFor(finding.code) === filter);
+    const errorCount = findings.filter((finding) => finding.severity === 'error').length;
+    const warningCount = findings.length - errorCount;
+    const reveal = (id) => {
+        const node = nodes[id];
+        if (!node)
+            return;
+        let parent = node;
+        const visited = new Set();
+        while (parent.parentId && parent.type !== 'level' && !visited.has(parent.id)) {
+            visited.add(parent.id);
+            const next = nodes[parent.parentId];
+            if (!next)
+                break;
+            parent = next;
+        }
+        const buildingId = parent.type === 'level' ? getLevelElevations(nodes).get(parent.id)?.buildingId : null;
+        const building = buildingId ? nodes[buildingId] : null;
+        useViewer.getState().setSelection({
+            ...(building?.type === 'building' ? { buildingId: building.id } : {}),
+            ...(parent.type === 'level' ? { levelId: parent.id } : {}),
+            selectedIds: [id],
+        });
+        emitter.emit('camera-controls:focus', { nodeId: id });
+        emitter.emit('selection:find-node', node);
+    };
+    return (_jsxs("section", { className: "border-t border-border/50", children: [_jsxs("button", { type: "button", className: "flex w-full items-center gap-2 px-3 py-3 text-left text-xs font-medium transition-colors hover:bg-muted/50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring", "aria-expanded": open, "aria-controls": contentId, onClick: () => setOpen((value) => !value), children: [_jsx(ShieldCheck, { className: "size-4 text-muted-foreground", "aria-hidden": "true" }), _jsx("span", { className: "flex-1", children: "System checks" }), open && (_jsx("span", { className: "rounded-md bg-muted px-1.5 py-0.5 text-[10px] tabular-nums text-muted-foreground", children: findings.length })), _jsx(ChevronDown, { className: `size-3.5 text-muted-foreground transition-transform ${open ? '' : '-rotate-90'}`, "aria-hidden": "true" })] }), open && (_jsxs("div", { id: contentId, className: "space-y-3 px-3 pb-3", children: [_jsxs("div", { className: "flex items-center justify-between gap-2 text-[11px] text-muted-foreground", children: [_jsx("span", { children: "All systems" }), summary && (_jsxs("span", { className: "tabular-nums", title: "Selected connected system", children: ["Selected: ", summary.runCount, " ", summary.runCount === 1 ? 'run' : 'runs', " \u00B7", ' ', summary.runLengthM.toFixed(1), " m"] }))] }), _jsxs("div", { className: "grid grid-cols-2 gap-2", children: [_jsxs("div", { className: "flex items-center gap-2 rounded-lg border border-border/60 bg-muted/20 px-2.5 py-2", children: [_jsx(XCircle, { className: `size-4 ${errorCount ? 'text-red-500' : 'text-muted-foreground'}`, "aria-hidden": "true" }), _jsx("span", { className: "text-sm font-semibold tabular-nums", children: errorCount }), _jsx("span", { className: "text-[11px] text-muted-foreground", children: "Errors" })] }), _jsxs("div", { className: "flex items-center gap-2 rounded-lg border border-border/60 bg-muted/20 px-2.5 py-2", children: [_jsx(AlertTriangle, { className: `size-4 ${warningCount ? 'text-amber-500' : 'text-muted-foreground'}`, "aria-hidden": "true" }), _jsx("span", { className: "text-sm font-semibold tabular-nums", children: warningCount }), _jsx("span", { className: "text-[11px] text-muted-foreground", children: "Warnings" })] })] }), _jsxs("div", { className: "relative", children: [_jsx("select", { "aria-label": "Filter system checks", value: filter, onChange: (event) => setFilter(event.target.value), className: "h-9 w-full appearance-none rounded-lg border border-border bg-background px-3 pr-8 text-xs outline-none focus-visible:ring-2 focus-visible:ring-ring", children: CATEGORIES.map((category) => (_jsxs("option", { value: category.id, children: [category.label, " (", category.id === 'all'
+                                            ? findings.length
+                                            : findings.filter((finding) => categoryFor(finding.code) === category.id)
+                                                .length, ")"] }, category.id))) }), _jsx(ChevronDown, { className: "pointer-events-none absolute right-3 top-3 size-3.5 text-muted-foreground", "aria-hidden": "true" })] }), visibleFindings.length ? (_jsx("ul", { className: "max-h-72 space-y-2 overflow-y-auto overscroll-contain pr-1", "aria-label": "System findings", children: visibleFindings.map((finding, index) => {
+                            const error = finding.severity === 'error';
+                            const Icon = error ? XCircle : AlertTriangle;
+                            const label = CATEGORIES.find((category) => category.id === categoryFor(finding.code))?.label ??
+                                'System finding';
+                            return (_jsxs("li", { className: "overflow-hidden rounded-lg border border-border/60 bg-muted/10 p-2.5", children: [_jsxs("div", { className: "mb-1.5 flex items-center gap-2", children: [_jsx(Icon, { className: `size-3.5 shrink-0 ${error ? 'text-red-500' : 'text-amber-500'}`, "aria-hidden": "true" }), _jsx("span", { className: "min-w-0 flex-1 text-xs font-medium", children: label }), _jsx("span", { className: `text-[10px] font-medium ${error ? 'text-red-600 dark:text-red-400' : 'text-amber-700 dark:text-amber-400'}`, children: error ? 'Error' : 'Warning' })] }), _jsx("p", { className: "break-words text-[11px] leading-relaxed text-muted-foreground", children: finding.message }), _jsx("div", { className: "mt-2 flex flex-wrap gap-1.5", children: finding.nodeIds.map((id) => (_jsxs("button", { type: "button", disabled: !nodes[id], title: `Locate ${nodes[id]?.name || nodes[id]?.type || 'item'} (${id})`, onClick: () => reveal(id), className: "inline-flex max-w-full items-center gap-1.5 rounded-md border border-border/60 bg-background px-2 py-1 text-[10px] transition-colors hover:bg-muted focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50", children: [_jsx(Crosshair, { className: "size-3 shrink-0 text-muted-foreground", "aria-hidden": "true" }), _jsx("span", { className: "truncate", children: nodes[id]?.name ||
+                                                        nodes[id]?.type.replaceAll('-', ' ') ||
+                                                        'Missing item' }), _jsx(ChevronRight, { className: "size-3 shrink-0 text-muted-foreground", "aria-hidden": "true" })] }, id))) })] }, `${finding.code}:${finding.nodeIds.join(':')}:${index}`));
+                        }) })) : (_jsxs("div", { role: "status", className: "flex flex-col items-center gap-2 rounded-lg border border-dashed border-border px-3 py-5 text-center", children: [_jsx(CheckCircle2, { className: "size-5 text-emerald-500", "aria-hidden": "true" }), _jsx("span", { className: "text-xs font-medium", children: findings.length ? 'No findings in this category' : 'No findings' }), filter !== 'all' && (_jsx("button", { type: "button", className: "text-[11px] text-muted-foreground underline underline-offset-4 hover:text-foreground", onClick: () => setFilter('all'), children: "Show all findings" }))] })), _jsxs("details", { className: "text-[10px] leading-relaxed text-muted-foreground", children: [_jsx("summary", { className: "cursor-pointer hover:text-foreground", children: "About these checks" }), _jsx("p", { className: "pt-1.5", children: "Open ends and separate branches may be intentional. Intersection checks use bounding boxes; inspect openings and clearances." })] })] }))] }));
+}

package/dist/shared/system-checks.d.ts

@@ -0,0 +1,9 @@
+import { type AnyNode, type AnyNodeId } from '@pascal-app/core';
+export type SystemFinding = {
+    code: string;
+    message: string;
+    nodeIds: AnyNodeId[];
+    severity: 'error' | 'warning';
+};
+export declare function checkDistributionSystems(nodes: Record<AnyNodeId, AnyNode>): SystemFinding[];
+//# sourceMappingURL=system-checks.d.ts.map

package/dist/shared/system-checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-checks.d.ts","sourceRoot":"","sources":["../../src/shared/system-checks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAUf,MAAM,kBAAkB,CAAA;AAKzB,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;CAC9B,CAAA;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,aAAa,EAAE,CAmI3F"}

package/dist/shared/system-checks.js

@@ -0,0 +1,131 @@
+import { buildPortComponents, collectSystemPorts, distributionPointToWorld, getWallBaseElevationForNodes, getWallCurveFrameAt, getWallEffectiveHeightForNodes, getWallThickness, nodeRegistry, validateDwv, } from '@pascal-app/core';
+import { Box3, Ray, Vector3 } from 'three';
+import { connectionCompatibility } from './connection-compatibility';
+import { planRunHangerSlots } from './run-hangers';
+export function checkDistributionSystems(nodes) {
+    const findings = [...validateDwv(nodes)];
+    const ports = collectSystemPorts(nodes);
+    const joined = new Set();
+    const connectedPairs = new Set();
+    for (let i = 0; i < ports.length; i++) {
+        const a = ports[i];
+        for (let j = i + 1; j < ports.length; j++) {
+            const b = ports[j];
+            if (a.nodeId === b.nodeId || Math.hypot(a.x - b.x, a.y - b.y, a.z - b.z) > 0.05)
+                continue;
+            joined.add(i);
+            joined.add(j);
+            connectedPairs.add([a.nodeId, b.nodeId].sort().join('|'));
+            const profile = (entry) => {
+                const node = nodes[entry.nodeId];
+                return node?.type === 'duct-segment'
+                    ? { ...entry.port, shape: node.shape, width: node.width, height: node.height }
+                    : entry.port;
+            };
+            const compatibility = connectionCompatibility(profile(a), profile(b));
+            if (compatibility.status !== 'match')
+                findings.push({
+                    code: 'connection-mismatch',
+                    message: compatibility.label,
+                    nodeIds: [a.nodeId, b.nodeId],
+                    severity: compatibility.status === 'incompatible' ? 'error' : 'warning',
+                });
+        }
+    }
+    ports.forEach((entry, index) => {
+        if (!joined.has(index))
+            findings.push({
+                code: 'open-end',
+                message: `Open connection: ${entry.port.id}`,
+                nodeIds: [entry.nodeId],
+                severity: 'warning',
+            });
+    });
+    const components = buildPortComponents(nodes);
+    for (const component of components) {
+        const hasEquipment = component.some((id) => nodeRegistry.get(nodes[id].type)?.distributionRole === 'equipment');
+        const systems = new Set(ports.filter((port) => component.includes(port.nodeId)).map((port) => port.system));
+        const hasSeparatePeer = components.some((other) => other !== component &&
+            ports.some((port) => other.includes(port.nodeId) && systems.has(port.system)));
+        if (!hasEquipment && hasSeparatePeer)
+            findings.push({
+                code: 'disconnected-branch',
+                message: 'Separate branch: no connection to the other branches of this system. Review whether this is intentional.',
+                nodeIds: component,
+                severity: 'warning',
+            });
+    }
+    const runs = Object.values(nodes).filter((node) => node.type === 'duct-segment' || node.type === 'pipe-segment');
+    const world = (node, point) => new Vector3(...distributionPointToWorld(node, point, nodes));
+    const segments = runs.flatMap((run) => {
+        const radius = ((run.type === 'duct-segment' && run.shape !== 'round'
+            ? Math.hypot(run.width, run.height)
+            : run.diameter) *
+            0.0254) /
+            2;
+        return run.path.slice(1).map((point, index) => ({
+            run,
+            a: world(run, run.path[index]),
+            b: world(run, point),
+            radius,
+        }));
+    });
+    const clashes = new Set();
+    const addClash = (a, b, message) => {
+        const key = [a, b].sort().join('|');
+        if (clashes.has(key))
+            return;
+        clashes.add(key);
+        findings.push({ code: 'possible-intersection', message, nodeIds: [a, b], severity: 'warning' });
+    };
+    for (let i = 0; i < segments.length; i++) {
+        const a = segments[i];
+        for (let j = i + 1; j < segments.length; j++) {
+            const b = segments[j];
+            if (a.run.id === b.run.id || connectedPairs.has([a.run.id, b.run.id].sort().join('|')))
+                continue;
+            const box = new Box3().setFromPoints([b.a, b.b]).expandByScalar(a.radius + b.radius);
+            if (segmentHitsBox(a.a, a.b, box))
+                addClash(a.run.id, b.run.id, 'Possible run intersection. Inspect the highlighted runs.');
+        }
+    }
+    for (const wall of Object.values(nodes)) {
+        if (wall.type !== 'wall')
+            continue;
+        const base = getWallBaseElevationForNodes(wall, nodes);
+        const top = base + getWallEffectiveHeightForNodes(wall, nodes);
+        const points = [];
+        for (let i = 0; i <= 16; i++) {
+            const frame = getWallCurveFrameAt(wall, i / 16);
+            points.push(world(wall, [frame.point.x, base, frame.point.y]), world(wall, [frame.point.x, top, frame.point.y]));
+        }
+        const box = new Box3().setFromPoints(points).expandByScalar(getWallThickness(wall) / 2);
+        for (const segment of segments) {
+            if (segment.run.wallAttachment?.wallId === wall.id)
+                continue;
+            if (segmentHitsBox(segment.a, segment.b, box.clone().expandByScalar(segment.radius)))
+                addClash(segment.run.id, wall.id, 'Possible wall intersection. Check the wall opening and run clearance.');
+        }
+    }
+    for (const run of runs) {
+        const missing = planRunHangerSlots(run, nodes).filter((slot) => !slot.skipped && !slot.hanger);
+        if (missing.length)
+            findings.push({
+                code: 'unsupported-hanger',
+                message: `${missing.length} hanger${missing.length === 1 ? '' : 's'} without a support.`,
+                nodeIds: [run.id],
+                severity: 'warning',
+            });
+    }
+    return findings.sort((a, b) => Number(a.severity !== 'error') - Number(b.severity !== 'error'));
+}
+function segmentHitsBox(start, end, box) {
+    if (box.containsPoint(start))
+        return true;
+    const delta = end.clone().sub(start);
+    const length = delta.length();
+    if (length < 1e-9)
+        return false;
+    const hit = new Ray(start, delta.divideScalar(length)).intersectBox(box, new Vector3());
+    return !!hit && hit.distanceTo(start) <= length;
+}

package/dist/shared/wall-attach-target.d.ts

@@ -49,6 +49,18 @@ export declare function projectWallLocalPointToPlan(wall: WallNode, localX: numb
  * overlay is then a faithful picture of where this snaps.
  */
 export declare function findClosestWallInPlan(planPoint: readonly [number, number], nodes: Record<AnyNodeId, AnyNode>, parentLevelId: AnyNodeId | null, excludeWallId?: AnyNodeId): WallHit | null;
+export type WallPlanAttachment = Omit<WallHit, 'wall'> & {
+    distance: number;
+};
+/** Resolve a plan point against one wall, including its curved centerline. */
+export declare function resolveWallAttachmentAtPlanPoint(wall: WallNode, planPoint: readonly [number, number], maxDistance?: number): WallPlanAttachment | null;
+/**
+ * Return the closest wall attachment target in plan space, including curved
+ * walls. This is deliberately separate from `findClosestWallInPlan`: doors,
+ * windows, and wall-mounted items still use the straight-wall-only opening
+ * query, while lean-to canopies have analytic curved-wall support.
+ */
+export declare function findClosestWallAttachmentInPlan(planPoint: readonly [number, number], nodes: Record<AnyNodeId, AnyNode>, parentLevelId: AnyNodeId | null, excludeWallId?: AnyNodeId): WallHit | null;
 /**
  * Figma-style alignment for a wall-hosted opening / item, along the wall
  * axis. Snaps the moving node's edges (or centre) to other attachments'
@@ -84,7 +96,7 @@ export declare function snapLocalXToNeighbors(args: {
  * window-math had byte-identical copies of this. Y conventions differ per kind
  * (items store bottom Y; doors/windows store centre Y), handled inline.
  */
-export declare function hasWallChildOverlap(wallId: string, clampedX: number, clampedY: number, width: number, height: number, ignoreId?: string): boolean;
+export declare function hasWallChildOverlap(wallId: string, nodes: Readonly<Record<string, AnyNode>>, clampedX: number, clampedY: number, width: number, height: number, ignoreId?: string): boolean;
 /** Placement state for a wall-hosted opening — the SINGLE decision the preview
  *  tint and the commit gate both consume so they can never disagree. */
 export type OpeningPlacement = {
@@ -98,7 +110,7 @@ export type OpeningPlacement = {
 };
 /**
  * Resolve the placement state from the raw collision result and whether the
- * user is force-placing (Shift). Force-place lifts the collision block, so the
+ * user is force-placing (held Alt). Force-place lifts the collision block, so the
  * opening becomes placeable AND the tint goes green — the preview and the
  * commit gate stay in lockstep because both read this one result.
  */

package/dist/shared/wall-attach-target.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-attach-target.d.ts","sourceRoot":"","sources":["../../src/shared/wall-attach-target.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAOd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,QAAQ,CAAA;IACd,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAA;IACd,gFAAgF;IAChF,YAAY,EAAE,MAAM,CAAA;IACpB,iDAAiD;IACjD,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;IACtB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;;OAOG;IACH,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,EACd,MAAM,SAAI,GACT,CAAC,MAAM,EAAE,MAAM,CAAC,CAKlB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,SAAS,GAAG,IAAI,EAC/B,aAAa,CAAC,EAAE,SAAS,GACxB,OAAO,GAAG,IAAI,CA+BhB;AAwBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,MAAM,GAAG,IAAI,CAiChB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAmDT;AAED;wEACwE;AACxE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAA;IACjB;+BAC2B;IAC3B,SAAS,EAAE,OAAO,CAAA;IAClB,sDAAsD;IACtD,IAAI,EAAE,OAAO,GAAG,SAAS,CAAA;CAC1B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,QAAQ,EAAE,OAAO,CAAA;IACjB,UAAU,EAAE,OAAO,CAAA;CACpB,GAAG,gBAAgB,CAOnB"}
+{"version":3,"file":"wall-attach-target.d.ts","sourceRoot":"","sources":["../../src/shared/wall-attach-target.ts"],"names":[],"mappings":"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"}

package/dist/shared/wall-attach-target.js

@@ -1,4 +1,4 @@
-import { collectLevelWallSegments, getScaledDimensions, nearestWallSegment, useScene, WALL_SNAP_DISTANCE_M, } from '@pascal-app/core';
+import { collectLevelWallSegments, getScaledDimensions, getWallArcData, getWallCurveFrameAt, getWallCurveLength, isCurvedWall, nearestWallSegment, WALL_SNAP_DISTANCE_M, } from '@pascal-app/core';
 export function projectWallLocalPointToPlan(wall, localX, localZ = 0) {
     const angle = -Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
     const c = Math.cos(angle);
@@ -40,6 +40,111 @@ export function findClosestWallInPlan(planPoint, nodes, parentLevelId, excludeWa
         itemRotation,
     };
 }
+function closestCurvedWallInPlan(wall, planPoint, maxDistance) {
+    const arc = getWallArcData(wall);
+    const wallLength = getWallCurveLength(wall);
+    if (!arc || wallLength <= 1e-6)
+        return null;
+    const pointAngle = Math.atan2(planPoint[1] - arc.center.y, planPoint[0] - arc.center.x);
+    let directedAngle = (pointAngle - arc.startAngle) * arc.direction;
+    while (directedAngle < 0)
+        directedAngle += Math.PI * 2;
+    const candidates = [0, 1];
+    const arcAngle = Math.abs(arc.delta);
+    if (directedAngle <= arcAngle)
+        candidates.push(directedAngle / arcAngle);
+    let best = null;
+    for (const t of candidates) {
+        const frame = getWallCurveFrameAt(wall, t);
+        const distance = Math.hypot(planPoint[0] - frame.point.x, planPoint[1] - frame.point.y);
+        if (!best || distance < best.distance)
+            best = { distance, t };
+    }
+    if (!best || best.distance > maxDistance)
+        return null;
+    const frame = getWallCurveFrameAt(wall, best.t);
+    const perpDistance = (planPoint[0] - frame.point.x) * frame.normal.x +
+        (planPoint[1] - frame.point.y) * frame.normal.y;
+    return {
+        distance: best.distance,
+        localX: wallLength * best.t,
+        perpDistance,
+        dirX: frame.tangent.x,
+        dirY: frame.tangent.y,
+        wallLength,
+    };
+}
+/** Resolve a plan point against one wall, including its curved centerline. */
+export function resolveWallAttachmentAtPlanPoint(wall, planPoint, maxDistance = WALL_SNAP_DISTANCE_M) {
+    if (!isCurvedWall(wall)) {
+        const dx = wall.end[0] - wall.start[0];
+        const dz = wall.end[1] - wall.start[1];
+        const wallLength = Math.hypot(dx, dz);
+        if (wallLength <= 1e-6)
+            return null;
+        const dirX = dx / wallLength;
+        const dirY = dz / wallLength;
+        const px = planPoint[0] - wall.start[0];
+        const pz = planPoint[1] - wall.start[1];
+        const localX = Math.max(0, Math.min(wallLength, px * dirX + pz * dirY));
+        const perpDistance = px * -dirY + pz * dirX;
+        const closestX = wall.start[0] + dirX * localX;
+        const closestZ = wall.start[1] + dirY * localX;
+        const distance = Math.hypot(planPoint[0] - closestX, planPoint[1] - closestZ);
+        if (distance > maxDistance)
+            return null;
+        const side = perpDistance >= 0 ? 'front' : 'back';
+        return {
+            distance,
+            localX,
+            perpDistance,
+            side,
+            dirX,
+            dirY,
+            wallLength,
+            itemRotation: side === 'front' ? 0 : Math.PI,
+        };
+    }
+    const curvedHit = closestCurvedWallInPlan(wall, planPoint, maxDistance);
+    if (!curvedHit || curvedHit.distance > maxDistance)
+        return null;
+    const side = curvedHit.perpDistance >= 0 ? 'front' : 'back';
+    return {
+        distance: curvedHit.distance,
+        localX: curvedHit.localX,
+        perpDistance: curvedHit.perpDistance,
+        side,
+        dirX: curvedHit.dirX,
+        dirY: curvedHit.dirY,
+        wallLength: curvedHit.wallLength,
+        itemRotation: side === 'front' ? 0 : Math.PI,
+    };
+}
+/**
+ * Return the closest wall attachment target in plan space, including curved
+ * walls. This is deliberately separate from `findClosestWallInPlan`: doors,
+ * windows, and wall-mounted items still use the straight-wall-only opening
+ * query, while lean-to canopies have analytic curved-wall support.
+ */
+export function findClosestWallAttachmentInPlan(planPoint, nodes, parentLevelId, excludeWallId) {
+    if (!parentLevelId)
+        return null;
+    const level = nodes[parentLevelId];
+    const childIds = level?.children;
+    if (!Array.isArray(childIds))
+        return null;
+    let best = null;
+    for (const childId of childIds) {
+        const node = nodes[childId];
+        if (node?.type !== 'wall' || node.id === excludeWallId)
+            continue;
+        const attachment = resolveWallAttachmentAtPlanPoint(node, planPoint);
+        if (!attachment || (best && attachment.distance >= best.distance))
+            continue;
+        best = { hit: { wall: node, ...attachment }, distance: attachment.distance };
+    }
+    return best?.hit ?? null;
+}
 /** Figma-style along-wall alignment threshold (meters) — parity with the
  *  XZ placement / move threshold. */
 const ALONG_WALL_ALIGN_THRESHOLD_M = 0.08;
@@ -121,8 +226,7 @@ export function snapLocalXToNeighbors(args) {
  * window-math had byte-identical copies of this. Y conventions differ per kind
  * (items store bottom Y; doors/windows store centre Y), handled inline.
  */
-export function hasWallChildOverlap(wallId, clampedX, clampedY, width, height, ignoreId) {
-    const nodes = useScene.getState().nodes;
+export function hasWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height, ignoreId) {
     const wallNode = nodes[wallId];
     if (!wallNode)
         return true;
@@ -178,7 +282,7 @@ export function hasWallChildOverlap(wallId, clampedX, clampedY, width, height, i
 }
 /**
  * Resolve the placement state from the raw collision result and whether the
- * user is force-placing (Shift). Force-place lifts the collision block, so the
+ * user is force-placing (held Alt). Force-place lifts the collision block, so the
  * opening becomes placeable AND the tint goes green — the preview and the
  * commit gate stay in lockstep because both read this one result.
  */

package/dist/shared/wall-opening-clearance.d.ts

@@ -0,0 +1,19 @@
+import type { AnyNode, AnyNodeId, WallNode } from '@pascal-app/core';
+export type WallOpeningClearance = {
+    bottom: number;
+    id: AnyNodeId;
+    kind: 'door' | 'window';
+    left: number;
+    right: number;
+    top: number;
+};
+export declare function wallOpeningClearances(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>): WallOpeningClearance[];
+export declare function findWallOpeningConflicts({ bottom, height, localX, nodes, wall, width, }: {
+    bottom: number;
+    height: number;
+    localX: number;
+    nodes: Readonly<Record<AnyNodeId, AnyNode>>;
+    wall: WallNode;
+    width: number;
+}): AnyNodeId[];
+//# sourceMappingURL=wall-opening-clearance.d.ts.map

package/dist/shared/wall-opening-clearance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-opening-clearance.d.ts","sourceRoot":"","sources":["../../src/shared/wall-opening-clearance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAIpE,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAQD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,oBAAoB,EAAE,CAYxB;AAED,wBAAgB,wBAAwB,CAAC,EACvC,MAAM,EACN,MAAM,EACN,MAAM,EACN,KAAK,EACL,IAAI,EACJ,KAAK,GACN,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;IAC3C,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;CACd,GAAG,SAAS,EAAE,CAcd"}

package/dist/shared/wall-opening-clearance.js

@@ -0,0 +1,28 @@
+const OVERLAP_EPSILON_M = 1e-5;
+function isWallOpening(node) {
+    return node?.type === 'door' || node?.type === 'window';
+}
+export function wallOpeningClearances(wall, nodes) {
+    return (wall.children ?? [])
+        .map((childId) => nodes[childId])
+        .filter(isWallOpening)
+        .map((opening) => ({
+        bottom: opening.position[1] - opening.height / 2,
+        id: opening.id,
+        kind: opening.type,
+        left: opening.position[0] - opening.width / 2,
+        right: opening.position[0] + opening.width / 2,
+        top: opening.position[1] + opening.height / 2,
+    }));
+}
+export function findWallOpeningConflicts({ bottom, height, localX, nodes, wall, width, }) {
+    const left = localX - width / 2;
+    const right = localX + width / 2;
+    const top = bottom + height;
+    return wallOpeningClearances(wall, nodes)
+        .filter((opening) => left < opening.right - OVERLAP_EPSILON_M &&
+        right > opening.left + OVERLAP_EPSILON_M &&
+        bottom < opening.top - OVERLAP_EPSILON_M &&
+        top > opening.bottom + OVERLAP_EPSILON_M)
+        .map((opening) => opening.id);
+}

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

@@ -0,0 +1,17 @@
+import type { AnyNode, GridEvent } from '@pascal-app/core';
+import type { RunWallAttachment } from './distribution-run-contract';
+type Point = [number, number, number];
+export type WallRunMoveResult = {
+    path: Point[];
+    attachment: RunWallAttachment;
+};
+/** Recompute persisted U/V coordinates after a 3D endpoint edit. */
+export declare function refreshWallRunAttachment(path: readonly Point[], attachment: RunWallAttachment, wall: Extract<AnyNode, {
+    type: 'wall';
+}>): RunWallAttachment;
+/** Translate a wall-attached run in the wall's horizontal/vertical plane. */
+export declare function translateWallRun(path: readonly Point[], attachment: RunWallAttachment, wall: Extract<AnyNode, {
+    type: 'wall';
+}>, event: Pick<GridEvent, 'surfaceHit' | 'surfaceLocalPosition'>): WallRunMoveResult | null;
+export {};
+//# sourceMappingURL=wall-run-move.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-run-move.d.ts","sourceRoot":"","sources":["../../src/shared/wall-run-move.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAEpE,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAErC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,KAAK,EAAE,CAAA;IACb,UAAU,EAAE,iBAAiB,CAAA;CAC9B,CAAA;AAED,oEAAoE;AACpE,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,UAAU,EAAE,iBAAiB,EAC7B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACvC,iBAAiB,CAgBnB;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,UAAU,EAAE,iBAAiB,EAC7B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACxC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,GAAG,sBAAsB,CAAC,GAC5D,iBAAiB,GAAG,IAAI,CAuC1B"}

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

@@ -0,0 +1,56 @@
+/** Recompute persisted U/V coordinates after a 3D endpoint edit. */
+export function refreshWallRunAttachment(path, attachment, wall) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-9 || path.length < 2)
+        return attachment;
+    const tx = dx / length;
+    const tz = dz / length;
+    const toUV = (point) => [
+        (point[0] - wall.start[0]) * tx + (point[2] - wall.start[1]) * tz,
+        point[1],
+    ];
+    return {
+        ...attachment,
+        startUV: toUV(path[0]),
+        endUV: toUV(path[path.length - 1]),
+    };
+}
+/** Translate a wall-attached run in the wall's horizontal/vertical plane. */
+export function translateWallRun(path, attachment, wall, event) {
+    if (event.surfaceHit?.kind !== 'wall' ||
+        event.surfaceHit.hostId !== attachment.wallId ||
+        event.surfaceHit.face !== 'side' ||
+        !event.surfaceLocalPosition ||
+        path.length === 0) {
+        return null;
+    }
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-9)
+        return null;
+    const tangent = [dx / length, 0, dz / length];
+    const center = [0, 0, 0];
+    for (const point of path) {
+        center[0] += point[0];
+        center[1] += point[1];
+        center[2] += point[2];
+    }
+    center[0] /= path.length;
+    center[1] /= path.length;
+    center[2] /= path.length;
+    const hit = event.surfaceLocalPosition;
+    const deltaU = (hit[0] - center[0]) * tangent[0] + (hit[2] - center[2]) * tangent[2];
+    const deltaV = hit[1] - center[1];
+    const movedPath = path.map((point) => [point[0] + tangent[0] * deltaU, point[1] + deltaV, point[2] + tangent[2] * deltaU]);
+    return {
+        path: movedPath,
+        attachment: {
+            ...attachment,
+            startUV: [attachment.startUV[0] + deltaU, attachment.startUV[1] + deltaV],
+            endUV: [attachment.endUV[0] + deltaU, attachment.endUV[1] + deltaV],
+        },
+    };
+}

package/dist/shelf/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAQpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA4HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAuJ5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAQpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA4HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAwJ5D,CAAA"}

package/dist/shelf/definition.js

@@ -194,7 +194,7 @@ export const shelfDefinition = {
     // declared here so the placement coordinator's shelf strategy can
     // confirm parent-kind compatibility before reparenting.
     relations: {
-        hosts: ['item'],
+        hosts: ['item', 'procedural-item'],
         cascadeDelete: 'descendants',
     },
     parametrics: shelfParametrics,
@@ -209,6 +209,7 @@ export const shelfDefinition = {
     // Boards/posts/back depend only on these fields — never on hosted
     // `children`. Lets <GeometrySystem> skip the dispose+rebuild (and the
     // pointer enter/leave churn it causes) when an item reparents onto a row.
+    geometryChildTypes: [],
     geometryKey: (n) => {
         const s = sanitizeShelfDimensions(n);
         return JSON.stringify([

package/dist/shelf/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AASzB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,OAAO,GAAG,OAAO,CAAA;IAGtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAmChE,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAiChE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EACxB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AASzB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,OAAO,GAAG,OAAO,CAAA;IAGtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAoChE,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAkChE,CAAA"}