@pascal-app/nodes 0.1.1

package/dist/chimney/presets.d.ts

@@ -0,0 +1,27 @@
+import type { ChimneyNode } from './schema';
+/**
+ * Style presets — opinionated starting points the user can pick from
+ * the panel header. Each preset sets shape / silhouette / accessory
+ * fields only; dimensions (`width` / `depth` / `heightAboveRidge`),
+ * placement (`position` / `rotation` / `roofSegmentId`), and paint
+ * (`material*` / `topMaterial*`) are left untouched so applying a
+ * preset to an already-sized chimney resizes nothing and doesn't
+ * overwrite the user's paint choices.
+ *
+ * Presets are intentionally distinct silhouettes:
+ *  - `brick`      — straight body, double band, flat overhanging cap
+ *  - `modern`     — minimal flat cap, recessed decorative panels
+ *  - `round`      — cylindrical body, single band, industrial look
+ */
+export type ChimneyPresetKey = 'brick' | 'modern' | 'round';
+export declare const CHIMNEY_PRESET_KEYS: ChimneyPresetKey[];
+export declare const CHIMNEY_PRESET_LABELS: Record<ChimneyPresetKey, string>;
+export declare const chimneyPresets: Record<ChimneyPresetKey, Partial<ChimneyNode>>;
+/**
+ * Returns the preset key whose every field matches the supplied node,
+ * or `null` if no preset is an exact match (i.e. the user has tweaked
+ * fields after applying a preset). Used by the panel to highlight the
+ * current preset in the segmented control.
+ */
+export declare function detectActiveChimneyPreset(node: Partial<ChimneyNode> | undefined | null): ChimneyPresetKey | null;
+//# sourceMappingURL=presets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/chimney/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAA;AAE3D,eAAO,MAAM,mBAAmB,EAAE,gBAAgB,EAAiC,CAAA;AAEnF,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAIlE,CAAA;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,gBAAgB,EAAE,OAAO,CAAC,WAAW,CAAC,CA8DzE,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,SAAS,GAAG,IAAI,GAC5C,gBAAgB,GAAG,IAAI,CAezB"}

package/dist/chimney/presets.js

