@pascal-app/nodes 0.1.1

package/dist/wall/paint.js

@@ -0,0 +1,176 @@
+import { getEffectiveWallSurfaceMaterial, getWallBandSlotId, getWallFaceBandConfig, getWallFaceBandForHeight, getWallSurfaceSideFromBandSlot, parseMaterialRef, sceneRegistry, useScene, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
+import { Raycaster } from 'three';
+import { buildSlotPreviewMaterial, createSlotPaintCapability, previewSlotByUserData, } from '../shared/slot-paint';
+const WALL_SLOT_IDS = new Set(Object.keys(WALL_SURFACE_SLOT_DEFAULTS));
+const WALL_ARRAY_SLOT_INDEX = {
+    interior: 1,
+    exterior: 2,
+    lowerInterior: 3,
+    middleInterior: 4,
+    upperInterior: 5,
+    topInterior: 6,
+    lowerExterior: 7,
+    middleExterior: 8,
+    upperExterior: 9,
+    topExterior: 10,
+};
+const WALL_INDEX_SLOT = new Map(Object.entries(WALL_ARRAY_SLOT_INDEX).map(([slotId, index]) => [
+    index,
+    slotId,
+]));
+const wallSlotRaycaster = new Raycaster();
+function resolveSideFromMaterialIndex(materialIndex) {
+    const slotId = materialIndex === null ? undefined : WALL_INDEX_SLOT.get(materialIndex);
+    if (slotId)
+        return getWallSurfaceSideFromBandSlot(slotId);
+    return null;
+}
+function resolveWallSlotByRay(node, ray) {
+    if (!ray)
+        return null;
+    const root = sceneRegistry.nodes.get(node.id);
+    if (!root)
+        return null;
+    wallSlotRaycaster.ray.copy(ray);
+    const hits = wallSlotRaycaster.intersectObject(root, true);
+    for (const hit of hits) {
+        const slotId = hit.object.userData?.slotId;
+        if (typeof slotId === 'string' && WALL_SLOT_IDS.has(slotId)) {
+            return slotId;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve which wall face band the user clicked. The side comes from:
+ *   1. Material-slot index from the renderer's groups. Cheap reference path.
+ *   2. Falls back to the hit-surface normal + local-Z when the
+ *      groups aren't conclusive. Front/back of the wall maps to the
+ *      node's `frontSide` / `backSide` semantic; absent that, front
+ *      → interior, back → exterior.
+ *
+ * Returns null when the click is too oblique (or lands on the wall's
+ * end-cap, etc.) to confidently assign a side.
+ */
+export function resolveWallRole(args) {
+    const { node, hitObject, materialIndex, normal, localPosition, ray } = args;
+    const directSlotId = hitObject?.userData?.slotId;
+    if (typeof directSlotId === 'string' && WALL_SLOT_IDS.has(directSlotId)) {
+        return directSlotId;
+    }
+    const raySlotId = resolveWallSlotByRay(node, ray);
+    if (raySlotId)
+        return raySlotId;
+    const indexedSlotId = materialIndex === null ? undefined : WALL_INDEX_SLOT.get(materialIndex);
+    const indexedSide = resolveSideFromMaterialIndex(materialIndex);
+    const sideFromIndex = indexedSide ?? null;
+    if (indexedSlotId && indexedSlotId !== 'interior' && indexedSlotId !== 'exterior') {
+        return indexedSlotId;
+    }
+    if (sideFromIndex && localPosition) {
+        const bands = getWallFaceBandConfig(node);
+        if (!bands.enabled)
+            return sideFromIndex;
+        return getWallBandSlotId(sideFromIndex, getWallFaceBandForHeight(node, localPosition[1]));
+    }
+    if (sideFromIndex)
+        return sideFromIndex;
+    const normalZ = normal?.[2];
+    const localZ = localPosition?.[2];
+    const thickness = node.thickness ?? 0.1;
+    if (normalZ === undefined ||
+        localZ === undefined ||
+        localPosition === undefined ||
+        Math.abs(normalZ) < 0.65 ||
+        Math.abs(localZ) < Math.max(thickness * 0.2, 0.01)) {
+        return null;
+    }
+    const hitFace = localZ >= 0 ? 'front' : 'back';
+    const semantic = hitFace === 'front' ? node.frontSide : node.backSide;
+    if (semantic === 'interior' || semantic === 'exterior') {
+        const bands = getWallFaceBandConfig(node);
+        if (!bands.enabled)
+            return semantic;
+        return getWallBandSlotId(semantic, getWallFaceBandForHeight(node, localPosition[1]));
+    }
+    const side = hitFace === 'front' ? 'interior' : 'exterior';
+    const bands = getWallFaceBandConfig(node);
+    if (!bands.enabled)
+        return side;
+    return getWallBandSlotId(side, getWallFaceBandForHeight(node, localPosition[1]));
+}
+/**
+ * Preview a wall paint by swapping just the painted face's entry in the wall
+ * mesh's material array. The array is the shared cached `WallMaterials.visible`,
+ * so we clone it before swapping and restore the original reference on cleanup
+ * (never mutate the cache).
+ */
+function applyWallPreview(args) {
+    const { role, material, materialPreset } = args;
+    if (!(role in WALL_ARRAY_SLOT_INDEX)) {
+        return previewSlotByUserData(args);
+    }
+    const index = WALL_ARRAY_SLOT_INDEX[role];
+    if (!index)
+        return previewSlotByUserData(args);
+    const mesh = sceneRegistry.nodes.get(args.node.id);
+    if (!(mesh && mesh.isMesh))
+        return null;
+    const wallMesh = mesh;
+    const current = wallMesh.material;
+    if (!Array.isArray(current))
+        return null;
+    const preview = buildSlotPreviewMaterial(material, materialPreset);
+    if (!preview)
+        return () => { };
+    const previous = current;
+    const next = previous.slice();
+    next[index] = preview;
+    wallMesh.material = next;
+    return () => {
+        wallMesh.material = previous;
+    };
+}
+/**
+ * Capability binding for the wall kind on the unified slot model. Painting
+ * writes `node.slots[bandSide]` (a `library:` ref or a minted `scene:`
+ * material) exactly like every other kind; `legacyEffective` reads the
+ * whole-side fallback so old scenes still show the current value.
+ */
+export const wallPaint = createSlotPaintCapability({
+    roomScope: true,
+    resolveRole: ({ node, hitObject, materialIndex, normal, localPosition, ray }) => resolveWallRole({
+        node: node,
+        hitObject: hitObject,
+        materialIndex,
+        normal,
+        localPosition,
+        ray,
+    }),
+    applyPreview: applyWallPreview,
+    legacyEffective: (node, role) => {
+        const side = getWallSurfaceSideFromBandSlot(role);
+        if (!side && role in WALL_SURFACE_SLOT_DEFAULTS) {
+            return {
+                material: undefined,
+                materialPreset: WALL_SURFACE_SLOT_DEFAULTS[role],
+            };
+        }
+        if (!side)
+            return null;
+        const sideRef = node.slots?.[side];
+        const parsed = parseMaterialRef(sideRef);
+        if (parsed?.kind === 'library') {
+            return { material: undefined, materialPreset: sideRef };
+        }
+        if (parsed?.kind === 'scene') {
+            const sceneMaterial = useScene.getState().materials[parsed.id];
+            if (sceneMaterial)
+                return { material: sceneMaterial.material, materialPreset: undefined };
+        }
+        const spec = getEffectiveWallSurfaceMaterial(node, side);
+        if (spec.material === undefined && spec.materialPreset === undefined)
+            return null;
+        return { material: spec.material, materialPreset: spec.materialPreset };
+    },
+});

package/dist/wall/panel.d.ts

@@ -0,0 +1,2 @@
+export default function WallPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

package/dist/wall/panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAmEA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA8OhC"}

package/dist/wall/panel.js

@@ -0,0 +1,198 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { buildWallFaceBandCountPatch, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, getWallFaceBandConfig, normalizeWallCurveOffset, useLiveNodeOverrides, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_FACE_BAND_DEFAULT, WALL_SKIRTING_DEFAULT, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, curveReshapeScope, getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Spline } from 'lucide-react';
+import { useCallback, useMemo, useRef } from 'react';
+const WALL_TRIM_PROFILE_OPTIONS = {
+    skirting: [
+        { label: 'Flat', value: 'flat' },
+        { label: 'Modern', value: 'base-modern' },
+        { label: 'Colonial', value: 'base-colonial' },
+        { label: 'Shoe', value: 'base-shoe' },
+        { label: 'Ogee', value: 'base-ogee' },
+    ],
+    crown: [
+        { label: 'Flat', value: 'flat' },
+        { label: 'Cove', value: 'crown-cove' },
+        { label: 'Ogee', value: 'crown-ogee' },
+        { label: 'Craft', value: 'crown-craftsman' },
+        { label: 'Layered', value: 'crown-layered' },
+    ],
+    chairRail: [
+        { label: 'Flat', value: 'flat' },
+        { label: 'Round', value: 'rail-rounded' },
+        { label: 'Ogee', value: 'rail-ogee' },
+        { label: 'Picture', value: 'rail-picture' },
+        { label: 'Step', value: 'rail-stepped' },
+    ],
+};
+export default function WallPanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const unit = useViewer((s) => s.unit);
+    const setSelection = useViewer((s) => s.setSelection);
+    const sceneNode = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    // Live override published by the 2D drag handlers (side-arrows /
+    // corner dots / curve handle). Merged on top of the scene node so
+    // the sliders read the live `start` / `end` / `curveOffset` during
+    // a drag without zustand being touched until commit.
+    const liveOverride = useLiveNodeOverrides((s) => selectedId ? s.get(selectedId) : undefined);
+    const node = useMemo(() => {
+        if (!sceneNode)
+            return undefined;
+        if (!liveOverride || Object.keys(liveOverride).length === 0)
+            return sceneNode;
+        return { ...sceneNode, ...liveOverride };
+    }, [sceneNode, liveOverride]);
+    // Boolean selector — re-renders only when this specific wall's child
+    // composition crosses the "has a door/window/wall-item" threshold.
+    const hasWallChildrenBlockingCurve = useScene((s) => {
+        if (!node)
+            return false;
+        return (node.children ?? []).some((childId) => {
+            const child = s.nodes[childId];
+            if (!child)
+                return false;
+            if (child.type === 'door' || child.type === 'window')
+                return true;
+            if (child.type === 'item') {
+                const attachTo = child.asset?.attachTo;
+                return attachTo === 'wall' || attachTo === 'wall-side';
+            }
+            return false;
+        });
+    });
+    // Mirror the latest node into a ref so the slider handlers below have
+    // stable identities across re-renders. Without this, every store tick
+    // (one per pointermove during a slider drag) rebuilt the handler
+    // refs, destabilising SliderControl's pointer-capture listeners and
+    // combining with float drift in `getWallCurveLength` produced a
+    // "Maximum update depth exceeded" cascade. Same fix in fence-panel.tsx.
+    const nodeRef = useRef(node);
+    nodeRef.current = node;
+    const handleUpdate = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        useScene.getState().updateNode(selectedId, updates);
+    }, [selectedId]);
+    const handleUpdateLength = useCallback((newLength) => {
+        const n = nodeRef.current;
+        if (!n || newLength <= 0)
+            return;
+        const dx = n.end[0] - n.start[0];
+        const dz = n.end[1] - n.start[1];
+        const currentLength = Math.sqrt(dx * dx + dz * dz);
+        if (currentLength === 0)
+            return;
+        const dirX = dx / currentLength;
+        const dirZ = dz / currentLength;
+        const newEnd = [
+            n.start[0] + dirX * newLength,
+            n.start[1] + dirZ * newLength,
+        ];
+        handleUpdate({ end: newEnd });
+    }, [handleUpdate]);
+    const handleClose = useCallback(() => {
+        setSelection({ selectedIds: [] });
+    }, [setSelection]);
+    const handleCurve = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        useInteractionScope.getState().begin(curveReshapeScope(node.id));
+        setSelection({ selectedIds: [] });
+    }, [node, setSelection]);
+    if (!(node && node.type === 'wall' && selectedId))
+        return null;
+    const length = getWallCurveLength(node);
+    const height = node.height ?? 2.5;
+    const thickness = node.thickness ?? 0.1;
+    const curveOffset = getClampedWallCurveOffset(node);
+    const maxCurveOffset = getMaxWallCurveOffset(node);
+    const unitLabel = getLinearUnitLabel(unit);
+    const displayLength = metersToLinearUnit(length, unit);
+    const displayHeight = metersToLinearUnit(height, unit);
+    const displayThickness = metersToLinearUnit(thickness, unit);
+    const displayCurveOffset = metersToLinearUnit(curveOffset, unit);
+    const displayMaxCurveOffset = metersToLinearUnit(maxCurveOffset, unit);
+    const curveOffsetLimit = Math.max(0.01, maxCurveOffset);
+    const wallHeightMeters = node.height ?? 2.5;
+    const skirting = { ...WALL_SKIRTING_DEFAULT, ...(node.skirting ?? {}) };
+    const crown = { ...WALL_CROWN_DEFAULT, ...(node.crown ?? {}) };
+    const chairRail = { ...WALL_CHAIR_RAIL_DEFAULT, ...(node.chairRail ?? {}) };
+    return (_jsxs(PanelWrapper, { icon: "/icons/wall.webp", onClose: handleClose, title: node.name || 'Wall', width: 280, children: [_jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: metersToLinearUnit(20, unit), min: metersToLinearUnit(0.1, unit), onChange: (value) => handleUpdateLength(linearControlValueToMeters(value, unit, { maxMeters: 20, minMeters: 0.1 })), precision: 2, step: unit === 'imperial' ? 0.1 : 0.01, unit: unitLabel, value: displayLength }), _jsx(SliderControl, { label: "Height", max: metersToLinearUnit(6, unit), min: metersToLinearUnit(0.1, unit), onChange: (v) => handleUpdate({
+                            height: linearControlValueToMeters(v, unit, { maxMeters: 6, minMeters: 0.1 }),
+                        }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayHeight * 100) / 100 }), _jsx(SliderControl, { label: "Thickness", max: metersToLinearUnit(1, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handleUpdate({
+                            thickness: linearControlValueToMeters(v, unit, { maxMeters: 1, minMeters: 0.05 }),
+                        }), precision: 3, step: 0.01, unit: unitLabel, value: Math.round(displayThickness * 1000) / 1000 }), !hasWallChildrenBlockingCurve && (_jsx(SliderControl, { label: "Curve", max: Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), min: -Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), onChange: (v) => handleUpdate({
+                            curveOffset: normalizeWallCurveOffset(node, linearControlValueToMeters(v, unit, {
+                                maxMeters: curveOffsetLimit,
+                                minMeters: -curveOffsetLimit,
+                            })),
+                        }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayCurveOffset * 100) / 100 }))] }), _jsx(WallFaceBandSection, { node: node, onUpdate: handleUpdate, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), _jsx(WallTrimSection, { node: node, onUpdate: handleUpdate, title: "Skirting", trimKey: "skirting", trimValue: skirting, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), _jsx(WallTrimSection, { node: node, onUpdate: handleUpdate, title: "Crown molding", trimKey: "crown", trimValue: crown, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), _jsx(WallTrimSection, { node: node, onUpdate: handleUpdate, title: "Chair rail", trimKey: "chairRail", trimValue: chairRail, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), !hasWallChildrenBlockingCurve && (_jsx(PanelSection, { title: "Actions", children: _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Spline, { className: "h-3.5 w-3.5" }), label: "Curve", onClick: handleCurve }) }) }))] }));
+}
+function WallFaceBandSection({ node, onUpdate, unit, unitLabel, wallHeightMeters, }) {
+    const bandConfig = getWallFaceBandConfig(node);
+    const bandCount = bandConfig.count;
+    const lowerHeight = bandConfig.lowerHeight;
+    const middleHeight = bandConfig.middleHeight;
+    const upperHeight = bandConfig.upperHeight;
+    const updateBands = (patch) => onUpdate({
+        faceBands: {
+            ...WALL_FACE_BAND_DEFAULT,
+            ...(node.faceBands ?? {}),
+            enabled: bandCount > 1,
+            count: bandCount,
+            ...patch,
+        },
+    });
+    return (_jsxs(PanelSection, { title: "Wall bands", children: [_jsx(SliderControl, { label: "Bands", max: 4, min: 1, onChange: (value) => onUpdate(buildWallFaceBandCountPatch(node, Math.round(value))), precision: 0, step: 1, value: bandCount }), bandCount >= 2 && (_jsx(SliderControl, { label: "Lower", max: metersToLinearUnit(wallHeightMeters, unit), min: metersToLinearUnit(0, unit), onChange: (value) => updateBands({
+                    lowerHeight: linearControlValueToMeters(value, unit, {
+                        maxMeters: wallHeightMeters,
+                        minMeters: 0,
+                    }),
+                }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(lowerHeight, unit) })), bandCount >= 3 && (_jsx(SliderControl, { label: "Middle", max: metersToLinearUnit(Math.max(0, wallHeightMeters - lowerHeight), unit), min: metersToLinearUnit(0, unit), onChange: (value) => updateBands({
+                    middleHeight: linearControlValueToMeters(value, unit, {
+                        maxMeters: Math.max(0, wallHeightMeters - lowerHeight),
+                        minMeters: 0,
+                    }),
+                }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(middleHeight, unit) })), bandCount >= 4 && (_jsx(SliderControl, { label: "Upper", max: metersToLinearUnit(Math.max(0, wallHeightMeters - lowerHeight - middleHeight), unit), min: metersToLinearUnit(0, unit), onChange: (value) => updateBands({
+                    upperHeight: linearControlValueToMeters(value, unit, {
+                        maxMeters: Math.max(0, wallHeightMeters - lowerHeight - middleHeight),
+                        minMeters: 0,
+                    }),
+                }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(upperHeight, unit) }))] }));
+}
+function WallTrimSection({ node, onUpdate, title, trimKey, trimValue, unit, unitLabel, wallHeightMeters, }) {
+    const updateTrim = (patch) => onUpdate({
+        [trimKey]: {
+            ...trimValue,
+            ...patch,
+        },
+    });
+    const profileOptions = WALL_TRIM_PROFILE_OPTIONS[trimKey];
+    const selectedProfile = profileOptions.some((option) => option.value === trimValue.profile)
+        ? trimValue.profile
+        : profileOptions[0].value;
+    return (_jsxs(PanelSection, { title: title, children: [_jsx(ActionGroup, { children: _jsx(ActionButton, { label: trimValue.enabled ? `Hide ${title.toLowerCase()}` : `Show ${title.toLowerCase()}`, onClick: () => updateTrim({ enabled: !trimValue.enabled }) }) }), trimValue.enabled && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { onChange: (next) => updateTrim({ sides: next }), options: [
+                            { label: 'Interior', value: 'interior' },
+                            { label: 'Exterior', value: 'exterior' },
+                            { label: 'Both', value: 'both' },
+                        ], value: trimValue.sides }), _jsx(SegmentedControl, { onChange: (next) => updateTrim({ profile: next }), options: profileOptions, value: selectedProfile }), _jsx(SliderControl, { label: "Height", max: metersToLinearUnit(Math.max(0.05, wallHeightMeters), unit), min: metersToLinearUnit(0.01, unit), onChange: (value) => updateTrim({
+                            height: linearControlValueToMeters(value, unit, {
+                                maxMeters: Math.max(0.05, wallHeightMeters),
+                                minMeters: 0.01,
+                            }),
+                        }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(trimValue.height, unit) }), _jsx(SliderControl, { label: "Proud", max: metersToLinearUnit(0.2, unit), min: metersToLinearUnit(0.001, unit), onChange: (value) => updateTrim({
+                            proud: linearControlValueToMeters(value, unit, {
+                                maxMeters: 0.2,
+                                minMeters: 0.001,
+                            }),
+                        }), precision: 3, step: 0.005, unit: unitLabel, value: metersToLinearUnit(trimValue.proud, unit) }), trimKey === 'chairRail' && (_jsx(SliderControl, { label: "Offset", max: metersToLinearUnit(Math.max(0.05, wallHeightMeters - trimValue.height), unit), min: metersToLinearUnit(0, unit), onChange: (value) => updateTrim({
+                            offsetY: linearControlValueToMeters(value, unit, {
+                                maxMeters: Math.max(0.05, wallHeightMeters - trimValue.height),
+                                minMeters: 0,
+                            }),
+                        }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(trimValue.offsetY ?? 0, unit) }))] }))] }));
+}

