@pascal-app/nodes 0.1.1

package/dist/box-vent/panel.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Inspector panel for a placed box-vent. Exposes the same parametrics
+ * as the auto-derived inspector (style + dimensions) plus Move /
+ * Duplicate / Delete actions wired into the same ghost-preview drag
+ * flow the placement tool uses.
+ *
+ * Move sets the vent as `editor.movingNode` — the registered move
+ * affordance tool (see `./move-tool.tsx`) takes over from there.
+ * Duplicate inserts a fresh clone into the scene (marked `isNew` so a
+ * cancelled drag deletes it), then routes the same way. On click the
+ * ghost commits; on Esc it cancels and the original mesh is restored.
+ */
+export default function BoxVentPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

package/dist/box-vent/panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/box-vent/panel.tsx"],"names":[],"mappings":"AA0BA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,uCA0ZnC"}

package/dist/box-vent/panel.js

@@ -0,0 +1,143 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { BoxVentNode as BoxVentSchema, getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Copy, Move, Trash2 } from 'lucide-react';
+import { useCallback } from 'react';
+/**
+ * Inspector panel for a placed box-vent. Exposes the same parametrics
+ * as the auto-derived inspector (style + dimensions) plus Move /
+ * Duplicate / Delete actions wired into the same ghost-preview drag
+ * flow the placement tool uses.
+ *
+ * Move sets the vent as `editor.movingNode` — the registered move
+ * affordance tool (see `./move-tool.tsx`) takes over from there.
+ * Duplicate inserts a fresh clone into the scene (marked `isNew` so a
+ * cancelled drag deletes it), then routes the same way. On click the
+ * ghost commits; on Esc it cancels and the original mesh is restored.
+ */
+export default function BoxVentPanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const setSelection = useViewer((s) => s.setSelection);
+    const updateNode = useScene((s) => s.updateNode);
+    const deleteNode = useScene((s) => s.deleteNode);
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    const storeNode = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    // Mirror any in-progress slider drag so the panel reads the same live
+    // values the renderer paints. Without this the slider thumb would jump
+    // back to the store value on every render until commit.
+    const overrides = useLiveNodeOverrides((s) => selectedId ? s.get(selectedId) : undefined);
+    const node = storeNode && overrides ? { ...storeNode, ...overrides } : storeNode;
+    // Pull the parent segment so the Position sliders can clamp to the
+    // segment's footprint (no point letting the user drag the vent off
+    // the eaves into thin air).
+    const segment = useScene((s) => node?.roofSegmentId
+        ? s.nodes[node.roofSegmentId]
+        : undefined);
+    // Slider drag (during): write to the ephemeral live-overrides store so
+    // the mesh updates frame-by-frame without thrashing the scene store
+    // (or polluting undo history).
+    const previewProp = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        useLiveNodeOverrides.getState().set(selectedId, updates);
+    }, [selectedId]);
+    // Slider release (commit): flush to the scene store as a single
+    // undoable change and clear the live override.
+    const commitProp = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        updateNode(selectedId, updates);
+        useLiveNodeOverrides.getState().clear(selectedId);
+    }, [selectedId, updateNode]);
+    // Discrete / one-shot updates (style switch, end-cap toggle) bypass
+    // the live-override dance — they're never part of a drag.
+    const handleUpdate = commitProp;
+    const handleClose = useCallback(() => {
+        setSelection({ selectedIds: [] });
+    }, [setSelection]);
+    const handleBack = useCallback(() => {
+        if (node?.roofSegmentId) {
+            setSelection({ selectedIds: [node.roofSegmentId] });
+        }
+    }, [node?.roofSegmentId, setSelection]);
+    const handleMove = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        // `setMovingNode`'s type union doesn't include roof-mounted kinds —
+        // skylight / chimney / etc. take the same `as never` escape hatch.
+        setMovingNode(node);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const handleDuplicate = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        const parentId = node.roofSegmentId;
+        if (!parentId)
+            return;
+        // Clone via the schema parser so the new node gets a fresh ID and
+        // valid defaults. Keep position/rotation/dimensions identical to the
+        // source — the user will drag it to its real destination next.
+        const state = useScene.getState();
+        const meta = typeof node.metadata === 'object' && node.metadata !== null
+            ? node.metadata
+            : {};
+        const cloneInput = {
+            ...node,
+            id: undefined,
+            metadata: { ...meta, isNew: true },
+        };
+        // Use the schema parser so the new node gets a fresh ID and stays
+        // in sync with the placement-tool defaults.
+        const cloned = BoxVentSchema.parse(cloneInput);
+        state.createNode(cloned, parentId);
+        state.dirtyNodes.add(parentId);
+        setMovingNode(cloned);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const handleDelete = useCallback(() => {
+        if (!(selectedId && node))
+            return;
+        triggerSFX('sfx:item-delete');
+        const segmentId = node.roofSegmentId;
+        if (segmentId) {
+            const state = useScene.getState();
+            const segment = state.nodes[segmentId];
+            if (segment) {
+                state.updateNode(segmentId, {
+                    children: (segment.children ?? []).filter((id) => id !== selectedId),
+                });
+            }
+        }
+        deleteNode(selectedId);
+        if (segmentId) {
+            useScene.getState().dirtyNodes.add(segmentId);
+            setSelection({ selectedIds: [segmentId] });
+        }
+        else {
+            setSelection({ selectedIds: [] });
+        }
+    }, [selectedId, node, deleteNode, setSelection]);
+    if (!(node && node.type === 'box-vent' && selectedId))
+        return null;
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || 'Box Vent', width: 300, children: [_jsx(PanelSection, { title: "Style", children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ style: v }), options: [
+                        { label: 'Box', value: 'box' },
+                        { label: 'Cap', value: 'cap' },
+                        { label: 'Dome', value: 'dome' },
+                    ], value: node.style ?? 'cap' }) }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: 0.8, min: 0.15, onChange: (v) => previewProp({ width: v }), onCommit: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.width * 100) / 100 }), _jsx(SliderControl, { label: "Depth", max: 0.8, min: 0.15, onChange: (v) => previewProp({ depth: v }), onCommit: (v) => handleUpdate({ depth: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.depth * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 0.4, min: 0.05, onChange: (v) => previewProp({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.height * 100) / 100 }), node.style === 'cap' && (_jsx(SliderControl, { label: "Hood Overhang", max: Math.max(0.02, node.width), min: 0, onChange: (v) => previewProp({ hoodOverhang: v }), onCommit: (v) => handleUpdate({ hoodOverhang: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.hoodOverhang ?? 0) * 1000) / 1000 })), node.style === 'box' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Base Inset", max: Math.max(0.005, Math.min(node.width, node.depth) / 2 - 0.005), min: 0, onChange: (v) => previewProp({ baseInset: v }), onCommit: (v) => handleUpdate({ baseInset: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.baseInset ?? 0.06) * 1000) / 1000 }), _jsx(SliderControl, { label: "Base Height", max: Math.max(0.01, node.height - 0.005), min: 0.005, onChange: (v) => previewProp({ baseHeight: v }), onCommit: (v) => handleUpdate({ baseHeight: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.baseHeight ?? 0.04) * 1000) / 1000 }), _jsx(SliderControl, { label: "Corner Bevel", max: Math.max(0, Math.min(node.width, node.depth) / 2 - (node.baseInset ?? 0.06) - 0.001), min: 0, onChange: (v) => previewProp({ cornerBevel: v }), onCommit: (v) => handleUpdate({ cornerBevel: v }), precision: 3, restoreOnCommit: false, step: 0.002, unit: "m", value: Math.round((node.cornerBevel ?? 0.012) * 1000) / 1000 })] })), node.style === 'cap' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Cap Height", max: Math.max(0.02, node.height - 0.01), min: 0.01, onChange: (v) => previewProp({ capHeight: v }), onCommit: (v) => handleUpdate({ capHeight: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.capHeight ?? 0.07) * 1000) / 1000 }), _jsx(SliderControl, { label: "Gap Height", max: Math.max(0, node.height - Math.max(0.01, node.capHeight ?? 0.07) - 0.005), min: 0, onChange: (v) => previewProp({ capGap: v }), onCommit: (v) => handleUpdate({ capGap: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.capGap ?? 0) * 1000) / 1000 }), _jsx(SliderControl, { label: "Top Taper", max: 1, min: 0, onChange: (v) => previewProp({ topTaper: v }), onCommit: (v) => handleUpdate({ topTaper: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "", value: Math.round((node.topTaper ?? 0.4) * 100) / 100 })] })), node.style === 'dome' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Dome Curvature", max: 1.5, min: 0.3, onChange: (v) => previewProp({ domeCurvature: v }), onCommit: (v) => handleUpdate({ domeCurvature: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "", value: Math.round((node.domeCurvature ?? 1.0) * 100) / 100 }), _jsx(SliderControl, { label: "Base Flange", max: 0.2, min: 0, onChange: (v) => previewProp({ hoodOverhang: v }), onCommit: (v) => handleUpdate({ hoodOverhang: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.hoodOverhang ?? 0.04) * 1000) / 1000 })] }))] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(((segment?.width ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.width ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({
+                            position: [v, node.position[1] ?? 0, node.position[2] ?? 0],
+                        }), onCommit: (v) => handleUpdate({
+                            position: [v, node.position[1] ?? 0, node.position[2] ?? 0],
+                        }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[0] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Y", max: Math.max((segment?.wallHeight ?? 3) + (segment ? getActiveRoofHeight(segment) : 3) + 2, (node.position[1] ?? 0) + 0.1), min: Math.min(0, (node.position[1] ?? 0) - 0.5), onChange: (v) => previewProp({
+                            position: [node.position[0] ?? 0, v, node.position[2] ?? 0],
+                        }), onCommit: (v) => handleUpdate({
+                            position: [node.position[0] ?? 0, v, node.position[2] ?? 0],
+                        }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[1] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({
+                            position: [node.position[0] ?? 0, node.position[1] ?? 0, v],
+                        }), onCommit: (v) => handleUpdate({
+                            position: [node.position[0] ?? 0, node.position[1] ?? 0, v],
+                        }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[2] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (deg) => previewProp({ rotation: (deg * Math.PI) / 180 }), onCommit: (deg) => handleUpdate({ rotation: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.rotation ?? 0) * 180) / Math.PI) })] }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+}

