@pascal-app/nodes 0.1.1

package/dist/chimney/holes.js

@@ -0,0 +1,310 @@
+import { getActiveRoofHeight } from '@pascal-app/core';
+import { Brush, csgEvaluator, csgGeometry, prepareBrushForCSG, SUBTRACTION, } from '@pascal-app/viewer';
+import * as THREE from 'three';
+import { mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { flueXPositions } from './geometry';
+const dummyMat = new THREE.MeshBasicMaterial();
+/**
+ * Carve the top openings the chimney needs:
+ *   - smoke shaft cavity in the body (one chimney-wide hole, or one
+ *     bore per flue when the flues are hollow)
+ *   - matching holes punched through the cap
+ *   - inner bore subtracted from each flue tube
+ *
+ * Mirrors the v1 roof-system pipeline. Lives next to `roof-trim.ts` so
+ * the CSG deps (three-bvh-csg / three-mesh-bvh) stay inside the
+ * chimney folder; `geometry.ts` itself stays pure.
+ */
+export function carveChimneyHoles(body, cap, flues, node, segment) {
+    const peakY = segment.wallHeight + getActiveRoofHeight(segment);
+    const topY = peakY + node.heightAboveRidge;
+    const capPresent = !!cap && node.cap && node.capShape !== 'none';
+    const capTopY = topY + (capPresent ? node.capThickness : 0);
+    const flueCount = Math.max(0, Math.min(4, node.flueCount ?? 0));
+    const flueDiameter = Math.max(0.02, node.flueDiameter ?? 0.22);
+    const flueWallT = Math.max(0, node.flueWallThickness ?? 0.02);
+    const flueInner = flueDiameter - 2 * flueWallT;
+    const useFlueHoles = flueCount > 0 && flueWallT > 0 && flueInner > 0.02;
+    const cavityDepth = Math.max(0, node.bodyHollowDepth ?? 0.6);
+    const hollowMargin = Math.max(0, node.bodyHollowMargin ?? 0.08);
+    const isRound = (node.bodyShape ?? 'square') === 'round';
+    const specs = [];
+    if (cavityDepth > 0.01) {
+        if (useFlueHoles) {
+            const xs = flueXPositions(flueCount, node.width, flueDiameter, node.flueSpacing);
+            const flueShape = node.flueShape ?? 'round';
+            for (const x of xs) {
+                specs.push({ shape: flueShape, sizeX: flueInner, sizeZ: flueInner, xCenter: x });
+            }
+        }
+        else if (hollowMargin > 0) {
+            if (isRound) {
+                const r = node.width / 2 - hollowMargin;
+                if (r > 0.02) {
+                    specs.push({ shape: 'round', sizeX: 2 * r, sizeZ: 2 * r, xCenter: 0 });
+                }
+            }
+            else {
+                const cw = node.width - 2 * hollowMargin;
+                const cd = node.depth - 2 * hollowMargin;
+                if (cw > 0.04 && cd > 0.04) {
+                    specs.push({ shape: 'square', sizeX: cw, sizeZ: cd, xCenter: 0 });
+                }
+            }
+        }
+    }
+    const flueHeight = Math.max(0.02, node.flueHeight ?? 0.3);
+    const yCavityBot = topY - cavityDepth;
+    const yCapTop = capTopY + 0.02;
+    const subtractFrom = (base, yBot, yTop) => {
+        if (specs.length === 0)
+            return base;
+        const cutters = specs.map((spec) => buildCutter(node, spec, yBot, yTop));
+        const result = subtractCutters(base, cutters);
+        for (const cutter of cutters)
+            cutter.geometry.dispose();
+        return result;
+    };
+    let newBody = subtractFrom(body, yCavityBot, yCapTop);
+    const newCap = cap ? subtractFrom(cap, yCavityBot, yCapTop) : null;
+    // Decorative inset panels — carve a shallow rectangle out of each
+    // vertical face. Square bodies only (round bodies have no flat
+    // faces). Same CSG pipeline as the cavity cutters above.
+    const wantPanels = node.panelStyle !== 'none' && !isRound && node.panelDepth > 0 && node.panelHeight > 0.01;
+    if (wantPanels) {
+        const panelCutters = buildPanelCutters(node, topY);
+        if (panelCutters.length > 0) {
+            newBody = subtractCutters(newBody, panelCutters);
+            for (const cutter of panelCutters)
+                cutter.geometry.dispose();
+        }
+    }
+    // Hollow each flue tube by punching its inner bore through.
+    let newFlues = flues;
+    if (flues && useFlueHoles) {
+        const xs = flueXPositions(flueCount, node.width, flueDiameter, node.flueSpacing);
+        const flueShape = node.flueShape ?? 'round';
+        const cutters = xs.map((x) => buildCutter(node, { shape: flueShape, sizeX: flueInner, sizeZ: flueInner, xCenter: x }, capTopY - 0.02, capTopY + flueHeight + 0.02));
+        newFlues = subtractCutters(flues, cutters);
+        for (const cutter of cutters)
+            cutter.geometry.dispose();
+    }
+    // Partition each surface so the very top face becomes its own material
+    // group (index 1 → top material, index 0 → body material). Matches v1's
+    // surface-array assignment.
+    partitionTopFaceGroups(newBody, topY - 0.05);
+    if (newCap)
+        partitionTopFaceGroups(newCap, capTopY - 0.005);
+    if (newFlues)
+        partitionTopFaceGroups(newFlues, capTopY + flueHeight - 0.005);
+    return { body: newBody, cap: newCap, flues: newFlues };
+}
+/**
+ * Split the index buffer into two groups:
+ *   - group 0: every triangle whose normal is NOT roughly up, or that
+ *     sits below `topYMin`. Receives the body material.
+ *   - group 1: the top face triangles. Receives the top material.
+ *
+ * Mirrors the v1 `partitionTopFaceGroups` in
+ * `packages/viewer/src/systems/chimney/chimney-geometry.ts`. Operates in
+ * place — the geometry is re-indexed and its `groups` array rewritten.
+ */
+export function partitionTopFaceGroups(geo, topYMin) {
+    // CSG paths return indexed geometry; the pure-builder path doesn't. If
+    // we don't have an index, build one so the partitioning logic has
+    // something to reorder.
+    if (!geo.getIndex()) {
+        const merged = mergeVertices(geo, 1e-4);
+        if (merged.getIndex()) {
+            const idx = merged.getIndex();
+            geo.setIndex(idx);
+            geo.setAttribute('position', merged.getAttribute('position'));
+            if (merged.getAttribute('uv'))
+                geo.setAttribute('uv', merged.getAttribute('uv'));
+            if (merged.getAttribute('normal'))
+                geo.setAttribute('normal', merged.getAttribute('normal'));
+        }
+    }
+    const positions = geo.getAttribute('position');
+    let normals = geo.getAttribute('normal');
+    if (!normals) {
+        geo.computeVertexNormals();
+        normals = geo.getAttribute('normal');
+    }
+    const index = geo.getIndex();
+    if (!(positions && normals && index)) {
+        geo.clearGroups();
+        geo.addGroup(0, index?.count ?? positions.count, 0);
+        return;
+    }
+    const idxArr = index.array;
+    const topTris = [];
+    const otherTris = [];
+    const yEps = 0.02;
+    for (let i = 0; i < idxArr.length; i += 3) {
+        const a = idxArr[i];
+        const b = idxArr[i + 1];
+        const c = idxArr[i + 2];
+        const ny = (normals.getY(a) + normals.getY(b) + normals.getY(c)) / 3;
+        const py = (positions.getY(a) + positions.getY(b) + positions.getY(c)) / 3;
+        if (ny > 0.95 && py >= topYMin - yEps) {
+            topTris.push(a, b, c);
+        }
+        else {
+            otherTris.push(a, b, c);
+        }
+    }
+    const total = otherTris.length + topTris.length;
+    const useUint32 = (positions.count ?? 0) > 0xff_ff;
+    const newArr = useUint32 ? new Uint32Array(total) : new Uint16Array(total);
+    for (let i = 0; i < otherTris.length; i++)
+        newArr[i] = otherTris[i];
+    for (let i = 0; i < topTris.length; i++)
+        newArr[otherTris.length + i] = topTris[i];
+    geo.setIndex(new THREE.BufferAttribute(newArr, 1));
+    geo.clearGroups();
+    if (otherTris.length > 0)
+        geo.addGroup(0, otherTris.length, 0);
+    if (topTris.length > 0)
+        geo.addGroup(otherTris.length, topTris.length, 1);
+}
+/**
+ * Build one cutter brush per vertical face for the inset-panel feature.
+ * Each cutter is a thin box flush against the body face; CSG-subtracted
+ * from the body it leaves a recessed rectangular panel — same shape as
+ * v1's `buildPanelCutterBrush`.
+ */
+function buildPanelCutters(node, topY) {
+    const w = node.width;
+    const d = node.depth;
+    const margin = Math.max(0, node.panelMargin);
+    const recess = Math.max(0.005, node.panelDepth);
+    const panelHeight = Math.max(0.05, node.panelHeight);
+    const offsetTop = Math.max(0, node.panelOffsetTop);
+    const yTop = topY - offsetTop;
+    const yBot = yTop - panelHeight;
+    const eps = 0.002;
+    const faces = [];
+    const panelW = w - 2 * margin;
+    const panelD = d - 2 * margin;
+    if (panelW > 0.05) {
+        // frontZ
+        faces.push({
+            sizeX: panelW,
+            sizeZ: recess + 2 * eps,
+            cx: 0,
+            cz: d / 2 - recess / 2 + eps,
+        });
+        // backZ
+        faces.push({
+            sizeX: panelW,
+            sizeZ: recess + 2 * eps,
+            cx: 0,
+            cz: -d / 2 + recess / 2 - eps,
+        });
+    }
+    if (panelD > 0.05) {
+        // rightX
+        faces.push({
+            sizeX: recess + 2 * eps,
+            sizeZ: panelD,
+            cx: w / 2 - recess / 2 + eps,
+            cz: 0,
+        });
+        // leftX
+        faces.push({
+            sizeX: recess + 2 * eps,
+            sizeZ: panelD,
+            cx: -w / 2 + recess / 2 - eps,
+            cz: 0,
+        });
+    }
+    const h = Math.max(0.02, yTop - yBot);
+    const midY = (yTop + yBot) / 2;
+    const brushes = [];
+    for (const f of faces) {
+        const geo = new THREE.BoxGeometry(f.sizeX, h, f.sizeZ);
+        geo.translate(f.cx, midY, f.cz);
+        // Body geometry is in chimney-local frame (node.position/rotation are
+        // applied by the renderer's nested ref'd group, not baked into the
+        // buffer geometry), so cutters need to stay in chimney-local too.
+        const idx = geo.getIndex()?.count ?? 0;
+        geo.clearGroups();
+        if (idx > 0)
+            geo.addGroup(0, idx, 0);
+        const brush = new Brush(geo, dummyMat);
+        brush.updateMatrixWorld();
+        prepareBrushForCSG(brush);
+        brushes.push(brush);
+    }
+    return brushes;
+}
+function buildCutter(node, spec, yBot, yTop) {
+    const h = Math.max(0.02, yTop - yBot);
+    const midY = (yTop + yBot) / 2;
+    const geo = spec.shape === 'round'
+        ? new THREE.CylinderGeometry(spec.sizeX / 2, spec.sizeX / 2, h, 24, 1, false)
+        : new THREE.BoxGeometry(spec.sizeX, h, spec.sizeZ);
+    geo.translate(spec.xCenter, midY, 0);
+    // Cutter stays in chimney-local frame to match the body/cap/flue
+    // geometry (node.position/rotation are applied via the renderer's
+    // nested ref'd group, not baked into the buffer geometry).
+    const idx = geo.getIndex()?.count ?? 0;
+    geo.clearGroups();
+    if (idx > 0)
+        geo.addGroup(0, idx, 0);
+    const brush = new Brush(geo, dummyMat);
+    brush.updateMatrixWorld();
+    prepareBrushForCSG(brush);
+    return brush;
+}
+function subtractCutters(base, cutters) {
+    if (cutters.length === 0)
+        return base;
+    const indexed = mergeVertices(base, 1e-4);
+    if (!indexed.getAttribute('normal'))
+        indexed.computeVertexNormals();
+    const ic = indexed.getIndex()?.count ?? 0;
+    indexed.clearGroups();
+    if (ic > 0)
+        indexed.addGroup(0, ic, 0);
+    const baseBrush = new Brush(indexed, dummyMat);
+    baseBrush.updateMatrixWorld();
+    prepareBrushForCSG(baseBrush);
+    let current = baseBrush;
+    const intermediates = [];
+    try {
+        for (const cutter of cutters) {
+            const next = csgEvaluator.evaluate(current, cutter, SUBTRACTION);
+            prepareBrushForCSG(next);
+            if (current !== baseBrush)
+                intermediates.push(current);
+            current = next;
+        }
+        const out = csgGeometry(current).clone();
+        const idx = out.getIndex()?.count ?? 0;
+        out.clearGroups();
+        if (idx > 0)
+            out.addGroup(0, idx, 0);
+        else
+            out.addGroup(0, out.getAttribute('position').count, 0);
+        out.computeVertexNormals();
+        base.dispose();
+        indexed.dispose();
+        for (const b of intermediates)
+            b.geometry.dispose();
+        if (current !== baseBrush)
+            current.geometry.dispose();
+        return out;
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.error('[chimney] hole carve CSG failed:', e);
+        indexed.dispose();
+        for (const b of intermediates)
+            b.geometry.dispose();
+        if (current !== baseBrush)
+            current.geometry.dispose();
+        return base;
+    }
+}

package/dist/chimney/index.d.ts

@@ -0,0 +1,4 @@
+export { chimneyDefinition } from './definition';
+export { buildChimneyGeometry, flueXPositions } from './geometry';
+export { ChimneyNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/chimney/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/chimney/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA"}

package/dist/chimney/index.js

@@ -0,0 +1,3 @@
+export { chimneyDefinition } from './definition';
+export { buildChimneyGeometry, flueXPositions } from './geometry';
+export { ChimneyNode } from './schema';

package/dist/chimney/move-tool.d.ts

@@ -0,0 +1,19 @@
+import { type ChimneyNode } from '@pascal-app/core';
+/**
+ * Drag-to-place tool for chimney duplicate / move. Receives the moving
+ * node (a clone with `id` stripped + `metadata.isNew = true` after a
+ * Duplicate action) via `node` prop, shows the same ghost preview as
+ * placement, and on click commits the cloned chimney to the hit
+ * segment with that segment's local coords.
+ *
+ * Mirrors `tool.tsx`'s placement preview — the only differences are
+ * (a) the ghost is built from the moving node so the duplicate
+ * preserves the original's body shape/material/etc., and (b) on click
+ * we keep all of the clone's fields and only overwrite host segment +
+ * position. Mounted via `def.affordanceTools.move`.
+ */
+declare const MoveChimneyTool: ({ node }: {
+    node: ChimneyNode;
+}) => import("react").JSX.Element | null;
+export default MoveChimneyTool;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/chimney/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/chimney/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AAiCzB;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,eAAe,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,uCAoRvD,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/chimney/move-tool.js

@@ -0,0 +1,286 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ChimneyNode as ChimneyNodeSchema, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { createRelativeRoofDrag, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfaceNodePlacementGuides, snapRoofSurfaceNodeTarget, } from '../shared/roof-surface-placement-guides';
+import ChimneyPreview from './preview';
+const tmpMatrix = new THREE.Matrix4();
+const tmpInv = new THREE.Matrix4();
+const tmpPos = new THREE.Vector3();
+const tmpQuat = new THREE.Quaternion();
+const tmpScale = new THREE.Vector3();
+/**
+ * Drag-to-place tool for chimney duplicate / move. Receives the moving
+ * node (a clone with `id` stripped + `metadata.isNew = true` after a
+ * Duplicate action) via `node` prop, shows the same ghost preview as
+ * placement, and on click commits the cloned chimney to the hit
+ * segment with that segment's local coords.
+ *
+ * Mirrors `tool.tsx`'s placement preview — the only differences are
+ * (a) the ghost is built from the moving node so the duplicate
+ * preserves the original's body shape/material/etc., and (b) on click
+ * we keep all of the clone's fields and only overwrite host segment +
+ * position. Mounted via `def.affordanceTools.move`.
+ */
+const MoveChimneyTool = ({ node }) => {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const setSelection = useViewer((s) => s.setSelection);
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    const [segmentXform, setSegmentXform] = useState(null);
+    const [hitLocal, setHitLocal] = useState(null);
+    const [previewSegment, setPreviewSegment] = useState(null);
+    const lastSnapRef = useRef(null);
+    // Ghost data — same as the moving clone but pinned to position[0,0,0]
+    // (the inner group does the cursor offset). Reparse so Zod fills any
+    // defaults missing from the clone.
+    const previewNode = useMemo(() => ChimneyNodeSchema.parse({
+        ...node,
+        id: 'chimney_preview',
+        position: [0, 0, 0],
+        rotation: 0,
+    }), [node]);
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        useScene.temporal.getState().pause();
+        const original = {
+            position: [...node.position],
+            rotation: node.rotation ?? 0,
+            roofSegmentId: node.roofSegmentId,
+            parentId: node.parentId,
+            metadata: node.metadata,
+        };
+        const meta = node.metadata && typeof node.metadata === 'object' && !Array.isArray(node.metadata)
+            ? node.metadata
+            : {};
+        const isNew = !!meta.isNew;
+        if (node.id) {
+            const chimneyObj = sceneRegistry.nodes.get(node.id);
+            if (chimneyObj)
+                chimneyObj.visible = false;
+        }
+        const computeSegmentXform = (segmentId) => {
+            const buildingObj = sceneRegistry.nodes.get(activeBuildingId);
+            const segObj = sceneRegistry.nodes.get(segmentId);
+            if (!(buildingObj && segObj))
+                return null;
+            buildingObj.updateWorldMatrix(true, false);
+            segObj.updateWorldMatrix(true, false);
+            tmpInv.copy(buildingObj.matrixWorld).invert();
+            tmpMatrix.multiplyMatrices(tmpInv, segObj.matrixWorld);
+            tmpMatrix.decompose(tmpPos, tmpQuat, tmpScale);
+            return {
+                position: [tmpPos.x, tmpPos.y, tmpPos.z],
+                quaternion: [tmpQuat.x, tmpQuat.y, tmpQuat.z, tmpQuat.w],
+            };
+        };
+        let lastTarget = null;
+        let committed = false;
+        const roofDrag = createRelativeRoofDrag({
+            position: original.position,
+            roofSegmentId: original.roofSegmentId,
+        });
+        const resolveSnappedTarget = (event) => {
+            const rawTarget = roofDrag.resolve(event);
+            if (!rawTarget)
+                return null;
+            return snapRoofSurfaceNodeTarget({
+                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true),
+                node,
+                bypass: event.nativeEvent?.shiftKey === true,
+            });
+        };
+        const clearTarget = () => {
+            lastTarget = null;
+            setSegmentXform(null);
+            setHitLocal(null);
+            setPreviewSegment(null);
+            clearRoofSurfacePlacementGuides();
+        };
+        const updatePreview = (event) => {
+            const target = resolveSnappedTarget(event);
+            if (!target)
+                return clearTarget();
+            const sx = Math.round(target.localX * 20) / 20;
+            const sz = Math.round(target.localZ * 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 xform = computeSegmentXform(target.segment.id);
+            if (!xform)
+                return clearTarget();
+            lastTarget = target;
+            setSegmentXform(xform);
+            setHitLocal([target.localX, target.localY, target.localZ]);
+            setPreviewSegment(target.segment);
+            publishRoofSurfaceNodePlacementGuides({
+                roof: event.node,
+                segment: target.segment,
+                center: [target.localX, target.localY, target.localZ],
+                node,
+            });
+            event.stopPropagation();
+        };
+        const onClick = (event) => {
+            if (committed)
+                return;
+            const target = lastTarget ?? resolveSnappedTarget(event);
+            if (!target)
+                return;
+            committed = true;
+            const state = useScene.getState();
+            // Strip the `isNew` flag — only used to mark a duplicate clone
+            // that hasn't been committed yet.
+            const { isNew, ...restMeta } = meta;
+            const cleanedMeta = Object.keys(restMeta).length > 0 ? restMeta : undefined;
+            const targetSegmentId = target.segment.id;
+            // Duplicate (clone with no committed id yet) → create a fresh
+            // chimney parented to the hit segment. Plain move (existing id,
+            // no `isNew` flag) → update host + position in place. Either way
+            // every other field from the clone is preserved.
+            if (isNew || !node.id) {
+                const committed = ChimneyNodeSchema.parse({
+                    ...node,
+                    id: undefined,
+                    roofSegmentId: target.segment.id,
+                    parentId: target.segment.id,
+                    position: [target.localX, target.localY, target.localZ],
+                    visible: true,
+                    metadata: cleanedMeta,
+                });
+                useScene.temporal.getState().resume();
+                state.applyNodeChanges({
+                    delete: node.id ? [node.id] : [],
+                    create: [{ node: committed, parentId: targetSegmentId }],
+                });
+                state.dirtyNodes.add(targetSegmentId);
+                setSelection({ selectedIds: [committed.id] });
+                useScene.temporal.getState().pause();
+            }
+            else {
+                const prevSegmentId = original.roofSegmentId;
+                const reparenting = Boolean(prevSegmentId && prevSegmentId !== targetSegmentId);
+                // Resume BEFORE any scene edits so the reparent (both segments'
+                // children arrays + the chimney's own host/position update) lands as
+                // one tracked transaction. Otherwise undo reverts the chimney but
+                // leaves the children arrays inconsistent with its parentId.
+                useScene.temporal.getState().resume();
+                if (reparenting) {
+                    const oldSeg = state.nodes[prevSegmentId];
+                    if (oldSeg) {
+                        state.updateNode(prevSegmentId, {
+                            children: (oldSeg.children ?? []).filter((id) => id !== node.id),
+                        });
+                    }
+                    const newSeg = state.nodes[targetSegmentId];
+                    if (newSeg && !(newSeg.children ?? []).includes(node.id)) {
+                        state.updateNode(targetSegmentId, {
+                            children: [...(newSeg.children ?? []), node.id],
+                        });
+                    }
+                    state.dirtyNodes.add(prevSegmentId);
+                }
+                state.updateNode(node.id, {
+                    roofSegmentId: target.segment.id,
+                    parentId: target.segment.id,
+                    position: [target.localX, target.localY, target.localZ],
+                    rotation: original.rotation,
+                    visible: true,
+                    metadata: cleanedMeta,
+                });
+                useScene.temporal.getState().pause();
+                state.dirtyNodes.add(targetSegmentId);
+                state.dirtyNodes.add(node.id);
+                setSelection({ selectedIds: [node.id] });
+            }
+            const obj = node.id && !isNew ? sceneRegistry.nodes.get(node.id) : null;
+            if (obj)
+                obj.visible = true;
+            clearRoofSurfacePlacementGuides();
+            setMovingNode(null);
+            triggerSFX('sfx:item-place');
+            event.stopPropagation();
+        };
+        const onCancel = () => {
+            if (isNew) {
+                if (node.id) {
+                    const parentId = original.roofSegmentId;
+                    if (parentId) {
+                        const parent = useScene.getState().nodes[parentId];
+                        if (parent) {
+                            useScene.getState().updateNode(parentId, {
+                                children: (parent.children ?? []).filter((id) => id !== node.id),
+                            });
+                        }
+                    }
+                    useScene.getState().deleteNode(node.id);
+                }
+                useScene.temporal.getState().resume();
+                markToolCancelConsumed();
+                clearRoofSurfacePlacementGuides();
+                setMovingNode(null);
+                return;
+            }
+            if (node.id) {
+                useScene.getState().updateNode(node.id, {
+                    position: original.position,
+                    rotation: original.rotation,
+                    roofSegmentId: original.roofSegmentId,
+                    parentId: original.parentId,
+                    metadata: original.metadata,
+                });
+                if (original.roofSegmentId) {
+                    useScene.getState().dirtyNodes.add(original.roofSegmentId);
+                }
+                const obj = sceneRegistry.nodes.get(node.id);
+                if (obj)
+                    obj.visible = true;
+            }
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            clearRoofSurfacePlacementGuides();
+            setMovingNode(null);
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            if (!lastTarget)
+                return;
+            onClick({
+                nativeEvent: event,
+                stopPropagation: () => event.stopPropagation(),
+            });
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onClick);
+        emitter.on('roof:leave', clearTarget);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onClick);
+            emitter.off('roof:leave', clearTarget);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+            if (node.id) {
+                const obj = sceneRegistry.nodes.get(node.id);
+                if (obj)
+                    obj.visible = true;
+            }
+            clearRoofSurfacePlacementGuides();
+            useScene.temporal.getState().resume();
+        };
+    }, [activeBuildingId, node, setMovingNode, setSelection]);
+    if (!activeBuildingId || !segmentXform || !hitLocal || !previewSegment)
+        return null;
+    return (_jsx("group", { position: segmentXform.position, quaternion: segmentXform.quaternion, children: _jsx("group", { position: [hitLocal[0], 0, hitLocal[2]], children: _jsx(ChimneyPreview, { node: previewNode, segment: previewSegment }) }) }));
+};
+export default MoveChimneyTool;