package/dist/wall/parametrics.d.ts

@@ -0,0 +1,16 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { WallNode } from './schema';
+/**
+ * Inspector descriptor for wall.
+ *
+ * Wall has a few "structural" knobs (thickness, height, curve sagitta) and
+ * a few "presentation" knobs (front / back / interior / exterior material
+ * presets). Phase 4's `<ParametricInspector>` renders these directly.
+ *
+ * Endpoints (`start`, `end`) and host children are *not* exposed here —
+ * those are edited via affordances (endpoint drag handles) and child
+ * placement tools, not number inputs. `parametrics` is for "type a value
+ * and see it apply"; spatial manipulation belongs to tools/affordances.
+ */
+export declare const wallParametrics: ParametricDescriptor<WallNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/wall/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/wall/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAiB1D,CAAA"}

package/dist/wall/parametrics.js

@@ -0,0 +1,30 @@
+/**
+ * Inspector descriptor for wall.
+ *
+ * Wall has a few "structural" knobs (thickness, height, curve sagitta) and
+ * a few "presentation" knobs (front / back / interior / exterior material
+ * presets). Phase 4's `<ParametricInspector>` renders these directly.
+ *
+ * Endpoints (`start`, `end`) and host children are *not* exposed here —
+ * those are edited via affordances (endpoint drag handles) and child
+ * placement tools, not number inputs. `parametrics` is for "type a value
+ * and see it apply"; spatial manipulation belongs to tools/affordances.
+ */
+export const wallParametrics = {
+    groups: [
+        {
+            label: 'Dimensions',
+            fields: [
+                { key: 'thickness', kind: 'number', unit: 'm', min: 0.05, max: 0.6, step: 0.01 },
+                { key: 'height', kind: 'number', unit: 'm', min: 1.5, max: 6, step: 0.05 },
+                { key: 'curveOffset', kind: 'number', unit: 'm', min: -3, max: 3, step: 0.05 },
+            ],
+        },
+    ],
+    // Stage E — kind-owned panel. Wall's panel has a derived Length
+    // slider (computes from start/end + dirX/dirZ) and a hosted-child-
+    // aware Curve slider that's only shown when no door / window / wall-
+    // attached item lives on the wall. The auto-inspector can't express
+    // "derived" or "conditionally visible" yet — kept as a custom panel.
+    customPanel: () => import('./panel'),
+};

