@pascal-app/nodes 0.1.1

package/dist/chimney/definition.js

@@ -0,0 +1,387 @@
+import { ChimneyNode as ChimneyNodeSchema, getActiveRoofHeight, } from '@pascal-app/core';
+import { buildChimneyFloorplan } from './floorplan';
+import { chimneyPaint } from './paint';
+import { chimneyParametrics } from './parametrics';
+import { ChimneyNode } from './schema';
+// Side handle offsets in metres. Match the roof-segment values so a
+// segment + chimney selected back-to-back use the same visual rhythm.
+const SIDE_HANDLE_OFFSET = 0.25;
+const HEIGHT_HANDLE_OFFSET = 0.25;
+const ROTATE_CORNER_OFFSET = 0.35;
+const MIN_BODY_DIM = 0.3;
+const MIN_HEIGHT_ABOVE_RIDGE = 0.05;
+const MIN_FLUE_HEIGHT = 0.05;
+const MAX_FLUE_HEIGHT = 1.5;
+const MIN_CAP_THICKNESS = 0.02;
+const MAX_CAP_THICKNESS = 0.5;
+const MIN_CAP_OVERHANG = 0;
+const MAX_CAP_OVERHANG = 0.3;
+// Cap-reveal gap between body top and cap base — mirrors the
+// `CAP_REVEAL` constant in `geometry.ts`. Local copy because handle
+// placements need to know the cap's Y range and the geometry's
+// constant isn't exported. If you change it here, change it there.
+const CAP_REVEAL = 0.003;
+// Fallback Y when the host segment can't be resolved (shouldn't happen
+// for a placed chimney, but `placement.position` runs synchronously and
+// must always return a vector).
+const FALLBACK_BODY_MID_Y = 1.5;
+// Resolve the segment that hosts this chimney. Returns undefined if the
+// chimney is unparented or the parent isn't in the scene yet.
+function resolveHostSegment(node, sceneApi) {
+    if (!node.roofSegmentId)
+        return undefined;
+    return sceneApi.get(node.roofSegmentId);
+}
+// Mid-Y of the visible chimney body in the host segment's local frame.
+// Matches the geometry builder: body runs from `baseY = max(0, wallHeight
+// - 0.2)` up to `peakY + heightAboveRidge`. The handle Y picks the
+// midpoint of the *visible* portion (deck plane → top) so chevrons sit
+// next to the body, not buried inside the roof deck or floating over
+// the eave.
+function getBodyMidY(node, segment) {
+    const peakY = segment.wallHeight + getActiveRoofHeight(segment);
+    const topY = peakY + node.heightAboveRidge;
+    return (segment.wallHeight + topY) / 2;
+}
+// Top of the chimney body (where the cap reveal gap begins). Tracker
+// handle and cap-thickness handle both reference this Y.
+function getBodyTopY(node, segment) {
+    return segment.wallHeight + getActiveRoofHeight(segment) + node.heightAboveRidge;
+}
+// Cap base Y — the bottom of the cap slab. Sits just above the body
+// top with a small reveal gap so a shadow line separates them.
+function getCapBaseY(node, segment) {
+    return getBodyTopY(node, segment) + CAP_REVEAL;
+}
+// Cap top Y — the top of the cap slab. Falls back to body top when no
+// cap is rendered (flues mount on whichever is the upper surface).
+function getCapTopY(node, segment) {
+    if (!node.cap || node.capShape === 'none')
+        return getBodyTopY(node, segment);
+    return getCapBaseY(node, segment) + node.capThickness;
+}
+// Width arrow on the +X (right) or -X (left) side. Asymmetric resize:
+// dragging one arrow grows the chimney outward from its own edge while
+// the opposite edge stays world-fixed. Handles live in the chimney's
+// registered ref frame (the nested inner group in the renderer that
+// applies `node.position` / `node.rotation`), so placements are in
+// chimney-local coordinates — no per-arrow rotation/translation
+// compensation. `apply` keeps the world-fixed edge anchored even when
+// the chimney is rotated by recentering `position` along the chimney's
+// own +X arm in segment frame.
+function chimneyWidthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: side === 'right' ? 'min' : 'max',
+        // Portal into the roof (grandparent), not the segment (parent). Unpainted
+        // roof segments live inside a `visible={false}` wrapper, which would
+        // hide the handles. The roof itself is always visible. Skylight does
+        // the same.
+        portal: 'grandparent',
+        min: MIN_BODY_DIM,
+        currentValue: (n) => n.width,
+        apply: (initial, newWidth) => {
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
+            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
+            return {
+                width: newWidth,
+                position: [newCenterX, initial.position[1], newCenterZ],
+            };
+        },
+        placement: {
+            position: (n, sceneApi) => {
+                const segment = resolveHostSegment(n, sceneApi);
+                const y = segment ? getBodyMidY(n, segment) : FALLBACK_BODY_MID_Y;
+                return [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), y, 0];
+            },
+            // Chevron faces along the chimney's own ±X; the left arrow flips
+            // 180°. No node.rotation here — the registered inner group is
+            // already rotated by `node.rotation`, so chimney-local +X is the
+            // chevron's natural direction.
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+    };
+}
+// Depth arrow — symmetric on the +Z side. Only meaningful for square
+// bodies; round chimneys are circular (depth field is ignored by the
+// geometry builder, so a depth handle would just resize an invisible
+// field). The chimneys factory below omits this descriptor for round
+// bodies.
+function chimneyDepthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'center',
+        min: MIN_BODY_DIM,
+        currentValue: (n) => n.depth,
+        apply: (_n, newValue) => ({ depth: newValue }),
+        placement: {
+            position: (n, sceneApi) => {
+                const segment = resolveHostSegment(n, sceneApi);
+                const y = segment ? getBodyMidY(n, segment) : FALLBACK_BODY_MID_Y;
+                return [0, y, n.depth / 2 + SIDE_HANDLE_OFFSET];
+            },
+        },
+    };
+}
+// Height-above-ridge tracker. Dashed leader spans the chimney body's
+// visible extent — from the roof deck plane up to the body top — and
+// terminates in a draggable cube at the body top. Cap, flues, cricket
+// and bands sit ABOVE the body and are explicitly excluded from the
+// leader so the height affordance reads as "this is the body height",
+// not "this is the whole stack height". Dragging the cube vertically
+// adjusts `heightAboveRidge` 1:1.
+function chimneyHeightAboveRidgeHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        min: MIN_HEIGHT_ABOVE_RIDGE,
+        currentValue: (n) => n.heightAboveRidge,
+        apply: (initial, newValue) => ({
+            heightAboveRidge: Math.max(MIN_HEIGHT_ABOVE_RIDGE, newValue),
+        }),
+        placement: {
+            // Cube sits AT the body top (no offset) so the leader terminates
+            // exactly at the body's top edge — visually the "ceiling" of the
+            // body, before the cap reveal gap.
+            position: (n, sceneApi) => {
+                const segment = resolveHostSegment(n, sceneApi);
+                const y = segment ? getBodyTopY(n, segment) : FALLBACK_BODY_MID_Y;
+                return [0, y, 0];
+            },
+        },
+        // Leader bottom = deck plane (segment.wallHeight). The chimney body
+        // geometry actually extends a touch below the deck so the bottom
+        // doesn't show above the eave on low-slope roofs (`baseY = max(0,
+        // wallHeight - 0.2)`), but the visible portion starts at the deck —
+        // and starting the leader there is what reads as "body height" to
+        // the user.
+        trackerBaseY: (n, sceneApi) => {
+            const segment = resolveHostSegment(n, sceneApi);
+            return segment?.wallHeight ?? 0;
+        },
+    };
+}
+// Whole-chimney rotation gizmo at the +X/+Z corner of the body
+// footprint. The registered inner group already centers on the chimney
+// and applies its yaw, so the default rotation pivot (rideObject origin)
+// is correct — no `rotationCenter` override needed.
+function chimneyRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: (n, sceneApi) => {
+                const segment = resolveHostSegment(n, sceneApi);
+                const y = segment ? getBodyMidY(n, segment) : FALLBACK_BODY_MID_Y;
+                const isRound = n.bodyShape === 'round';
+                const halfX = n.width / 2 + ROTATE_CORNER_OFFSET;
+                const halfZ = (isRound ? n.width : n.depth) / 2 + ROTATE_CORNER_OFFSET;
+                return [halfX, y, halfZ];
+            },
+            // The two-headed icon's natural bias points along +X; aim it
+            // toward the corner (45° outward from the chimney's local frame).
+            rotationY: () => -Math.PI / 4,
+        },
+    };
+}
+// Flue-height chevron at the center of the cap top, pointing upward.
+// Drag adjusts `flueHeight` for ALL flues uniformly — the schema only
+// carries a single scalar. Placed at chimney center (X=Z=0) so the
+// handle stays valid regardless of `flueCount` / `flueSpacing`. Anchor
+// is 'min' so the flue base stays pinned to the cap and the top edge
+// follows the pointer.
+function chimneyFlueHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        portal: 'grandparent',
+        min: MIN_FLUE_HEIGHT,
+        max: MAX_FLUE_HEIGHT,
+        currentValue: (n) => n.flueHeight,
+        apply: (_n, newValue) => ({ flueHeight: newValue }),
+        placement: {
+            position: (n, sceneApi) => {
+                const segment = resolveHostSegment(n, sceneApi);
+                // Sit the chevron at the flue top so it visually attaches to
+                // the thing being dragged. Fallback Y mirrors the body-top
+                // fallback above.
+                const baseY = segment ? getCapTopY(n, segment) : FALLBACK_BODY_MID_Y;
+                return [0, baseY + n.flueHeight, 0];
+            },
+        },
+    };
+}
+// Cap-thickness chevron above the cap top, pointing upward. Anchor is
+// 'min' so the cap base stays at body-top + reveal and the top edge
+// follows the pointer.
+function chimneyCapThicknessHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        portal: 'grandparent',
+        min: MIN_CAP_THICKNESS,
+        max: MAX_CAP_THICKNESS,
+        currentValue: (n) => n.capThickness,
+        apply: (_n, newValue) => ({ capThickness: newValue }),
+        placement: {
+            position: (n, sceneApi) => {
+                const segment = resolveHostSegment(n, sceneApi);
+                // Offset toward +Z (away from chimney center on the depth axis)
+                // so the cap-thickness chevron doesn't overlap the flue-height
+                // chevron at X=0,Z=0. Pick the cap edge minus a small margin so
+                // it sits on top of the cap, not floating off to the side.
+                const isRound = n.bodyShape === 'round';
+                const halfZ = (isRound ? n.width : n.depth) / 2;
+                const z = halfZ * 0.35;
+                const y = segment ? getCapTopY(n, segment) : FALLBACK_BODY_MID_Y;
+                return [0, y, z];
+            },
+        },
+    };
+}
+// Cap-overhang radial chevron on the +X edge of the cap. Outward 1:1
+// drag grows the overhang; the cap's half-extent is `width/2 + overhang`.
+function chimneyCapOverhangHandle() {
+    return {
+        kind: 'radial-resize',
+        axis: 'x',
+        portal: 'grandparent',
+        min: MIN_CAP_OVERHANG,
+        max: MAX_CAP_OVERHANG,
+        currentValue: (n) => n.capOverhang,
+        apply: (_n, newValue) => ({ capOverhang: newValue }),
+        placement: {
+            position: (n, sceneApi) => {
+                const segment = resolveHostSegment(n, sceneApi);
+                // Cap mid-height in the chimney-local frame so the chevron sits
+                // on the cap edge, not above or below it.
+                const capBaseY = segment ? getCapBaseY(n, segment) : FALLBACK_BODY_MID_Y;
+                const y = capBaseY + n.capThickness / 2;
+                return [n.width / 2 + n.capOverhang + SIDE_HANDLE_OFFSET, y, 0];
+            },
+        },
+    };
+}
+const chimneyHandles = (node) => {
+    const descriptors = [
+        chimneyWidthHandle('right'),
+        chimneyWidthHandle('left'),
+    ];
+    if (node.bodyShape !== 'round')
+        descriptors.push(chimneyDepthHandle());
+    descriptors.push(chimneyHeightAboveRidgeHandle(), chimneyRotateHandle());
+    // Conditional flue/cap handles are temporarily disabled — they fired
+    // a "Color target has no corresponding fragment stage output" WebGPU
+    // validation error that the original four handles don't trigger. The
+    // descriptor shapes (linear-resize y / radial-resize x) match other
+    // working handles in the codebase, so the cause is likely a TSL/MRT
+    // pipeline interaction we haven't pinned down. Re-enable one at a
+    // time after isolating the trigger; the factory + helpers are kept so
+    // we can flip them back on without re-deriving the placement math.
+    // if (node.cap && node.capShape !== 'none') {
+    //   descriptors.push(chimneyCapThicknessHandle(), chimneyCapOverhangHandle())
+    // }
+    // if (node.flueCount > 0) descriptors.push(chimneyFlueHeightHandle())
+    return descriptors;
+};
+// Every fresh chimney starts as plain white (body + top). The paint
+// flow / material picker writes preset refs or full `MaterialSchema`
+// objects on top of this; until then both roles render `#ffffff`.
+const WHITE_MATERIAL = {
+    properties: {
+        color: '#ffffff',
+        roughness: 0.85,
+        metalness: 0,
+        opacity: 1,
+        transparent: false,
+        side: 'front',
+    },
+};
+/**
+ * Chimney — a vertical masonry stack hosted on a roof segment.
+ *
+ * Three-checkbox model: `def.renderer` (custom — segment-aware
+ * geometry from `useScene`, body height derived from
+ * `segment.wallHeight + roofHeight + heightAboveRidge`), no `geometry`,
+ * no `system`.
+ *
+ * **Option C scope**: chimney ships in the registry shape with solid
+ * geometry. CSG-driven decoration (cap flue holes, body cavity,
+ * panels, bands) is preserved in the schema but not rendered yet —
+ * those re-light when roof-segment migrates to Stage B and introduces
+ * a `roofCutout` capability the parent segment can read.
+ */
+export const chimneyDefinition = {
+    kind: 'chimney',
+    schemaVersion: 1,
+    schema: ChimneyNode,
+    category: 'structure',
+    surfaceRole: 'wall',
+    defaults: () => {
+        const stub = ChimneyNodeSchema.parse({
+            id: 'chimney_default',
+            type: 'chimney',
+            material: WHITE_MATERIAL,
+            topMaterial: WHITE_MATERIAL,
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Dirty marks
+        // cascade to the host segment's parent roof so its merged shell
+        // re-renders. No `buildCut` — the chimney does its own self-trim
+        // via `trimChimneyBodyAgainstRoof`; the host roof shell stays solid
+        // underneath.
+        roofAccessory: {},
+        // Paint dispatch for the body / top surface split. The editor's
+        // selection-manager routes paint hover / click / preview through
+        // this entry rather than carrying a kind-name arm.
+        paint: chimneyPaint,
+    },
+    affordanceTools: {
+        // Drag-to-place tool for duplicate + move. Reuses the placement
+        // ghost preview but seeds it from the moving (cloned) node so the
+        // duplicate keeps the source's body shape, materials, panels, etc.
+        move: () => import('./move-tool'),
+    },
+    parametrics: chimneyParametrics,
+    handles: chimneyHandles,
+    floorplan: buildChimneyFloorplan,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Left click', label: 'Place chimney on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Chimney',
+        description: 'Vertical masonry stack on a roof segment.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 122,
+    },
+    mcp: {
+        description: 'A chimney on a roof segment. Square or round body; optional shoulder taper; sloped/flat/stepped cap; up to 4 protruding flues; optional cricket on the up-slope face.',
+    },
+};

package/dist/chimney/floorplan.d.ts

@@ -0,0 +1,17 @@
+import type { ChimneyNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+/**
+ * Floor-plan builder for a chimney. A chimney is a masonry stack hosted on
+ * a roof segment. Seen from above it reads as its crown/cap footprint with
+ * the body shaft nested inside (the cap overhangs the body) and the flue
+ * openings poking out the top.
+ *
+ * Coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → chimney). The chimney's `position` is
+ * segment-local (X = width axis, Z = depth axis; Y is ignored — the 3D
+ * renderer anchors it to the slope). `rotation` is yaw. We compose with
+ * the floor-plan's negated-rotation convention (see
+ * `buildRoofSegmentFloorplan`). Unlike the gutter there's no eave/overhang
+ * offset — a chimney sits at its own footprint, not on the drip edge.
+ */
+export declare function buildChimneyFloorplan(node: ChimneyNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/chimney/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,WAAW,EACX,iBAAiB,EAEjB,eAAe,EAGhB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAqL1B"}

package/dist/chimney/floorplan.js

@@ -0,0 +1,190 @@
+import { flueXPositions } from './geometry';
+/**
+ * Floor-plan builder for a chimney. A chimney is a masonry stack hosted on
+ * a roof segment. Seen from above it reads as its crown/cap footprint with
+ * the body shaft nested inside (the cap overhangs the body) and the flue
+ * openings poking out the top.
+ *
+ * Coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → chimney). The chimney's `position` is
+ * segment-local (X = width axis, Z = depth axis; Y is ignored — the 3D
+ * renderer anchors it to the slope). `rotation` is yaw. We compose with
+ * the floor-plan's negated-rotation convention (see
+ * `buildRoofSegmentFloorplan`). Unlike the gutter there's no eave/overhang
+ * offset — a chimney sits at its own footprint, not on the drip edge.
+ */
+export function buildChimneyFloorplan(node, ctx) {
+    const segment = ctx.parent;
+    if (segment?.type !== 'roof-segment')
+        return null;
+    const roofId = segment.parentId;
+    const roof = roofId ? ctx.resolve(roofId) : undefined;
+    if (roof?.type !== 'roof')
+        return null;
+    // Compose roof → segment → chimney in plan coords. Each rotation is
+    // negated so SVG's y-down CW matches Three.js' top-down CCW.
+    const cosR = Math.cos(-roof.rotation);
+    const sinR = Math.sin(-roof.rotation);
+    const segCx = roof.position[0] + segment.position[0] * cosR - segment.position[2] * sinR;
+    const segCz = roof.position[2] + segment.position[0] * sinR + segment.position[2] * cosR;
+    const segRot = -(roof.rotation + segment.rotation);
+    const cosS = Math.cos(segRot);
+    const sinS = Math.sin(segRot);
+    const cx = segCx + node.position[0] * cosS - node.position[2] * sinS;
+    const cz = segCz + node.position[0] * sinS + node.position[2] * cosS;
+    const rot = -(roof.rotation + segment.rotation + node.rotation);
+    const cos = Math.cos(rot);
+    const sin = Math.sin(rot);
+    const toPlan = (lx, lz) => [
+        cx + lx * cos - lz * sin,
+        cz + lx * sin + lz * cos,
+    ];
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const isHovered = view?.hovered ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    // Masonry — warm stone grey, accent on select, light blue on hover.
+    const baseInk = '#44403c';
+    const stroke = showSelectedChrome && palette
+        ? palette.selectedStroke
+        : isHovered && palette
+            ? palette.wallHoverStroke
+            : baseInk;
+    const fill = showSelectedChrome ? '#fed7aa' : '#d6d3d1';
+    const fillOpacity = showSelectedChrome ? 0.55 : 0.6;
+    const lineWidth = showSelectedChrome ? 0.03 : 0.022;
+    const isRound = node.bodyShape === 'round';
+    const halfW = Math.max(node.width, 0.05) / 2;
+    // Round bodies use `width` as the diameter and ignore `depth`.
+    const halfD = isRound ? halfW : Math.max(node.depth, 0.05) / 2;
+    const hasCap = node.cap && node.capShape !== 'none';
+    const overhang = hasCap ? Math.max(node.capOverhang, 0) : 0;
+    const capHalfW = halfW + overhang;
+    const capHalfD = halfD + overhang;
+    const showBodyInset = hasCap && overhang > 0.001;
+    const children = [];
+    if (isRound) {
+        const c = toPlan(0, 0);
+        // Transparent hit-target across the crown footprint.
+        children.push({
+            kind: 'circle',
+            cx: c[0],
+            cy: c[1],
+            r: capHalfW,
+            fill: stroke,
+            fillOpacity: 0,
+            stroke: 'none',
+            strokeWidth: 0,
+            pointerEvents: 'all',
+        });
+        // Crown / outer body footprint, filled.
+        children.push({
+            kind: 'circle',
+            cx: c[0],
+            cy: c[1],
+            r: capHalfW,
+            fill,
+            fillOpacity,
+            stroke,
+            strokeWidth: lineWidth,
+            pointerEvents: 'none',
+        });
+        // Body shaft inside the cap overhang.
+        if (showBodyInset) {
+            children.push({
+                kind: 'circle',
+                cx: c[0],
+                cy: c[1],
+                r: halfW,
+                fill: 'none',
+                stroke,
+                strokeWidth: lineWidth * 0.8,
+                strokeOpacity: 0.7,
+                pointerEvents: 'none',
+            });
+        }
+    }
+    else {
+        const capCorners = [
+            toPlan(-capHalfW, -capHalfD),
+            toPlan(capHalfW, -capHalfD),
+            toPlan(capHalfW, capHalfD),
+            toPlan(-capHalfW, capHalfD),
+        ];
+        children.push({
+            kind: 'polygon',
+            points: capCorners,
+            fill: stroke,
+            fillOpacity: 0,
+            stroke: 'none',
+            strokeWidth: 0,
+            pointerEvents: 'all',
+        });
+        children.push({
+            kind: 'polygon',
+            points: capCorners,
+            fill,
+            fillOpacity,
+            stroke,
+            strokeWidth: lineWidth,
+            strokeLinejoin: 'miter',
+            pointerEvents: 'none',
+        });
+        if (showBodyInset) {
+            children.push({
+                kind: 'polygon',
+                points: [
+                    toPlan(-halfW, -halfD),
+                    toPlan(halfW, -halfD),
+                    toPlan(halfW, halfD),
+                    toPlan(-halfW, halfD),
+                ],
+                fill: 'none',
+                stroke,
+                strokeWidth: lineWidth * 0.8,
+                strokeOpacity: 0.7,
+                strokeLinejoin: 'miter',
+                pointerEvents: 'none',
+            });
+        }
+    }
+    // Flue openings poking out the crown — drawn along the chimney's local X
+    // at z = 0, matching `flueXPositions` (the same layout the 3D pots use).
+    // Round or square per `flueShape`. Hollow so they read as openings.
+    const flueCount = Math.max(0, Math.min(4, node.flueCount));
+    if (flueCount > 0) {
+        const d = Math.max(0.02, node.flueDiameter);
+        const r = d / 2;
+        const xs = flueXPositions(flueCount, node.width, d, node.flueSpacing);
+        const flueStroke = showSelectedChrome && palette ? palette.selectedStroke : '#292524';
+        for (const fx of xs) {
+            if (node.flueShape === 'square') {
+                children.push({
+                    kind: 'polygon',
+                    points: [toPlan(fx - r, -r), toPlan(fx + r, -r), toPlan(fx + r, r), toPlan(fx - r, r)],
+                    fill: 'none',
+                    stroke: flueStroke,
+                    strokeWidth: lineWidth * 0.8,
+                    strokeLinejoin: 'miter',
+                    pointerEvents: 'none',
+                });
+            }
+            else {
+                const c = toPlan(fx, 0);
+                children.push({
+                    kind: 'circle',
+                    cx: c[0],
+                    cy: c[1],
+                    r,
+                    fill: 'none',
+                    stroke: flueStroke,
+                    strokeWidth: lineWidth * 0.8,
+                    pointerEvents: 'none',
+                });
+            }
+        }
+    }
+    return { kind: 'group', children };
+}

package/dist/chimney/geometry.d.ts

@@ -0,0 +1,29 @@
+import { type ChimneyNode, type RoofSegmentNode } from '@pascal-app/core';
+import * as THREE from 'three';
+/**
+ * Pure chimney geometry builder. Returns body, cap, flues, and cricket
+ * as separate BufferGeometries so each can carry its own material
+ * (body/top split mirrors the schema's `material` vs `topMaterial`).
+ *
+ * **Option C scope** (see commit message): no CSG. The chimney body
+ * intersects the roof at the deck line; the cap is solid (no flue
+ * holes carved); the body has no hollow shaft cavity; flues are solid
+ * cylinders/boxes protruding from the cap. Decorative bands and inset
+ * panels are no-op on this builder until roof-segment migrates to
+ * Stage B and a `roofCutout` capability lets the parent segment own
+ * its own boolean operations.
+ *
+ * Pure: no React, no scene access, no store mutation. Takes the
+ * segment as a second argument so the body height can be derived from
+ * the segment's pitch — analogous to `door`'s `ctx.parent` access.
+ */
+export type ChimneyGeometry = {
+    body: THREE.BufferGeometry;
+    cap: THREE.BufferGeometry | null;
+    flues: THREE.BufferGeometry | null;
+    cricket: THREE.BufferGeometry | null;
+    bands: THREE.BufferGeometry | null;
+};
+export declare function buildChimneyGeometry(node: ChimneyNode, segment: RoofSegmentNode): ChimneyGeometry;
+export declare function flueXPositions(count: number, chimneyWidth: number, flueDiameter: number, spacing?: number): number[];
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/chimney/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAuB,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAC9F,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,KAAK,CAAC,cAAc,CAAA;IAC1B,GAAG,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,CAAA;IAChC,KAAK,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,CAAA;IAClC,OAAO,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,CAAA;IACpC,KAAK,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,CAAA;CACnC,CAAA;AAwCD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,GAAG,eAAe,CAmCjG;AAqJD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,OAAO,SAAI,GACV,MAAM,EAAE,CAUV"}