@@ -0,0 +1,93 @@
+export const CHIMNEY_PRESET_KEYS = ['brick', 'modern', 'round'];
+export const CHIMNEY_PRESET_LABELS = {
+    brick: 'Brick',
+    modern: 'Modern',
+    round: 'Round',
+};
+export const chimneyPresets = {
+    brick: {
+        bodyShape: 'square',
+        shoulderStyle: 'none',
+        cap: true,
+        capShape: 'flat',
+        capOverhang: 0.04,
+        capThickness: 0.06,
+        bandStyle: 'double',
+        bandHeight: 0.05,
+        bandExtent: 0.025,
+        bandOffset: 0.4,
+        cricketStyle: 'none',
+        cornerBevel: 0,
+        panelStyle: 'none',
+        flueCount: 1,
+        flueShape: 'round',
+        flueDiameter: 0.2,
+        flueHeight: 0.25,
+        flueSpacing: 1,
+    },
+    modern: {
+        bodyShape: 'square',
+        shoulderStyle: 'none',
+        cap: true,
+        capShape: 'flat',
+        capOverhang: 0.02,
+        capThickness: 0.04,
+        bandStyle: 'none',
+        cricketStyle: 'none',
+        cornerBevel: 0,
+        panelStyle: 'rectangular',
+        panelDepth: 0.015,
+        panelHeight: 1.0,
+        panelOffsetTop: 0.2,
+        panelMargin: 0.12,
+        flueCount: 1,
+        flueShape: 'round',
+        flueDiameter: 0.16,
+        flueHeight: 0.18,
+        flueSpacing: 1,
+    },
+    round: {
+        bodyShape: 'round',
+        shoulderStyle: 'none',
+        cap: true,
+        capShape: 'flat',
+        capOverhang: 0.05,
+        capThickness: 0.05,
+        bandStyle: 'single',
+        bandHeight: 0.04,
+        bandExtent: 0.02,
+        bandOffset: 0.4,
+        cricketStyle: 'none',
+        cornerBevel: 0,
+        panelStyle: 'none',
+        flueCount: 1,
+        flueShape: 'round',
+        flueDiameter: 0.16,
+        flueHeight: 0.2,
+        flueSpacing: 1,
+    },
+};
+/**
+ * Returns the preset key whose every field matches the supplied node,
+ * or `null` if no preset is an exact match (i.e. the user has tweaked
+ * fields after applying a preset). Used by the panel to highlight the
+ * current preset in the segmented control.
+ */
+export function detectActiveChimneyPreset(node) {
+    if (!node)
+        return null;
+    for (const key of CHIMNEY_PRESET_KEYS) {
+        const preset = chimneyPresets[key];
+        const n = node;
+        let matches = true;
+        for (const k of Object.keys(preset)) {
+            if (n[k] !== preset[k]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return key;
+    }
+    return null;
+}

package/dist/chimney/preview.d.ts

@@ -0,0 +1,14 @@
+import { type ChimneyNode, type RoofSegmentNode } from '@pascal-app/core';
+/**
+ * The preview needs a segment fixture to build the body height. The
+ * placement tool passes the segment under the cursor; when floating
+ * (off-roof fallback), segment is absent — build against RoofSegmentNode
+ * defaults so the ghost renders flat at the grid position with yaw 0.
+ */
+declare const ChimneyPreview: ({ node, segment, invalid, }: {
+    node: ChimneyNode;
+    segment?: RoofSegmentNode;
+    invalid?: boolean;
+}) => import("react").JSX.Element;
+export default ChimneyPreview;
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/chimney/preview.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AA0BzB;;;;;GAKG;AACH,QAAA,MAAM,cAAc,GAAI,6BAIrB;IACD,IAAI,EAAE,WAAW,CAAA;IACjB,OAAO,CAAC,EAAE,eAAe,CAAA;IACzB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,gCAyDA,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/chimney/preview.js

@@ -0,0 +1,74 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RoofSegmentNode as RoofSegmentSchema, } from '@pascal-app/core';
+import { useEffect, useMemo } from 'react';
+import * as THREE from 'three';
+import { INVALID_GHOST_COLOR } from '../shared/ghost-materials';
+import { buildChimneyGeometry } from './geometry';
+const ghostMaterial = new THREE.MeshStandardMaterial({
+    color: 0xff_ff_ff,
+    emissive: 0xff_ff_ff,
+    emissiveIntensity: 0.12,
+    roughness: 0.85,
+    transparent: true,
+    opacity: 0.55,
+    depthWrite: false,
+});
+const invalidGhostMaterial = new THREE.MeshStandardMaterial({
+    color: INVALID_GHOST_COLOR,
+    emissive: INVALID_GHOST_COLOR,
+    emissiveIntensity: 0.12,
+    roughness: 0.85,
+    transparent: true,
+    opacity: 0.4,
+    depthWrite: false,
+});
+/**
+ * The preview needs a segment fixture to build the body height. The
+ * placement tool passes the segment under the cursor; when floating
+ * (off-roof fallback), segment is absent — build against RoofSegmentNode
+ * defaults so the ghost renders flat at the grid position with yaw 0.
+ */
+const ChimneyPreview = ({ node, segment, invalid, }) => {
+    const material = invalid ? invalidGhostMaterial : ghostMaterial;
+    const effectiveSegment = segment ?? RoofSegmentSchema.parse({});
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geo = useMemo(() => buildChimneyGeometry(node, effectiveSegment), [
+        effectiveSegment.wallHeight,
+        effectiveSegment.pitch,
+        effectiveSegment.roofType,
+        effectiveSegment.width,
+        effectiveSegment.depth,
+        node.width,
+        node.depth,
+        node.heightAboveRidge,
+        node.bodyShape,
+        node.shoulderStyle,
+        node.shoulderHeight,
+        node.shoulderExtent,
+        node.cap,
+        node.capShape,
+        node.capOverhang,
+        node.capThickness,
+        node.flueCount,
+        node.flueShape,
+        node.flueHeight,
+        node.flueDiameter,
+        node.flueSpacing,
+        node.cricketStyle,
+        node.cricketSide,
+        node.cricketLength,
+        node.cricketHeight,
+        node.position[0],
+        node.position[2],
+        node.rotation,
+    ]);
+    useEffect(() => () => {
+        geo.body.dispose();
+        geo.cap?.dispose();
+        geo.flues?.dispose();
+        geo.cricket?.dispose();
+    }, [geo]);
+    return (_jsxs("group", { children: [_jsx("mesh", { geometry: geo.body, material: material, raycast: () => { } }), geo.cap && _jsx("mesh", { geometry: geo.cap, material: material, raycast: () => { } }), geo.flues && _jsx("mesh", { geometry: geo.flues, material: material, raycast: () => { } }), geo.cricket && _jsx("mesh", { geometry: geo.cricket, material: material, raycast: () => { } })] }));
+};
+export default ChimneyPreview;

package/dist/chimney/renderer.d.ts

@@ -0,0 +1,17 @@
+import { type ChimneyNode } from '@pascal-app/core';
+/**
+ * Chimney renderer. Reads the parent roof-segment so the body height
+ * is derived from `segment.wallHeight + roofHeight + node.heightAboveRidge`.
+ *
+ * **Option C scope**: chimney is rendered as solid geometry that
+ * intersects the roof at the deck line. The decorative CSG-driven
+ * features (cap flue holes, body cavity, panels, bands) are not
+ * rendered in this port — they remain as no-op fields in the schema
+ * until the roof-segment Stage B migration introduces a `roofCutout`
+ * capability the parent can read.
+ */
+declare const ChimneyRenderer: ({ node: storeNode }: {
+    node: ChimneyNode;
+}) => import("react").JSX.Element | null;
+export default ChimneyRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

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

package/dist/chimney/renderer.js

@@ -0,0 +1,193 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, getRoofSegmentBrushes, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip';
+import { buildChimneyGeometry } from './geometry';
+import { carveChimneyHoles } from './holes';
+import { trimChimneyBodyAgainstRoof } from './roof-trim';
+/**
+ * Chimney renderer. Reads the parent roof-segment so the body height
+ * is derived from `segment.wallHeight + roofHeight + node.heightAboveRidge`.
+ *
+ * **Option C scope**: chimney is rendered as solid geometry that
+ * intersects the roof at the deck line. The decorative CSG-driven
+ * features (cap flue holes, body cavity, panels, bands) are not
+ * rendered in this port — they remain as no-op fields in the schema
+ * until the roof-segment Stage B migration introduces a `roofCutout`
+ * capability the parent can read.
+ */
+const ChimneyRenderer = ({ node: storeNode }) => {
+    const ref = useRef(null);
+    useRegistry(storeNode.id, 'chimney', ref);
+    const handlers = useNodeEvents(storeNode, 'chimney');
+    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 in-flight slider drags from `useLiveNodeOverrides` so the mesh
+    // updates while the user is still holding the slider. On release the
+    // panel commits to the store and clears the override.
+    const overrides = useLiveNodeOverrides((state) => state.get(storeNode.id));
+    const node = useMemo(() => (overrides ? { ...storeNode, ...overrides } : storeNode), [storeNode, overrides]);
+    const segment = useScene((state) => node.roofSegmentId
+        ? state.nodes[node.roofSegmentId]
+        : undefined);
+    // Geometry + carved CSG depend on the chimney's full schema and the
+    // host segment's shape. Both come in as memoised references — `node`
+    // only re-references when the store node or a live-override actually
+    // changes, `segment` only when the segment's own data changes — so a
+    // two-entry dep array is equivalent to enumerating every field, and
+    // adding a new schema field doesn't risk stale geometry from a
+    // forgotten dep.
+    const geo = useMemo(() => {
+        if (!segment)
+            return null;
+        const raw = buildChimneyGeometry(node, segment);
+        // Carve the smoke shaft (body cavity), cap holes, and hollow flue
+        // bores. Matches the v1 roof-system visual.
+        const carved = carveChimneyHoles(raw.body, raw.cap, raw.flues, node, segment);
+        return { ...raw, body: carved.body, cap: carved.cap, flues: carved.flues };
+    }, [node, segment]);
+    // Segment brushes for the body trim. Building these is non-trivial
+    // (4 CSG-ready Brush instances per segment). `segment` comes from a
+    // `useScene` selector, so it only re-identifies when the segment's own
+    // data changes — depend on it directly (as the `geo` memo above does)
+    // and the brushes rebuild exactly when the host roof reshapes, incl.
+    // the gambrel / mansard / dutch-hip width-ratio fields that
+    // `getRoofSegmentBrushes` reads. A chimney slider drag changes `node`,
+    // not `segment`, so the cache still survives the drag. Enumerating
+    // individual fields here previously omitted those ratios and left the
+    // trim CSG-ing against a stale roof outline.
+    const segmentBrushes = useMemo(() => (segment ? getRoofSegmentBrushes(segment) : null), [segment]);
+    useEffect(() => () => {
+        if (segmentBrushes) {
+            segmentBrushes.deckSlab.geometry.dispose();
+            segmentBrushes.shinSlab.geometry.dispose();
+            segmentBrushes.wallBrush.geometry.dispose();
+            segmentBrushes.innerBrush.geometry.dispose();
+        }
+    }, [segmentBrushes]);
+    // CSG-trim the body against the parent roof segment so the portion
+    // passing through the wall and shingles is hidden. Returns the
+    // original body geometry on any CSG failure (logged via console.error).
+    const trimmedBody = useMemo(() => {
+        if (!geo || !segment || !segmentBrushes)
+            return null;
+        return trimChimneyBodyAgainstRoof(geo.body, segment, node, segmentBrushes);
+    }, [geo, segment, node, segmentBrushes]);
+    useEffect(() => () => {
+        if (geo) {
+            // The body may have been replaced by the trimmed version —
+            // `trimChimneyBodyAgainstRoof` disposes the original on
+            // success. Dispose `trimmedBody` if present, else the
+            // original body.
+            ;
+            (trimmedBody ?? geo.body).dispose();
+            geo.cap?.dispose();
+            geo.flues?.dispose();
+            geo.cricket?.dispose();
+            geo.bands?.dispose();
+        }
+    }, [geo, trimmedBody]);
+    // Map chimney-local geometry into the host segment's local frame (where the
+    // trim cut prisms live) — same pose the inner mesh group is mounted with
+    // (node.position x/z, y=0 — chimneys anchor to the surface, not position[1]).
+    // Every chimney part (body, cap, flues, cricket, bands) shares this pose, so
+    // each is clipped by the segment trim independently. The body chains AFTER
+    // the through-roof self-trim, so both CSG passes compose.
+    const localToSegment = useMemo(() => new THREE.Matrix4().compose(new THREE.Vector3(node.position[0] ?? 0, 0, node.position[2] ?? 0), new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), node.rotation ?? 0), new THREE.Vector3(1, 1, 1)), [node.position[0], node.position[2], node.rotation]);
+    const clippedBody = useSegmentTrimClippedGeometry(trimmedBody ?? geo?.body ?? null, segment, localToSegment);
+    const clippedCap = useSegmentTrimClippedGeometry(geo?.cap ?? null, segment, localToSegment);
+    const clippedFlues = useSegmentTrimClippedGeometry(geo?.flues ?? null, segment, localToSegment);
+    const clippedCricket = useSegmentTrimClippedGeometry(geo?.cricket ?? null, segment, localToSegment);
+    const clippedBands = useSegmentTrimClippedGeometry(geo?.bands ?? null, segment, localToSegment);
+    // Per-instance fallback materials. Were previously module-scoped
+    // singletons shared across every chimney — a paint-mode or debug
+    // system that mutates `surfaceMaterial` would have flipped the look
+    // of every unpainted chimney on the scene. Owning them here also
+    // lets us dispose them on unmount.
+    const fallbackBodyMaterial = useMemo(() => new THREE.MeshStandardMaterial({
+        color: 0xb8_88_72,
+        roughness: 0.85,
+        metalness: 0,
+    }), []);
+    const fallbackTopMaterial = useMemo(() => new THREE.MeshStandardMaterial({
+        color: 0xa0_a0_a0,
+        roughness: 0.75,
+        metalness: 0,
+    }), []);
+    useEffect(() => () => {
+        fallbackBodyMaterial.dispose();
+        fallbackTopMaterial.dispose();
+    }, [fallbackBodyMaterial, fallbackTopMaterial]);
+    const surfaceMaterial = useMemo(() => {
+        // Untextured chimney body (and everything in textures-off mode) takes
+        // the themed 'wall' role colour; only an explicit preset/material keeps
+        // its texture when textures are on.
+        if (!textures || (!node.material && !node.materialPreset)) {
+            return createSurfaceRoleMaterial('wall', colorPreset, undefined, sceneTheme);
+        }
+        if (node.material)
+            return createMaterial(node.material, shading);
+        return createMaterialFromPresetRef(node.materialPreset, shading) ?? fallbackBodyMaterial;
+    }, [
+        textures,
+        colorPreset,
+        sceneTheme,
+        shading,
+        node.material,
+        node.materialPreset,
+        fallbackBodyMaterial,
+    ]);
+    const capSurfaceMaterial = useMemo(() => {
+        // Cap/crown is the chimney's roof-facing surface → 'roof' role when
+        // untextured (or textures off). Otherwise resolve the explicit cap
+        // material, then fall back to the body material.
+        if (!textures ||
+            (!node.topMaterial && !node.topMaterialPreset && !node.material && !node.materialPreset)) {
+            return createSurfaceRoleMaterial('roof', colorPreset, undefined, sceneTheme);
+        }
+        if (node.topMaterial)
+            return createMaterial(node.topMaterial, shading);
+        const preset = createMaterialFromPresetRef(node.topMaterialPreset, shading);
+        if (preset)
+            return preset;
+        if (node.material)
+            return createMaterial(node.material, shading);
+        return createMaterialFromPresetRef(node.materialPreset, shading) ?? fallbackTopMaterial;
+    }, [
+        textures,
+        colorPreset,
+        sceneTheme,
+        shading,
+        node.topMaterial,
+        node.topMaterialPreset,
+        node.material,
+        node.materialPreset,
+        fallbackTopMaterial,
+    ]);
+    // Two-material array: index 0 = body/surface, index 1 = top. The
+    // geometry buffers are partitioned in `holes.ts:partitionTopFaceGroups`
+    // so the very top face of body/cap/flues lands in group 1 and picks up
+    // the top material — matching the v1 roof-system visual.
+    // Must be declared above the early-return below: hooks can't be
+    // called conditionally without changing the hook-call order between
+    // renders.
+    const surfaceArray = useMemo(() => [surfaceMaterial, capSurfaceMaterial], [surfaceMaterial, capSurfaceMaterial]);
+    if (!segment || !geo)
+        return null;
+    // Chimneys are mounted inside `RoofRenderer`'s `roof-elements` group,
+    // which sits at the ROOF's origin — not inside the host segment's
+    // transform. Apply the segment's pose on the outer group, then nest a
+    // ref'd inner group at the chimney's segment-local position +
+    // rotation so the registered Object3D's local frame is *chimney-local*
+    // — that's what `NodeArrowHandles` reads to place its arrows.
+    // Mirrors skylight's renderer; geometry comes from `geometry.ts` in
+    // chimney-local frame (no transform baking) and lands in the right
+    // world spot via the two-group stack below.
+    return (_jsx("group", { position: segment.position, "rotation-y": segment.rotation, visible: node.visible, ...handlers, children: _jsxs("group", { position: [node.position[0] ?? 0, 0, node.position[2] ?? 0], ref: ref, "rotation-y": node.rotation ?? 0, children: [_jsx("mesh", { castShadow: true, geometry: clippedBody ?? trimmedBody ?? geo.body, material: surfaceArray, name: "chimney-body", receiveShadow: true }), geo.cap && (_jsx("mesh", { castShadow: true, geometry: clippedCap ?? geo.cap, material: surfaceArray, name: "chimney-cap", receiveShadow: true })), geo.flues && (_jsx("mesh", { castShadow: true, geometry: clippedFlues ?? geo.flues, material: surfaceArray, name: "chimney-flues", receiveShadow: true })), geo.cricket && (_jsx("mesh", { castShadow: true, geometry: clippedCricket ?? geo.cricket, material: surfaceMaterial, name: "chimney-cricket", receiveShadow: true })), geo.bands && (_jsx("mesh", { castShadow: true, geometry: clippedBands ?? geo.bands, material: surfaceMaterial, name: "chimney-bands", receiveShadow: true }))] }) }));
+};
+export default ChimneyRenderer;