package/dist/wall/quick-measurement.d.ts

@@ -0,0 +1,3 @@
+import { type QuickMeasurementReport, type WallNode } from '@pascal-app/core';
+export declare function wallQuickMeasurement(node: WallNode): QuickMeasurementReport;
+//# sourceMappingURL=quick-measurement.d.ts.map

package/dist/wall/quick-measurement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quick-measurement.d.ts","sourceRoot":"","sources":["../../src/wall/quick-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,sBAAsB,EAC3B,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,sBAAsB,CA6B3E"}

package/dist/wall/quick-measurement.js

@@ -0,0 +1,30 @@
+import { DEFAULT_WALL_HEIGHT, getWallCurveFrameAt, getWallCurveLength, getWallThickness, } from '@pascal-app/core';
+export function wallQuickMeasurement(node) {
+    const length = getWallCurveLength(node);
+    const height = node.height ?? DEFAULT_WALL_HEIGHT;
+    const frame = getWallCurveFrameAt(node, 0.5);
+    return {
+        title: node.name ?? 'Wall',
+        kindLabel: 'Wall',
+        anchor: [frame.point.x, height * 0.55, frame.point.y],
+        metrics: [
+            { key: 'length', label: 'Length', abbreviation: 'L', quantity: 'length', value: length },
+            { key: 'height', label: 'Height', abbreviation: 'H', quantity: 'length', value: height },
+            {
+                key: 'surface',
+                label: 'Surface',
+                abbreviation: 'A',
+                quantity: 'area',
+                value: length * height,
+            },
+            {
+                key: 'thickness',
+                label: 'Thickness',
+                abbreviation: 'T',
+                quantity: 'length',
+                value: getWallThickness(node),
+            },
+        ],
+        note: 'Gross face area before openings.',
+    };
+}