package/dist/box-vent/parametrics.d.ts

@@ -0,0 +1,9 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { BoxVentNode } from './schema';
+/**
+ * Inspector descriptor for the box vent. Position / rotation are
+ * surfaced by the framework via `capabilities.movable` + the bespoke
+ * move tool — not in this descriptor.
+ */
+export declare const boxVentParametrics: ParametricDescriptor<BoxVentNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/box-vent/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/box-vent/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,oBAAoB,CAAC,WAAW,CA6BhE,CAAA"}

package/dist/box-vent/parametrics.js

@@ -0,0 +1,35 @@
+/**
+ * Inspector descriptor for the box vent. Position / rotation are
+ * surfaced by the framework via `capabilities.movable` + the bespoke
+ * move tool — not in this descriptor.
+ */
+export const boxVentParametrics = {
+    // Move + Duplicate need the kind-owned ghost-preview flow (see
+    // `./move-tool.tsx`), so the panel hosts those actions itself instead
+    // of relying on the generic inspector — which only knows about Move
+    // for `capabilities.movable` kinds and routes those through the
+    // grid-plane mover.
+    customPanel: () => import('./panel'),
+    groups: [
+        {
+            label: 'Style',
+            fields: [
+                {
+                    key: 'style',
+                    kind: 'enum',
+                    options: ['standard', 'low-profile', 'dome'],
+                    display: 'segmented',
+                },
+            ],
+        },
+        {
+            label: 'Dimensions',
+            fields: [
+                { key: 'width', kind: 'number', unit: 'm', min: 0.15, max: 0.8, step: 0.01 },
+                { key: 'depth', kind: 'number', unit: 'm', min: 0.15, max: 0.8, step: 0.01 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.05, max: 0.4, step: 0.01 },
+                { key: 'hoodOverhang', kind: 'number', unit: 'm', min: 0, max: 0.12, step: 0.005 },
+            ],
+        },
+    ],
+};

