@pascal-app/nodes 0.1.1

package/dist/turbine-vent/floorplan.js

@@ -0,0 +1,111 @@
+/**
+ * Floor-plan builder for a turbine vent — seen from above it reads as the
+ * round flange flashing with the head circle inside and short radial ticks
+ * suggesting the vanes.
+ *
+ * Coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → vent), same as the box-vent builder. `position`
+ * is segment-local; `rotation` is yaw; rotations are negated for the floor
+ * plan's y-down convention.
+ */
+export function buildTurbineVentFloorplan(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;
+    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;
+    // Painted-metal vent — cool grey, accent on select, light blue on hover.
+    const baseInk = '#475569';
+    const stroke = showSelectedChrome && palette
+        ? palette.selectedStroke
+        : isHovered && palette
+            ? palette.wallHoverStroke
+            : baseInk;
+    const fill = showSelectedChrome ? '#fed7aa' : '#dbe1e8';
+    const fillOpacity = showSelectedChrome ? 0.55 : 0.7;
+    const lineWidth = showSelectedChrome ? 0.03 : 0.02;
+    const ro = Math.max(node.diameter, 0.05) / 2;
+    const flangeR = ro + Math.max(0, node.baseOverhang ?? 0.05);
+    const circle = (r) => {
+        const pts = [];
+        const N = 32;
+        for (let i = 0; i < N; i++) {
+            const a = (i / N) * Math.PI * 2;
+            pts.push(toPlan(r * Math.cos(a), r * Math.sin(a)));
+        }
+        return pts;
+    };
+    const children = [];
+    // Flange footprint — the hit target + outer ring.
+    const outer = circle(flangeR);
+    children.push({
+        kind: 'polygon',
+        points: outer,
+        fill: stroke,
+        fillOpacity: 0,
+        stroke: 'none',
+        strokeWidth: 0,
+        pointerEvents: 'all',
+    });
+    children.push({
+        kind: 'polygon',
+        points: outer,
+        fill,
+        fillOpacity,
+        stroke,
+        strokeWidth: lineWidth,
+        pointerEvents: 'none',
+    });
+    // Head circle.
+    children.push({
+        kind: 'polygon',
+        points: circle(ro),
+        fill: 'none',
+        stroke,
+        strokeWidth: lineWidth * 0.8,
+        strokeOpacity: 0.7,
+        pointerEvents: 'none',
+    });
+    // Radial vane ticks from the hub out to the head circle.
+    const vanes = Math.max(6, Math.min(36, Math.round(node.vaneCount ?? 20)));
+    const hubR = ro * 0.4;
+    for (let i = 0; i < vanes; i++) {
+        const a = (i / vanes) * Math.PI * 2;
+        children.push({
+            kind: 'polyline',
+            points: [
+                toPlan(hubR * Math.cos(a), hubR * Math.sin(a)),
+                toPlan(ro * Math.cos(a), ro * Math.sin(a)),
+            ],
+            stroke,
+            strokeWidth: lineWidth * 0.6,
+            strokeOpacity: 0.5,
+            pointerEvents: 'none',
+        });
+    }
+    return { kind: 'group', children };
+}

package/dist/turbine-vent/geometry.d.ts

@@ -0,0 +1,6 @@
+import type { TurbineVentNode } from '@pascal-app/core';
+import * as THREE from 'three';
+export declare function buildTurbineVentBase(node: TurbineVentNode): THREE.BufferGeometry;
+export declare function buildTurbineVentHead(node: TurbineVentNode): THREE.BufferGeometry;
+export declare function buildTurbineVentGeometry(node: TurbineVentNode): THREE.BufferGeometry;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/turbine-vent/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAoD9B,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAiBhF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAqChF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CASpF"}

package/dist/turbine-vent/geometry.js