package/dist/chimney/roof-trim.d.ts

@@ -0,0 +1,23 @@
+import { type ChimneyNode, type RoofSegmentNode } from '@pascal-app/core';
+import { type getRoofSegmentBrushes } from '@pascal-app/viewer';
+import * as THREE from 'three';
+export type SegmentTrimBrushes = NonNullable<ReturnType<typeof getRoofSegmentBrushes>>;
+/**
+ * CSG-trim the chimney body against the parent roof segment so the
+ * portion of the chimney that passes through the wall and shingles
+ * is hidden — gives the clean "chimney emerges from the roof" look
+ * the archive shipped. Lives in the chimney folder (not the geometry
+ * builder) because three-bvh-csg + three-mesh-bvh are viewer-only
+ * deps; the renderer is the natural seam since it already imports
+ * from `@pascal-app/viewer`.
+ *
+ * Segment brushes are passed in (built once per segment shape in the
+ * renderer and reused across slider drags); the function does NOT
+ * dispose them. CSG `evaluate` returns a new brush, so the input
+ * brushes survive the call unmutated.
+ *
+ * Returns the input geometry untouched on any CSG failure so the
+ * chimney still renders (just not trimmed).
+ */
+export declare function trimChimneyBodyAgainstRoof(body: THREE.BufferGeometry, segment: RoofSegmentNode, node: ChimneyNode, segBrushes: SegmentTrimBrushes): THREE.BufferGeometry;
+//# sourceMappingURL=roof-trim.d.ts.map