package/dist/box-vent/preview.d.ts

@@ -0,0 +1,17 @@
+import type { BoxVentNode } from './schema';
+/**
+ * Translucent ghost of a box vent, used by the placement tool's cursor
+ * and the move-tool preview. Builds the geometry through the shared
+ * pure builder so the ghost shape stays in lockstep with the committed
+ * vent.
+ *
+ * Raycast is disabled on the mesh — the cursor follows the vent, so
+ * leaving raycast active would cause the preview itself to intercept
+ * the cursor ray and starve the placement tool of `roof:move` events.
+ */
+declare const BoxVentPreview: ({ node, invalid }: {
+    node: BoxVentNode;
+    invalid?: boolean;
+}) => import("react").JSX.Element;
+export default BoxVentPreview;
+//# sourceMappingURL=preview.d.ts.map

package/dist/box-vent/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/box-vent/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAAI,mBAAmB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,gCAgDlF,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/box-vent/preview.js

@@ -0,0 +1,41 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import * as THREE from 'three';
+import { INVALID_GHOST_COLOR } from '../shared/ghost-materials';
+import { buildBoxVentGeometry } from './geometry';
+/**
+ * Translucent ghost of a box vent, used by the placement tool's cursor
+ * and the move-tool preview. Builds the geometry through the shared
+ * pure builder so the ghost shape stays in lockstep with the committed
+ * vent.
+ *
+ * Raycast is disabled on the mesh — the cursor follows the vent, so
+ * leaving raycast active would cause the preview itself to intercept
+ * the cursor ray and starve the placement tool of `roof:move` events.
+ */
+const BoxVentPreview = ({ node, invalid }) => {
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geometry = useMemo(() => buildBoxVentGeometry(node), [node.width, node.depth, node.height, node.hoodOverhang, node.style]);
+    const material = useMemo(() => new THREE.MeshStandardMaterial({
+        color: invalid ? INVALID_GHOST_COLOR : 0xff_ff_ff,
+        emissive: invalid ? INVALID_GHOST_COLOR : 0x6c_a3_ff,
+        emissiveIntensity: 0.18,
+        roughness: 0.85,
+        metalness: 0.05,
+        transparent: true,
+        opacity: invalid ? 0.4 : 0.35,
+        depthWrite: false,
+        side: THREE.DoubleSide,
+    }), [invalid]);
+    const edgesGeometry = useMemo(() => new THREE.EdgesGeometry(geometry, 25), [geometry]);
+    useEffect(() => () => {
+        geometry.dispose();
+        edgesGeometry.dispose();
+        material.dispose();
+    }, [geometry, edgesGeometry, material]);
+    return (_jsxs("group", { "rotation-y": node.rotation ?? 0, children: [_jsx("mesh", { geometry: geometry, material: material, raycast: () => {
+                    /* disabled — see component-level note */
+                } }), _jsx("lineSegments", { geometry: edgesGeometry, renderOrder: 1000, children: _jsx("lineBasicMaterial", { color: 0x6c_a3_ff, depthTest: false, opacity: 0.95, transparent: true }) })] }));
+};
+export default BoxVentPreview;