@@ -0,0 +1,284 @@
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+function resolveDims(node) {
+    const ro = Math.max(0.05, node.diameter / 2);
+    const height = Math.max(0.12, node.height);
+    const neckH = Math.max(0.02, Math.min(node.neckHeight ?? 0.09, height * 0.5));
+    const headH = height - neckH;
+    const throatR = ro * 0.82;
+    const flangeR = ro + Math.max(0, node.baseOverhang ?? 0.05);
+    const vanes = Math.max(6, Math.min(36, Math.round(node.vaneCount ?? 20)));
+    // Radial blade thickness — scales gently with size so wide turbines
+    // don't read paper-thin.
+    const thk = Math.max(0.004, ro * 0.03);
+    return { ro, neckH, headH, throatR, flangeR, vanes, thk };
+}
+// ─── Public builders ─────────────────────────────────────────────────
+export function buildTurbineVentBase(node) {
+    const d = resolveDims(node);
+    const p = [];
+    const n = [];
+    const uv = [];
+    const flangeThk = Math.min(0.012, d.neckH * 0.5);
+    // Flange flashing — a thin disc the throat sits on.
+    cylinderWall(p, n, uv, d.flangeR, 0, flangeThk, 32);
+    disc(p, n, uv, d.flangeR, flangeThk, [0, 1, 0]); // flange top
+    disc(p, n, uv, d.flangeR, 0, [0, -1, 0]); // flange underside
+    // Throat — the tube the head rides on.
+    cylinderWall(p, n, uv, d.throatR, flangeThk, d.neckH, 28);
+    // Cap the throat top so you can't see down the tube past the head.
+    disc(p, n, uv, d.throatR, d.neckH, [0, 1, 0]);
+    return toGeometry(p, n, uv);
+}
+export function buildTurbineVentHead(node) {
+    const d = resolveDims(node);
+    const p = [];
+    const n = [];
+    const uv = [];
+    const hubR = d.ro * 0.55;
+    const rings = vaneRings(node, d);
+    const ringBottomY = rings[0].y;
+    // Lower hub — short cylinder closing the underside of the head over the
+    // throat, so the spinning head reads as solid from below.
+    cylinderWall(p, n, uv, hubR, 0, ringBottomY, 24);
+    disc(p, n, uv, hubR, 0, [0, -1, 0]);
+    // Vanes.
+    const dTheta = (Math.PI * 2) / d.vanes;
+    const dw = dTheta * 0.55;
+    const totalTwist = dTheta * 0.9;
+    buildVanes(p, n, uv, d.vanes, rings, dw, totalTwist, d.thk);
+    // Top cap + spindle knob.
+    const topRing = rings[rings.length - 1];
+    if (node.style === 'cylinder') {
+        // Straight barrel → flat disc lid with a slim rim.
+        const lidY = topRing.y;
+        cylinderWall(p, n, uv, topRing.r, lidY, lidY + d.headH * 0.04, 28);
+        disc(p, n, uv, topRing.r, lidY + d.headH * 0.04, [0, 1, 0]);
+        knob(p, n, uv, d.ro, lidY + d.headH * 0.04, d.headH);
+    }
+    else {
+        // Globe → domed lid for the spherical whirlybird silhouette.
+        const apexY = d.headH * 0.96;
+        dome(p, n, uv, topRing.r, topRing.y, apexY - topRing.y, 5, 24);
+        knob(p, n, uv, d.ro, apexY, d.headH);
+    }
+    return toGeometry(p, n, uv);
+}
+export function buildTurbineVentGeometry(node) {
+    const d = resolveDims(node);
+    const base = buildTurbineVentBase(node);
+    const head = buildTurbineVentHead(node);
+    head.translate(0, d.neckH, 0);
+    const merged = mergeGeometries([base, head], false);
+    base.dispose();
+    head.dispose();
+    return merged ?? buildTurbineVentBase(node);
+}
+// ─── Vane profile ────────────────────────────────────────────────────
+// The head's vanes are lofted between these rings (bottom → top). `globe`
+// bulges at the equator and narrows top + bottom; `cylinder` holds a
+// constant radius for a straight barrel.
+function vaneRings(node, d) {
+    if (node.style === 'cylinder') {
+        return [
+            { r: d.ro, y: d.headH * 0.04 },
+            { r: d.ro, y: d.headH * 0.85 },
+        ];
+    }
+    return [
+        { r: d.ro * 0.6, y: d.headH * 0.05 },
+        { r: d.ro, y: d.headH * 0.42 },
+        { r: d.ro * 0.58, y: d.headH * 0.72 },
+    ];
+}
+// Each vane is a thin, twisted shell lofted through `rings`: an outer and
+// inner surface joined by edge strips, plus bottom + top caps. The twist
+// from bottom to top is what reads as the scoop that catches the wind.
+function buildVanes(p, n, uv, count, rings, dw, totalTwist, thk) {
+    const y0 = rings[0].y;
+    const span = rings[rings.length - 1].y - y0 || 1;
+    const K = rings.length;
+    for (let i = 0; i < count; i++) {
+        const a0 = i * ((Math.PI * 2) / count);
+        const oLo = [];
+        const oHi = [];
+        const iLo = [];
+        const iHi = [];
+        for (let k = 0; k < K; k++) {
+            const ring = rings[k];
+            const t = (ring.y - y0) / span;
+            const tw = totalTwist * t;
+            const loA = a0 + tw;
+            const hiA = a0 + tw + dw;
+            oLo.push(polar(loA, ring.r, ring.y));
+            oHi.push(polar(hiA, ring.r, ring.y));
+            iLo.push(polar(loA, ring.r - thk, ring.y));
+            iHi.push(polar(hiA, ring.r - thk, ring.y));
+        }
+        const midA = a0 + totalTwist * 0.5 + dw * 0.5;
+        const out = [Math.cos(midA), 0, Math.sin(midA)];
+        const inward = [-out[0], 0, -out[2]];
+        // Tangential directions for the two angular edges.
+        const left = [Math.sin(midA), 0, -Math.cos(midA)];
+        const right = [-left[0], 0, -left[2]];
+        for (let k = 0; k < K - 1; k++) {
+            // Outer + inner faces.
+            pushQuad(p, n, uv, oLo[k], oHi[k], oHi[k + 1], oLo[k + 1], out);
+            pushQuad(p, n, uv, iLo[k], iHi[k], iHi[k + 1], iLo[k + 1], inward);
+            // Angular edges (lo side / hi side).
+            pushQuad(p, n, uv, oLo[k], iLo[k], iLo[k + 1], oLo[k + 1], left);
+            pushQuad(p, n, uv, oHi[k], iHi[k], iHi[k + 1], oHi[k + 1], right);
+        }
+        // Bottom + top caps.
+        pushQuad(p, n, uv, oLo[0], oHi[0], iHi[0], iLo[0], [0, -1, 0]);
+        pushQuad(p, n, uv, oLo[K - 1], oHi[K - 1], iHi[K - 1], iLo[K - 1], [0, 1, 0]);
+    }
+}
+// ─── Primitive builders ──────────────────────────────────────────────
+function cylinderWall(p, n, uv, r, y0, y1, segs) {
+    for (let i = 0; i < segs; i++) {
+        const a = (i / segs) * Math.PI * 2;
+        const b = ((i + 1) / segs) * Math.PI * 2;
+        const ca = Math.cos(a);
+        const sa = Math.sin(a);
+        const cb = Math.cos(b);
+        const sb = Math.sin(b);
+        const out = [Math.cos((a + b) / 2), 0, Math.sin((a + b) / 2)];
+        pushQuad(p, n, uv, [r * ca, y0, r * sa], [r * cb, y0, r * sb], [r * cb, y1, r * sb], [r * ca, y1, r * sa], out);
+    }
+}
+function disc(p, n, uv, r, y, hint, segs = 32) {
+    const center = new THREE.Vector3(0, y, 0);
+    for (let i = 0; i < segs; i++) {
+        const a = (i / segs) * Math.PI * 2;
+        const b = ((i + 1) / segs) * Math.PI * 2;
+        pushTri(p, n, uv, center, polar(a, r, y), polar(b, r, y), hint);
+    }
+}
+// Half-ellipsoid cap: base radius `rb` at `y0`, apex `hd` above it.
+function dome(p, n, uv, rb, y0, hd, lat, lng) {
+    const grid = [];
+    for (let i = 0; i <= lat; i++) {
+        const phi = (Math.PI / 2) * (i / lat);
+        const r = rb * Math.cos(phi);
+        const y = y0 + hd * Math.sin(phi);
+        const row = [];
+        for (let j = 0; j <= lng; j++) {
+            const theta = (j / lng) * Math.PI * 2;
+            row.push(new THREE.Vector3(r * Math.cos(theta), y, r * Math.sin(theta)));
+        }
+        grid.push(row);
+    }
+    const center = new THREE.Vector3(0, y0, 0);
+    for (let i = 0; i < lat; i++) {
+        for (let j = 0; j < lng; j++) {
+            const a = grid[i][j];
+            const b = grid[i][j + 1];
+            const c = grid[i + 1][j + 1];
+            const d = grid[i + 1][j];
+            const mid = new THREE.Vector3().add(a).add(b).add(c).add(d).multiplyScalar(0.25);
+            const hint = mid.clone().sub(center).normalize();
+            pushQuad(p, n, uv, a, b, c, d, [hint.x, hint.y, hint.z]);
+        }
+    }
+}
+// Small spindle knob at the top centre.
+function knob(p, n, uv, ro, y0, headH) {
+    const kr = ro * 0.12;
+    const kh = headH * 0.06;
+    cylinderWall(p, n, uv, kr, y0, y0 + kh, 12);
+    dome(p, n, uv, kr, y0 + kh, kr * 0.9, 3, 12);
+}
+// ─── Geometry plumbing ───────────────────────────────────────────────
+function polar(angle, r, y) {
+    return new THREE.Vector3(r * Math.cos(angle), y, r * Math.sin(angle));
+}
+function v(point) {
+    if (Array.isArray(point))
+        return [point[0], point[1], point[2]];
+    return [point.x, point.y, point.z];
+}
+// Winding-safe quad: triangulates (a,b,c,d) and orients both triangles so
+// their shared flat normal points toward `hint`. Front faces are then
+// always visible from the intended side under a FrontSide material — no
+// hand-traced winding to get wrong. UVs are dimension-based so painted
+// presets tile at a consistent world density across the body and vanes.
+function pushQuad(positions, normals, uvs, ap, bp, cp, dp, hint) {
+    const a = v(ap);
+    const b = v(bp);
+    const c = v(cp);
+    const d = v(dp);
+    // Normal of triangle (a, c, b): (c-a) × (b-a).
+    let nx = (c[1] - a[1]) * (b[2] - a[2]) - (c[2] - a[2]) * (b[1] - a[1]);
+    let ny = (c[2] - a[2]) * (b[0] - a[0]) - (c[0] - a[0]) * (b[2] - a[2]);
+    let nz = (c[0] - a[0]) * (b[1] - a[1]) - (c[1] - a[1]) * (b[0] - a[0]);
+    const flip = nx * hint[0] + ny * hint[1] + nz * hint[2] < 0;
+    if (flip) {
+        nx = -nx;
+        ny = -ny;
+        nz = -nz;
+    }
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    nx /= len;
+    ny /= len;
+    nz /= len;
+    const abx = b[0] - a[0];
+    const aby = b[1] - a[1];
+    const abz = b[2] - a[2];
+    const adx = d[0] - a[0];
+    const ady = d[1] - a[1];
+    const adz = d[2] - a[2];
+    const u = Math.sqrt(abx * abx + aby * aby + abz * abz);
+    const vv = Math.sqrt(adx * adx + ady * ady + adz * adz);
+    if (flip) {
+        // Reversed winding: (a,b,c) + (a,c,d).
+        positions.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+        uvs.push(0, 0, u, 0, u, vv);
+        positions.push(a[0], a[1], a[2], c[0], c[1], c[2], d[0], d[1], d[2]);
+        uvs.push(0, 0, u, vv, 0, vv);
+    }
+    else {
+        // Default winding: (a,c,b) + (a,d,c).
+        positions.push(a[0], a[1], a[2], c[0], c[1], c[2], b[0], b[1], b[2]);
+        uvs.push(0, 0, u, vv, u, 0);
+        positions.push(a[0], a[1], a[2], d[0], d[1], d[2], c[0], c[1], c[2]);
+        uvs.push(0, 0, 0, vv, u, vv);
+    }
+    for (let i = 0; i < 6; i++)
+        normals.push(nx, ny, nz);
+}
+function pushTri(positions, normals, uvs, ap, bp, cp, hint) {
+    const a = v(ap);
+    const b = v(bp);
+    const c = v(cp);
+    let nx = (b[1] - a[1]) * (c[2] - a[2]) - (b[2] - a[2]) * (c[1] - a[1]);
+    let ny = (b[2] - a[2]) * (c[0] - a[0]) - (b[0] - a[0]) * (c[2] - a[2]);
+    let nz = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+    const flip = nx * hint[0] + ny * hint[1] + nz * hint[2] < 0;
+    if (flip) {
+        nx = -nx;
+        ny = -ny;
+        nz = -nz;
+    }
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    nx /= len;
+    ny /= len;
+    nz /= len;
+    if (flip) {
+        positions.push(a[0], a[1], a[2], c[0], c[1], c[2], b[0], b[1], b[2]);
+    }
+    else {
+        positions.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+    }
+    uvs.push(0, 0, 1, 0, 0, 1);
+    for (let i = 0; i < 3; i++)
+        normals.push(nx, ny, nz);
+}
+function toGeometry(positions, normals, uvs) {
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    geo.computeBoundingSphere();
+    return geo;
+}