package/dist/wall/renderer.d.ts

@@ -0,0 +1,25 @@
+import { type WallNode } from '@pascal-app/core';
+/**
+ * Thin wall renderer.
+ *
+ * Mounts a placeholder mesh, registers it with `sceneRegistry`, marks the
+ * node dirty so `WallSystem` fills the geometry on the next frame, and
+ * recursively renders hosted children (doors / windows / wall-mounted
+ * items) inside the wall's local frame.
+ *
+ * Behaviorally identical to the legacy `WallRenderer` in
+ * `@pascal-app/viewer/components/renderers/wall/wall-renderer.tsx`.
+ * Phase 6 deletes the legacy file; until then both coexist and the Phase 0
+ * shims pick which one renders based on `nodeRegistry.has('wall')`.
+ *
+ * No `geometry` field on the wall definition yet — wall's geometry depends
+ * on level-batch miter data (see `WallSystem.calculateLevelMiters`), which
+ * doesn't fit the generic `(node, ctx) => Group` shape without `ctx.levelData`.
+ * That decision lands in a later milestone; for now the system retains
+ * ownership of the rebuild loop.
+ */
+declare const WallRenderer: ({ node }: {
+    node: WallNode;
+}) => import("react").JSX.Element;
+export default WallRenderer;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/wall/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAOzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAgFjD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/wall/renderer.js