package/dist/chimney/roof-trim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-trim.d.ts","sourceRoot":"","sources":["../../src/chimney/roof-trim.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAuB,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAC9F,OAAO,EAIL,KAAK,qBAAqB,EAG3B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAAA;AAEtF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,KAAK,CAAC,cAAc,EAC1B,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,kBAAkB,GAC7B,KAAK,CAAC,cAAc,CA2EtB"}

package/dist/chimney/roof-trim.js

@@ -0,0 +1,94 @@
+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 { partitionTopFaceGroups } from './holes';
+const visibleMat = new THREE.MeshBasicMaterial();
+/**
+ * CSG-trim the chimney body against the parent roof segment so the
+ * portion of the chimney that passes through the wall and shingles
+ * is hidden — gives the clean "chimney emerges from the roof" look
+ * the archive shipped. Lives in the chimney folder (not the geometry
+ * builder) because three-bvh-csg + three-mesh-bvh are viewer-only
+ * deps; the renderer is the natural seam since it already imports
+ * from `@pascal-app/viewer`.
+ *
+ * Segment brushes are passed in (built once per segment shape in the
+ * renderer and reused across slider drags); the function does NOT
+ * dispose them. CSG `evaluate` returns a new brush, so the input
+ * brushes survive the call unmutated.
+ *
+ * Returns the input geometry untouched on any CSG failure so the
+ * chimney still renders (just not trimmed).
+ */
+export function trimChimneyBodyAgainstRoof(body, segment, node, segBrushes) {
+    const { shinSlab, wallBrush } = segBrushes;
+    // The body comes in chimney-local frame — `node.position` /
+    // `node.rotation` are applied by the renderer's nested ref'd group
+    // rather than baked into the geometry. Segment brushes from
+    // `getRoofSegmentBrushes` are in segment-local frame, so we move the
+    // chimney brush into segment-local space for the CSG pass, then strip
+    // the same transform back off the result before returning, so the
+    // mesh stays in chimney-local for the renderer to position via the
+    // inner ref group.
+    const indexed = mergeVertices(body, 1e-4);
+    if (!indexed.getAttribute('normal'))
+        indexed.computeVertexNormals();
+    const hasRotation = Math.abs(node.rotation) > 1e-4;
+    const posX = node.position[0] ?? 0;
+    const posZ = node.position[2] ?? 0;
+    if (hasRotation)
+        indexed.rotateY(node.rotation);
+    indexed.translate(posX, 0, posZ);
+    const indexCount = indexed.getIndex()?.count ?? 0;
+    indexed.clearGroups();
+    if (indexCount > 0)
+        indexed.addGroup(0, indexCount, 0);
+    indexed.computeBoundsTree?.({ maxLeafSize: 10 });
+    const chimneyBrush = new Brush(indexed, visibleMat);
+    chimneyBrush.updateMatrixWorld();
+    prepareBrushForCSG(chimneyBrush);
+    let result = body;
+    try {
+        // Two-pass subtraction: trim the chimney shaft below the eave with
+        // `wallBrush`, then trim the section above the wall but below the
+        // shingles with `shinSlab`. Together these hide the chimney's body
+        // wherever it passes through the roof shell, leaving only the
+        // visible portion above the shingles.
+        const step1 = csgEvaluator.evaluate(chimneyBrush, wallBrush, SUBTRACTION);
+        prepareBrushForCSG(step1);
+        const step2 = csgEvaluator.evaluate(step1, shinSlab, SUBTRACTION);
+        const out = csgGeometry(step2).clone();
+        // Strip the same node transform we baked onto the input so the
+        // returned geometry is back in chimney-local frame (the renderer's
+        // inner ref'd group applies `node.position` / `node.rotation`).
+        out.translate(-posX, 0, -posZ);
+        if (hasRotation)
+            out.rotateY(-node.rotation);
+        const ic = out.getIndex()?.count ?? 0;
+        out.clearGroups();
+        if (ic > 0)
+            out.addGroup(0, ic, 0);
+        out.computeVertexNormals();
+        // Re-partition the top rim face into group 1 so the body mesh's
+        // `[bodyMaterial, topMaterial]` array routes the rim to the top
+        // material — the CSG step above wiped the partition we set inside
+        // `holes.ts:carveChimneyHoles`. Same threshold as the carve step
+        // (top rim is at `topY`, just below it for safety).
+        const peakY = segment.wallHeight + getActiveRoofHeight(segment);
+        const topY = peakY + node.heightAboveRidge;
+        partitionTopFaceGroups(out, topY - 0.05);
+        body.dispose();
+        step1.geometry.dispose();
+        step2.geometry.dispose();
+        indexed.dispose();
+        result = out;
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.error('[chimney] roof-trim CSG failed:', e);
+        indexed.dispose();
+        result = body;
+    }
+    return result;
+}

package/dist/chimney/schema.d.ts

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

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

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

package/dist/chimney/schema.js

@@ -0,0 +1 @@
+export { ChimneyNode } from '@pascal-app/core';

package/dist/chimney/tool.d.ts

@@ -0,0 +1,3 @@
+declare const ChimneyTool: () => import("react").JSX.Element;
+export default ChimneyTool;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/chimney/tool.tsx"],"names":[],"mappings":"AA4CA,QAAA,MAAM,WAAW,mCAyIhB,CAAA;AAED,eAAe,WAAW,CAAA"}