package/dist/box-vent/renderer.d.ts

@@ -0,0 +1,26 @@
+import { type BoxVentNode } from '@pascal-app/core';
+/**
+ * Box vent renderer. The vent is parented to a roof-segment in the scene
+ * graph, but the registry-era roof-segment renderer doesn't auto-nest
+ * children (it's a single mesh with placeholder geometry filled by
+ * `RoofSystem`). So this renderer reads the parent segment directly and
+ * reproduces the segment-local transform stack manually:
+ *
+ *   segment.position → segment.rotation (Y) → vent.position
+ *     → slope tilt (X) → vent.rotation (Y) → mesh
+ *
+ * The slope tilt is derived from the segment's roof shape and the vent's
+ * local Z — see `computeBoxVentSlopeTilt`. The +Z side of the segment is
+ * the down-slope direction, so a positive Z lands on the lower half of
+ * the pitch.
+ *
+ * Live segment drags are honoured by subscribing to `useLiveTransforms`
+ * for the parent segment ID — during the segment's move, the override
+ * carries the in-progress position/rotation and the vent follows
+ * smoothly without waiting for a commit.
+ */
+declare const BoxVentRenderer: ({ node: storeNode }: {
+    node: BoxVentNode;
+}) => import("react").JSX.Element | null;
+export default BoxVentRenderer;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/box-vent/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/box-vent/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAA;AAqBzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,QAAA,MAAM,eAAe,GAAI,qBAAqB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,uCAqIlE,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/box-vent/renderer.js