package/dist/chimney/paint.d.ts

@@ -0,0 +1,24 @@
+import type { ChimneyMaterialRole, ChimneyNode, MaterialSchema, PaintCapability } from '@pascal-app/core';
+/**
+ * Resolve a chimney face click to its logical surface role.
+ *
+ * `holes.ts:partitionTopFaceGroups` partitions the chimney body
+ * mesh's material slots so:
+ *   0 = body
+ *   1 = top (the cap face)
+ * Faces outside any group (cricket mesh, which renders with a single
+ * material) fall back to 'body'.
+ */
+export declare function resolveChimneyRole(materialIndex: number | null): ChimneyMaterialRole;
+export declare function buildChimneyMaterialPatch(role: ChimneyMaterialRole, material: MaterialSchema | undefined, materialPreset: string | undefined): Partial<ChimneyNode>;
+export declare function getEffectiveChimneyMaterial(node: ChimneyNode, role: ChimneyMaterialRole): {
+    material: MaterialSchema | undefined;
+    materialPreset: string | undefined;
+};
+/**
+ * Capability binding for the chimney kind. The editor's
+ * selection-manager invokes these in place of the legacy
+ * `if (node.type === 'chimney') { ... }` arm.
+ */
+export declare const chimneyPaint: PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

package/dist/chimney/paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/chimney/paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAIzB;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,mBAAmB,CAEpF;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,mBAAmB,EACzB,QAAQ,EAAE,cAAc,GAAG,SAAS,EACpC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,OAAO,CAAC,WAAW,CAAC,CAKtB;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,mBAAmB,GACxB;IAAE,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAC;IAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAQ9E;AAyDD;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,eAW1B,CAAA"}