package/dist/turbine-vent/index.d.ts

@@ -0,0 +1,4 @@
+export { turbineVentDefinition } from './definition';
+export { buildTurbineVentGeometry } from './geometry';
+export { TurbineVentNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/turbine-vent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA"}

package/dist/turbine-vent/index.js

@@ -0,0 +1,3 @@
+export { turbineVentDefinition } from './definition';
+export { buildTurbineVentGeometry } from './geometry';
+export { TurbineVentNode } from './schema';

package/dist/turbine-vent/move-tool.d.ts

@@ -0,0 +1,13 @@
+import { type TurbineVentNode } from '@pascal-app/core';
+/**
+ * Turbine-vent move tool. Mirrors the box-vent move flow: the original
+ * mesh hides during the drag, a ghost tracks the cursor with the correct
+ * slope tilt + segment yaw, and the click updates the node's position +
+ * parent segment in one undoable step (reparenting between segments when
+ * needed). Cancel restores the original transform, or deletes a
+ * freshly-cloned vent (`metadata.isNew`).
+ */
+export default function MoveTurbineVentTool({ node }: {
+    node: TurbineVentNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/turbine-vent/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,sCAwN9E"}

package/dist/turbine-vent/move-tool.js

@@ -0,0 +1,207 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useCallback, useEffect, useState } from 'react';
+import * as THREE from 'three';
+import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag';
+import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfaceNodePlacementGuides, snapRoofSurfaceNodeTarget, } from '../shared/roof-surface-placement-guides';
+import TurbineVentPreview from './preview';
+/**
+ * Turbine-vent move tool. Mirrors the box-vent move flow: the original
+ * mesh hides during the drag, a ghost tracks the cursor with the correct
+ * slope tilt + segment yaw, and the click updates the node's position +
+ * parent segment in one undoable step (reparenting between segments when
+ * needed). Cancel restores the original transform, or deletes a
+ * freshly-cloned vent (`metadata.isNew`).
+ */
+export default function MoveTurbineVentTool({ node }) {
+    const exitMoveMode = useCallback(() => {
+        useEditor.getState().setMovingNode(null);
+    }, []);
+    const [previewPos, setPreviewPos] = useState(null);
+    const [previewSurfaceQuat, setPreviewSurfaceQuat] = useState(null);
+    const [previewYaw, setPreviewYaw] = useState(0);
+    useEffect(() => {
+        useScene.temporal.getState().pause();
+        const original = {
+            position: [...node.position],
+            rotation: node.rotation ?? 0,
+            roofSegmentId: node.roofSegmentId,
+            parentId: node.parentId,
+            metadata: node.metadata,
+        };
+        const meta = typeof node.metadata === 'object' && node.metadata !== null
+            ? node.metadata
+            : {};
+        const isNew = !!meta.isNew;
+        const ventObj = sceneRegistry.nodes.get(node.id);
+        if (ventObj)
+            ventObj.visible = false;
+        let lastSnap = null;
+        let lastTarget = null;
+        let committed = false;
+        const roofDrag = createRelativeRoofDrag(original);
+        const clearTarget = () => {
+            lastTarget = null;
+            lastSnap = null;
+            setPreviewPos(null);
+            setPreviewSurfaceQuat(null);
+            clearRoofSurfacePlacementGuides();
+        };
+        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 updatePreview = (event) => {
+            const target = resolveSnappedTarget(event);
+            if (!target) {
+                clearTarget();
+                return;
+            }
+            lastTarget = target;
+            const sx = Math.round(target.localX * 20) / 20;
+            const sz = Math.round(target.localZ * 20) / 20;
+            if (event.nativeEvent?.shiftKey !== true &&
+                (!lastSnap || lastSnap[0] !== sx || lastSnap[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnap = [sx, sz];
+            }
+            const normal = getAnalyticalNormal(target.localX, target.localZ, target.segment);
+            setPreviewSurfaceQuat(surfaceQuatFromNormal(normal, new THREE.Quaternion()));
+            setPreviewYaw((event.node.rotation ?? 0) + (target.segment.rotation ?? 0));
+            setPreviewPos(roofSegmentLocalToBuildingLocal(target.segment.id, [
+                target.localX,
+                target.localY,
+                target.localZ,
+            ]));
+            publishRoofSurfaceNodePlacementGuides({
+                roof: event.node,
+                segment: target.segment,
+                center: [target.localX, target.localY, target.localZ],
+                node,
+            });
+            event.stopPropagation();
+        };
+        const onRoofClick = (event) => {
+            if (committed)
+                return;
+            const target = lastTarget ?? resolveSnappedTarget(event);
+            if (!target)
+                return;
+            committed = true;
+            const targetSegmentId = target.segment.id;
+            const st = useScene.getState();
+            const prevSegmentId = original.roofSegmentId;
+            if (prevSegmentId && prevSegmentId !== targetSegmentId) {
+                const oldSeg = st.nodes[prevSegmentId];
+                if (oldSeg) {
+                    st.updateNode(prevSegmentId, {
+                        children: (oldSeg.children ?? []).filter((id) => id !== node.id),
+                    });
+                }
+                const newSeg = st.nodes[targetSegmentId];
+                if (newSeg && !(newSeg.children ?? []).includes(node.id)) {
+                    st.updateNode(targetSegmentId, {
+                        children: [...(newSeg.children ?? []), node.id],
+                    });
+                }
+                st.dirtyNodes.add(prevSegmentId);
+            }
+            useScene.temporal.getState().resume();
+            st.updateNode(node.id, {
+                roofSegmentId: targetSegmentId,
+                parentId: targetSegmentId,
+                position: [target.localX, target.localY, target.localZ],
+                rotation: original.rotation,
+                visible: true,
+                metadata: {},
+            });
+            useScene.temporal.getState().pause();
+            st.dirtyNodes.add(targetSegmentId);
+            st.dirtyNodes.add(node.id);
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            exitMoveMode();
+            event.stopPropagation();
+        };
+        const onCancel = () => {
+            if (isNew) {
+                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();
+                exitMoveMode();
+                return;
+            }
+            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();
+            exitMoveMode();
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            if (!lastTarget)
+                return;
+            onRoofClick({
+                nativeEvent: event,
+                stopPropagation: () => event.stopPropagation(),
+            });
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onRoofClick);
+        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', onRoofClick);
+            emitter.off('roof:leave', clearTarget);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            clearRoofSurfacePlacementGuides();
+            useScene.temporal.getState().resume();
+        };
+    }, [exitMoveMode, node]);
+    if (!(previewPos && previewSurfaceQuat))
+        return null;
+    return (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx("group", { quaternion: previewSurfaceQuat, children: _jsx(TurbineVentPreview, { node: node }) }) }) }));
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Inspector panel for a placed turbine vent. Exposes style + dimensions +
+ * spin speed plus Move / Duplicate / Delete wired into the same
+ * ghost-preview drag flow the placement tool uses (see `./move-tool.tsx`).
+ * Mirrors the box-vent panel.
+ */
+export default function TurbineVentPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/panel.tsx"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCA6SvC"}