@@ -0,0 +1,127 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
+import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip';
+import { buildBoxVentGeometry } from './geometry';
+const defaultMaterial = new THREE.MeshStandardMaterial({
+    color: 0xff_ff_ff,
+    roughness: 0.85,
+    metalness: 0.1,
+});
+/**
+ * Box vent renderer. The vent is parented to a roof-segment in the scene
+ * graph, but the registry-era roof-segment renderer doesn't auto-nest
+ * children (it's a single mesh with placeholder geometry filled by
+ * `RoofSystem`). So this renderer reads the parent segment directly and
+ * reproduces the segment-local transform stack manually:
+ *
+ *   segment.position → segment.rotation (Y) → vent.position
+ *     → slope tilt (X) → vent.rotation (Y) → mesh
+ *
+ * The slope tilt is derived from the segment's roof shape and the vent's
+ * local Z — see `computeBoxVentSlopeTilt`. The +Z side of the segment is
+ * the down-slope direction, so a positive Z lands on the lower half of
+ * the pitch.
+ *
+ * Live segment drags are honoured by subscribing to `useLiveTransforms`
+ * for the parent segment ID — during the segment's move, the override
+ * carries the in-progress position/rotation and the vent follows
+ * smoothly without waiting for a commit.
+ */
+const BoxVentRenderer = ({ node: storeNode }) => {
+    const ref = useRef(null);
+    useRegistry(storeNode.id, 'box-vent', ref);
+    const handlers = useNodeEvents(storeNode, 'box-vent');
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneTheme = useViewer((s) => s.sceneTheme);
+    // Merge live overrides (panel slider drags) on top of the store node.
+    // Sliders write here on every `onChange` and only flush to the scene
+    // store on `onCommit`, so the mesh updates frame-by-frame without
+    // polluting undo history or triggering a full store-driven re-render.
+    const overrides = useLiveNodeOverrides((s) => s.get(storeNode.id));
+    const node = overrides ? { ...storeNode, ...overrides } : storeNode;
+    const segment = useScene((state) => node.roofSegmentId
+        ? state.nodes[node.roofSegmentId]
+        : undefined);
+    // Rebuild geometry whenever any shape-bearing field changes — that's
+    // every parametric field, including the per-style ones. Listing them
+    // explicitly keeps the dep array tight (vs. `[node]` which would
+    // also fire on `name` / `visible` flips).
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geometry = useMemo(() => buildBoxVentGeometry(node), [
+        node.style,
+        node.width,
+        node.depth,
+        node.height,
+        node.hoodOverhang,
+        node.topTaper,
+        node.capHeight,
+        node.capGap,
+        node.domeCurvature,
+        node.baseInset,
+        node.baseHeight,
+        node.cornerBevel,
+    ]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    // Orient the vent to whatever roof face it sits on. The analytical
+    // normal (shared with solar-panel + skylight) handles every roof type
+    // — gable, shed, hip front, hip side — instead of the previous
+    // X-tilt-from-Z-sign trick, which only worked on slopes whose dip
+    // ran along segment-local Z.
+    const surfaceQuat = useMemo(() => {
+        if (!segment)
+            return new THREE.Quaternion();
+        const normal = getAnalyticalNormal(node.position[0] ?? 0, node.position[2] ?? 0, segment);
+        return surfaceQuatFromNormal(normal, new THREE.Quaternion());
+    }, [segment, node.position[0], node.position[2]]);
+    // Paint surface: explicit material wins, then preset, then the cached
+    // default. FrontSide everywhere — DoubleSide on the role material's
+    // NodeMaterial poisons the MRT scene pass (see `materials.ts` line 77 /
+    // glazing fix 9400f1c5). Earlier this path forced DoubleSide so back
+    // faces of the vent body / hood wouldn't drop out when looking up at the
+    // eaves; that's now a known visual tradeoff — a closed-solid extrude in
+    // `geometry.ts` is the right fix if undersides become noticeable.
+    const material = useMemo(() => {
+        if (!textures || (!node.material && !node.materialPreset)) {
+            return createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
+        }
+        return node.material
+            ? createMaterial(node.material, shading)
+            : (createMaterialFromPresetRef(node.materialPreset, shading) ?? defaultMaterial);
+    }, [textures, colorPreset, sceneTheme, shading, node.material, node.materialPreset]);
+    // Compose slope tilt + yaw onto a single quaternion so the registered
+    // ref's local frame is vent-mesh-local. `NodeArrowHandles` reads this
+    // frame to place its chevrons; collapsing the nested-group stack onto
+    // the registered group lets handles use vent-local coords directly,
+    // without per-arrow tilt compensation. Mirrors solar-panel's renderer.
+    const yAxis = useMemo(() => new THREE.Vector3(0, 1, 0), []);
+    const composedQuat = useMemo(() => {
+        const yawQuat = new THREE.Quaternion().setFromAxisAngle(yAxis, node.rotation ?? 0);
+        return new THREE.Quaternion().copy(surfaceQuat).multiply(yawQuat);
+    }, [surfaceQuat, node.rotation, yAxis]);
+    // Map vent-local geometry into the host segment's local frame (the frame the
+    // trim cut prisms live in) — same pose the inner mesh group is mounted with.
+    const localToSegment = useMemo(() => new THREE.Matrix4().compose(new THREE.Vector3(node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0), composedQuat, new THREE.Vector3(1, 1, 1)), [node.position[0], node.position[1], node.position[2], composedQuat]);
+    const clippedGeometry = useSegmentTrimClippedGeometry(geometry, segment, localToSegment);
+    if (!segment)
+        return null;
+    // `node.position` is segment-local (the placement + move tools resolve
+    // the click via `segObj.worldToLocal`). The vent is mounted in the
+    // roof's `roof-elements` group, which carries only the roof transform
+    // — so we replicate the segment's roof-local transform here to bridge
+    // the two frames. Without this, segment-local coords would be rendered
+    // *as if* they were roof-local; on gable / hip roofs (where every
+    // segment shares the roof origin but differs by Y rotation), the vent
+    // would land rotated away from the click — the "slight shift" between
+    // ghost and committed mesh.
+    const segPos = segment.position ?? [0, 0, 0];
+    const segRotY = segment.rotation ?? 0;
+    return (_jsx("group", { position: segPos, "rotation-y": segRotY, children: _jsx("group", { position: [node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0], quaternion: composedQuat, ref: ref, visible: node.visible, children: _jsx("mesh", { castShadow: true, geometry: clippedGeometry ?? geometry, material: material, name: "box-vent-surface", receiveShadow: true, ...handlers }) }) }));
+};
+export default BoxVentRenderer;

package/dist/box-vent/schema.d.ts

@@ -0,0 +1,2 @@
+export { BoxVentNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/box-vent/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/box-vent/schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/box-vent/schema.js

@@ -0,0 +1,3 @@
+// Schema lives in core (referenced by the AnyNode union). Re-export so
+// every box-vent-related import stays inside @pascal-app/nodes/box-vent.
+export { BoxVentNode } from '@pascal-app/core';

package/dist/box-vent/tool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Box-vent placement tool. Mounts when the palette activates the
+ * box-vent kind; listens for `roof:*` events; on click commits a new
+ * `BoxVentNode` parented to the targeted segment with segment-local
+ * coordinates.
+ *
+ * Cursor preview follows the roof surface: position from `roof:move`,
+ * slope tilt from the segment under the cursor, segment yaw from the
+ * roof + segment rotation stack.
+ */
+declare const BoxVentTool: () => import("react").JSX.Element;
+export default BoxVentTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/box-vent/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/box-vent/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;;;;;GASG;AACH,QAAA,MAAM,WAAW,mCA6HhB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/box-vent/tool.js

@@ -0,0 +1,116 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { BoxVentNode, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
+import { getAnalyticalNormal, getDownSlopeYaw, surfaceQuatFromNormal } from '../shared/roof-surface';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
+import { boxVentDefinition } from './definition';
+import BoxVentPreview from './preview';
+const worldPoint = new THREE.Vector3();
+/**
+ * Box-vent placement tool. Mounts when the palette activates the
+ * box-vent kind; listens for `roof:*` events; on click commits a new
+ * `BoxVentNode` parented to the targeted segment with segment-local
+ * coordinates.
+ *
+ * Cursor preview follows the roof surface: position from `roof:move`,
+ * slope tilt from the segment under the cursor, segment yaw from the
+ * roof + segment rotation stack.
+ */
+const BoxVentTool = () => {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const setSelection = useViewer((s) => s.setSelection);
+    const [previewPos, setPreviewPos] = useState(null);
+    const [previewSurfaceQuat, setPreviewSurfaceQuat] = useState(null);
+    const [previewYaw, setPreviewYaw] = useState(0);
+    const [previewRotation, setPreviewRotation] = useState(0);
+    const lastSnapRef = useRef(null);
+    // Default-shaped preview node — matches what the commit will create.
+    const previewNode = useMemo(() => BoxVentNode.parse({
+        ...boxVentDefinition.defaults(),
+        name: 'Box Vent',
+        position: [0, 0, 0],
+        rotation: previewRotation,
+    }), [previewRotation]);
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        const worldToBuildingLocal = (wx, wy, wz) => {
+            const buildingObj = sceneRegistry.nodes.get(activeBuildingId);
+            if (!buildingObj)
+                return [wx, wy, wz];
+            worldPoint.set(wx, wy, wz);
+            buildingObj.worldToLocal(worldPoint);
+            return [worldPoint.x, worldPoint.y, worldPoint.z];
+        };
+        const updatePreview = (event) => {
+            const wx = event.position[0];
+            const wy = event.position[1];
+            const wz = event.position[2];
+            const sx = Math.round(wx * 20) / 20;
+            const sz = Math.round(wz * 20) / 20;
+            const prev = lastSnapRef.current;
+            if (event.nativeEvent?.shiftKey !== true && (!prev || prev[0] !== sx || prev[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapRef.current = [sx, sz];
+            }
+            const hit = resolveRoofSegmentHit(event.node, wx, wy, wz);
+            if (!hit)
+                return;
+            const normal = getAnalyticalNormal(hit.localX, hit.localZ, hit.segment);
+            setPreviewSurfaceQuat(surfaceQuatFromNormal(normal, new THREE.Quaternion()));
+            setPreviewYaw((event.node.rotation ?? 0) + (hit.segment.rotation ?? 0));
+            setPreviewRotation(getDownSlopeYaw(hit.localX, hit.localZ, hit.segment));
+            setPreviewPos(worldToBuildingLocal(wx, wy, wz));
+            publishRoofSurfacePlacementGuides({
+                roof: event.node,
+                segment: hit.segment,
+                center: [hit.localX, hit.localY, hit.localZ],
+                footprint: roofSurfaceFootprintFromNode({
+                    ...previewNode,
+                    rotation: getDownSlopeYaw(hit.localX, hit.localZ, hit.segment),
+                }),
+            });
+            event.stopPropagation();
+        };
+        const onClick = (event) => {
+            const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return;
+            const state = useScene.getState();
+            const vent = BoxVentNode.parse({
+                ...boxVentDefinition.defaults(),
+                name: 'Box Vent',
+                roofSegmentId: hit.segment.id,
+                position: [hit.localX, hit.localY, hit.localZ],
+                rotation: getDownSlopeYaw(hit.localX, hit.localZ, hit.segment),
+            });
+            state.createNode(vent, hit.segment.id);
+            state.dirtyNodes.add(hit.segment.id);
+            setSelection({ selectedIds: [vent.id] });
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            event.stopPropagation();
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onClick);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onClick);
+            clearRoofSurfacePlacementGuides();
+        };
+    }, [activeBuildingId, setSelection, previewNode]);
+    return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(BoxVentPreview, { node: previewNode, invalid: true }), onInvalidTarget: () => {
+                    setPreviewPos(null);
+                    setPreviewSurfaceQuat(null);
+                    clearRoofSurfacePlacementGuides();
+                } }), activeBuildingId && previewPos && previewSurfaceQuat && (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx("group", { quaternion: previewSurfaceQuat, children: _jsx(BoxVentPreview, { node: previewNode }) }) }) }))] }));
+};
+export default BoxVentTool;

package/dist/building/definition.d.ts

@@ -0,0 +1,12 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { BuildingNode } from './schema';
+/**
+ * Building — Stage A. Container for levels; can be translated /
+ * rotated as a whole (movable + rotatable on Y). The legacy
+ * `MoveBuildingContent` handles building-wide drag; the registry
+ * fallback would translate position, which is close to right —
+ * but kept legacy at Stage A to avoid disturbing the building's
+ * world-space group transform handling.
+ */
+export declare const buildingDefinition: NodeDefinition<typeof BuildingNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/building/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAE1F,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CAgDlE,CAAA"}