@@ -0,0 +1,65 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRegistry, useScene, } from '@pascal-app/core';
+import { getVisibleWallMaterials, NodeRenderer, useNodeEvents, useViewer } from '@pascal-app/viewer';
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
+import { createWallExtraSlotMaterials, WallTreatments } from './treatments';
+/**
+ * Thin wall renderer.
+ *
+ * Mounts a placeholder mesh, registers it with `sceneRegistry`, marks the
+ * node dirty so `WallSystem` fills the geometry on the next frame, and
+ * recursively renders hosted children (doors / windows / wall-mounted
+ * items) inside the wall's local frame.
+ *
+ * Behaviorally identical to the legacy `WallRenderer` in
+ * `@pascal-app/viewer/components/renderers/wall/wall-renderer.tsx`.
+ * Phase 6 deletes the legacy file; until then both coexist and the Phase 0
+ * shims pick which one renders based on `nodeRegistry.has('wall')`.
+ *
+ * No `geometry` field on the wall definition yet — wall's geometry depends
+ * on level-batch miter data (see `WallSystem.calculateLevelMiters`), which
+ * doesn't fit the generic `(node, ctx) => Group` shape without `ctx.levelData`.
+ * That decision lands in a later milestone; for now the system retains
+ * ownership of the rebuild loop.
+ */
+const WallRenderer = ({ node }) => {
+    const ref = useRef(null);
+    const placeholderGeometry = useMemo(() => createPlaceholderGeometry(3), []);
+    const collisionPlaceholderGeometry = useMemo(() => createPlaceholderGeometry(), []);
+    useRegistry(node.id, 'wall', ref);
+    useLayoutEffect(() => {
+        useScene.getState().markDirty(node.id);
+    }, [node.id]);
+    useEffect(() => {
+        return () => {
+            placeholderGeometry.dispose();
+            collisionPlaceholderGeometry.dispose();
+        };
+    }, [collisionPlaceholderGeometry, placeholderGeometry]);
+    const handlers = useNodeEvents(node, 'wall');
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneTheme = useViewer((s) => s.sceneTheme);
+    const sceneNodes = useScene((state) => state.nodes);
+    const childNodes = useMemo(() => (node.children ?? [])
+        .map((childId) => sceneNodes[childId])
+        .filter((child) => child !== undefined), [node.children, sceneNodes]);
+    // Subscribe to the scene-material palette so editing a `scene:` material a
+    // wall slot references re-renders the wall live (the wall-system geometry
+    // dirty loop never fires for a material-only edit). `getMaterialsForWall`'s
+    // content hash keeps unaffected walls on their cached materials.
+    const sceneMaterials = useScene((s) => s.materials);
+    const baseMaterials = getVisibleWallMaterials(node, shading, textures, colorPreset, sceneTheme, sceneMaterials);
+    const extraMaterials = useMemo(() => createWallExtraSlotMaterials(node, shading, sceneMaterials), [node, sceneMaterials, shading]);
+    useEffect(() => () => {
+        const baseSet = new Set(baseMaterials);
+        const owned = new Set(Object.values(extraMaterials).filter((entry) => !baseSet.has(entry)));
+        for (const entry of owned)
+            entry.dispose();
+    }, [baseMaterials, extraMaterials]);
+    return (_jsxs("mesh", { castShadow: true, geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { geometry: collisionPlaceholderGeometry, name: "collision-mesh", visible: false, ...handlers }), _jsx(WallTreatments, { childrenNodes: childNodes, materials: extraMaterials, node: node }), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
+};
+export default WallRenderer;

package/dist/wall/schema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wall schema re-export.
+ *
+ * Wall's Zod schema lives in `@pascal-app/core` because doors, windows, and
+ * items still need to type-check their `parentId` against `WallNode.shape.id`
+ * before the migration to a `relations.hosts`-driven model is complete. The
+ * registry definition consumes it from here so the rest of the bundle
+ * imports a single canonical type.
+ */
+export type { WallNode as WallNodeType } from '@pascal-app/core';
+export { WallNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/wall/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/wall/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,YAAY,EAAE,QAAQ,IAAI,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/wall/schema.js

@@ -0,0 +1,10 @@
+/**
+ * Wall schema re-export.
+ *
+ * Wall's Zod schema lives in `@pascal-app/core` because doors, windows, and
+ * items still need to type-check their `parentId` against `WallNode.shape.id`
+ * before the migration to a `relations.hosts`-driven model is complete. The
+ * registry definition consumes it from here so the rest of the bundle
+ * imports a single canonical type.
+ */
+export { WallNode } from '@pascal-app/core';

package/dist/wall/slots.d.ts

@@ -0,0 +1,10 @@
+import { type SlotDeclaration } from '@pascal-app/core';
+/**
+ * A wall exposes two paintable faces — interior + exterior. Painting writes
+ * `node.slots[interior|exterior]` via `wallPaint` like every other kind; this
+ * declaration surfaces the slot list + declared defaults for the picker and
+ * keeps walls on the same `{ slotId, label, default }` contract. The defaults
+ * come from core so the viewer's material resolver renders the identical value.
+ */
+export declare function wallSlots(): SlotDeclaration[];
+//# sourceMappingURL=slots.d.ts.map

package/dist/wall/slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/wall/slots.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAA8B,MAAM,kBAAkB,CAAA;AAEnF;;;;;;GAMG;AACH,wBAAgB,SAAS,IAAI,eAAe,EAAE,CA2E7C"}