@pascal-app/nodes 0.1.1

package/dist/elevator/system.js

@@ -0,0 +1,13 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ElevatorOpeningSystem, ElevatorRuntimeSystem } from '@pascal-app/core';
+import { ElevatorInteractionSystem } from '@pascal-app/viewer';
+/**
+ * Composite system for elevator — bundles three per-frame systems:
+ * `ElevatorRuntimeSystem` (cab travel + door state machine),
+ * `ElevatorInteractionSystem` (call buttons / cab UI), and
+ * `ElevatorOpeningSystem` (wall + slab cutout cascade).
+ */
+export default function ElevatorSystem() {
+    return (_jsxs(_Fragment, { children: [_jsx(ElevatorRuntimeSystem, {}), _jsx(ElevatorInteractionSystem, {}), _jsx(ElevatorOpeningSystem, {})] }));
+}

package/dist/eyebrow-vent/definition.d.ts

@@ -0,0 +1,12 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { EyebrowVentNode } from './schema';
+/**
+ * Eyebrow vent — a low, curved lens-shaped hood with a louvered front that
+ * sweeps out of a roof slope. Parented to a `roof-segment`; position is
+ * segment-local; rotation rotates it around the segment's vertical axis after
+ * the slope tilt is applied. Same composition as the box vent / cupola (custom
+ * renderer, pure geometry builder, no system) — see box-vent's definition for
+ * the rationale on why roof accessories need a custom renderer.
+ */
+export declare const eyebrowVentDefinition: NodeDefinition<typeof EyebrowVentNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/eyebrow-vent/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA+F1C;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA2DxE,CAAA"}

package/dist/eyebrow-vent/definition.js

@@ -0,0 +1,150 @@
+import { EyebrowVentNode as EyebrowVentNodeSchema, } from '@pascal-app/core';
+import { surfacePaintCapability } from '../shared/surface-paint';
+import { buildEyebrowVentFloorplan } from './floorplan';
+import { eyebrowVentParametrics } from './parametrics';
+import { EyebrowVentNode } from './schema';
+const SIDE_HANDLE_OFFSET = 0.3;
+const HEIGHT_HANDLE_OFFSET = 0.2;
+// Snug to the vent corner so the rotate icon stays close to the item.
+const ROTATE_CORNER_OFFSET = 0.12;
+const MIN_WIDTH = 0.4;
+const MIN_DEPTH = 0.2;
+const MIN_HEIGHT = 0.08;
+// Mid-Y of the arch (its tallest point is `height`), used to seat the side /
+// rotate chevrons against the body and centre the rotate ring.
+function getBodyMidY(n) {
+    return Math.max(0.001, n.height) / 2;
+}
+// Width (span) and depth grow symmetrically from the centre — eyebrow vents
+// are placed by their centre — so a single centred chevron per axis.
+function eyebrowWidthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'center',
+        min: MIN_WIDTH,
+        currentValue: (n) => n.width,
+        apply: (_n, newValue) => ({ width: Math.max(MIN_WIDTH, newValue) }),
+        placement: {
+            position: (n) => [n.width / 2 + SIDE_HANDLE_OFFSET, getBodyMidY(n), 0],
+        },
+    };
+}
+function eyebrowDepthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'center',
+        min: MIN_DEPTH,
+        currentValue: (n) => n.depth,
+        apply: (_n, newValue) => ({ depth: Math.max(MIN_DEPTH, newValue) }),
+        placement: {
+            position: (n) => [0, getBodyMidY(n), n.depth / 2 + SIDE_HANDLE_OFFSET],
+        },
+    };
+}
+function eyebrowHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_HEIGHT,
+        currentValue: (n) => n.height,
+        apply: (_n, newValue) => ({ height: Math.max(MIN_HEIGHT, newValue) }),
+        placement: {
+            position: (n) => [0, Math.max(n.height, MIN_HEIGHT) + HEIGHT_HANDLE_OFFSET, 0],
+        },
+    };
+}
+function eyebrowRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: (n) => [
+                n.width / 2 + ROTATE_CORNER_OFFSET,
+                getBodyMidY(n),
+                n.depth / 2 + ROTATE_CORNER_OFFSET,
+            ],
+            rotationY: () => -Math.PI / 4,
+        },
+        // Guide ring centred on the vent, sized to pass through the corner icon so
+        // the icon rides the ring — matches cupola / solar-panel.
+        decoration: {
+            kind: 'ring',
+            radius: (n) => Math.hypot(n.width / 2 + ROTATE_CORNER_OFFSET, n.depth / 2 + ROTATE_CORNER_OFFSET),
+            y: (n) => getBodyMidY(n),
+        },
+    };
+}
+// `portal: 'grandparent'` on every handle — see box-vent's note. The vent
+// rides the roof→segment→node frame chain, so the handle rig must too, or the
+// handles (and rotate arc) render offset from the vent.
+const eyebrowVentHandles = [
+    eyebrowWidthHandle(),
+    eyebrowDepthHandle(),
+    eyebrowHeightHandle(),
+    eyebrowRotateHandle(),
+].map((h) => ({ ...h, portal: 'grandparent' }));
+/**
+ * Eyebrow vent — a low, curved lens-shaped hood with a louvered front that
+ * sweeps out of a roof slope. Parented to a `roof-segment`; position is
+ * segment-local; rotation rotates it around the segment's vertical axis after
+ * the slope tilt is applied. Same composition as the box vent / cupola (custom
+ * renderer, pure geometry builder, no system) — see box-vent's definition for
+ * the rationale on why roof accessories need a custom renderer.
+ */
+export const eyebrowVentDefinition = {
+    kind: 'eyebrow-vent',
+    schemaVersion: 1,
+    schema: EyebrowVentNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = EyebrowVentNodeSchema.parse({
+            id: 'eyebrow-vent_default',
+            type: 'eyebrow-vent',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Single painted surface — registry-driven paint dispatch (see chimney).
+        paint: surfacePaintCapability,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the slope —
+        // no `buildCut`, just the dirty cascade so the parent roof's merged shell
+        // rebuilds when the vent moves / resizes.
+        roofAccessory: {},
+    },
+    parametrics: eyebrowVentParametrics,
+    handles: eyebrowVentHandles,
+    floorplan: buildEyebrowVentFloorplan,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    preview: () => import('./preview'),
+    tool: () => import('./tool'),
+    affordanceTools: {
+        move: () => import('./move-tool'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place eyebrow vent on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Eyebrow Vent',
+        description: 'Low curved lens-shaped roof vent with a louvered front.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 123,
+    },
+    mcp: {
+        description: 'A low curved eyebrow vent on a roof segment — a lens-shaped hood with an optional louvered front. Parametric width (span) / depth / height.',
+    },
+};

package/dist/eyebrow-vent/floorplan.d.ts

@@ -0,0 +1,9 @@
+import type { EyebrowVentNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+/**
+ * Floor-plan builder for an eyebrow vent — seen from above it reads as the
+ * lens (eye-shaped) footprint of the hood, with a faint centre seam. The
+ * coordinate frame mirrors the 3D transform stack (roof → roof-segment →
+ * vent), same as the box-vent / cupola builders.
+ */
+export declare function buildEyebrowVentFloorplan(node: EyebrowVentNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/eyebrow-vent/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,eAAe,EACf,iBAAiB,EAEjB,eAAe,EAGhB,MAAM,kBAAkB,CAAA;AAEzB;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAwF1B"}

package/dist/eyebrow-vent/floorplan.js

@@ -0,0 +1,86 @@
+/**
+ * Floor-plan builder for an eyebrow vent — seen from above it reads as the
+ * lens (eye-shaped) footprint of the hood, with a faint centre seam. The
+ * coordinate frame mirrors the 3D transform stack (roof → roof-segment →
+ * vent), same as the box-vent / cupola builders.
+ */
+export function buildEyebrowVentFloorplan(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;
+    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 hw = Math.max(node.width, 0.1) / 2;
+    const hd = Math.max(node.depth, 0.1) / 2;
+    const rect = (halfX, halfZ) => [
+        toPlan(-halfX, -halfZ),
+        toPlan(halfX, -halfZ),
+        toPlan(halfX, halfZ),
+        toPlan(-halfX, halfZ),
+    ];
+    const children = [];
+    // Hood footprint outline + hit target (no flashing plate).
+    const hood = rect(hw, hd);
+    children.push({
+        kind: 'polygon',
+        points: hood,
+        fill: stroke,
+        fillOpacity: 0,
+        stroke: 'none',
+        strokeWidth: 0,
+        pointerEvents: 'all',
+    });
+    children.push({
+        kind: 'polygon',
+        points: hood,
+        fill,
+        fillOpacity,
+        stroke,
+        strokeWidth: lineWidth,
+        strokeLinejoin: 'round',
+        pointerEvents: 'none',
+    });
+    // Front edge (the louvered opening faces +Z).
+    children.push({
+        kind: 'polyline',
+        points: [toPlan(-hw, hd), toPlan(hw, hd)],
+        stroke,
+        strokeWidth: lineWidth,
+        strokeOpacity: 0.9,
+        pointerEvents: 'none',
+    });
+    return { kind: 'group', children };
+}

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

@@ -0,0 +1,25 @@
+import type { EyebrowVentNode } from '@pascal-app/core';
+import * as THREE from 'three';
+/**
+ * Pure builder for the eyebrow-vent mesh. Three styles, all seated directly on
+ * the roof at y=0 and facing +Z (downslope):
+ *
+ *  - `scoop`      — a rounded louvered opening at the front that sweeps back
+ *                   and tapers to nothing (the classic dormer "eyebrow"). Front
+ *                   = a half-ellipse of horizontal louvers; the body is a lofted
+ *                   half-cone with a rounded nose.
+ *  - `half-round` — a D-shaped half-round vent: a constant half-ellipse cross
+ *                   section extruded a short depth, flat louvered front face,
+ *                   capped back, curved top.
+ *  - `slant-box`  — a low box with a slanted top (tall front, lower back) and a
+ *                   framed front face holding recessed louvers + a screen.
+ *
+ * Every face is emitted through a winding-safe oriented quad/tri, the louvers
+ * are extruded into solid slabs, and the whole mesh is double-sided at the end
+ * (see `doubleSide`) so it reads correctly from any angle.
+ *
+ * Pure: no React, no scene access, no store mutation. Safe for unit tests, the
+ * placement preview, and the move-tool ghost.
+ */
+export declare function buildEyebrowVentGeometry(node: EyebrowVentNode): THREE.BufferGeometry;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAoCpF"}

package/dist/eyebrow-vent/geometry.js

@@ -0,0 +1,313 @@
+import * as THREE from 'three';
+/**
+ * Pure builder for the eyebrow-vent mesh. Three styles, all seated directly on
+ * the roof at y=0 and facing +Z (downslope):
+ *
+ *  - `scoop`      — a rounded louvered opening at the front that sweeps back
+ *                   and tapers to nothing (the classic dormer "eyebrow"). Front
+ *                   = a half-ellipse of horizontal louvers; the body is a lofted
+ *                   half-cone with a rounded nose.
+ *  - `half-round` — a D-shaped half-round vent: a constant half-ellipse cross
+ *                   section extruded a short depth, flat louvered front face,
+ *                   capped back, curved top.
+ *  - `slant-box`  — a low box with a slanted top (tall front, lower back) and a
+ *                   framed front face holding recessed louvers + a screen.
+ *
+ * Every face is emitted through a winding-safe oriented quad/tri, the louvers
+ * are extruded into solid slabs, and the whole mesh is double-sided at the end
+ * (see `doubleSide`) so it reads correctly from any angle.
+ *
+ * Pure: no React, no scene access, no store mutation. Safe for unit tests, the
+ * placement preview, and the move-tool ghost.
+ */
+export function buildEyebrowVentGeometry(node) {
+    const w = Math.max(0.15, node.width);
+    const d = Math.max(0.15, node.depth);
+    const h = Math.max(0.06, node.height);
+    const slats = Math.max(0, Math.min(8, Math.round(node.louverCount ?? 3)));
+    // slant-box: the low rear edge as a fraction of the tall front edge.
+    const backRatio = Math.max(0.15, Math.min(1, node.backRatio ?? 0.5));
+    const p = [];
+    const n = [];
+    const uv = [];
+    // The hood seats directly on the roof at y=0 — no flashing plate.
+    if (node.style === 'half-round') {
+        addHalfRound(p, n, uv, w, d, h, 0, slats);
+    }
+    else if (node.style === 'slant-box') {
+        addSlantBox(p, n, uv, w, d, h, 0, slats, backRatio);
+    }
+    else {
+        addScoop(p, n, uv, w, d, h, 0, slats);
+    }
+    // Double-side the whole mesh at the geometry level: append a back-facing
+    // copy of every triangle (reversed winding + negated normals). The open
+    // shells (scoop hood, half-round dome, slant-box pocket) then read as solid
+    // from inside too, lit correctly from both sides — without a `DoubleSide`
+    // material, which poisons the MRT scene pass (see the ridge-vent renderer
+    // note). Only one of each coplanar pair front-faces any camera, so there's
+    // no z-fighting.
+    doubleSide(p, n, uv);
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(p, 3));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute(n, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+    geo.computeBoundingSphere();
+    return geo;
+}
+// ─── Style: scoop (the eyebrow) ───────────────────────────────────────────
+function addScoop(p, n, uv, w, d, h, yB, slats) {
+    const a = w / 2;
+    const b = h;
+    const zF = d / 2;
+    const NZ = 20;
+    const NF = 18;
+    // Lofted half-ellipse, full at the front (z = zF) tapering to a rounded
+    // nose at the back. `cos(v·π/2)` gives a smooth falloff to zero.
+    const rings = [];
+    for (let i = 0; i <= NZ; i++) {
+        const v = i / NZ;
+        const scale = Math.cos((v * Math.PI) / 2);
+        const z = zF - v * d;
+        rings.push(halfRing(a, b, yB, z, scale, NF));
+    }
+    for (let i = 0; i < NZ; i++) {
+        addBand(p, n, uv, rings[i + 1], rings[i], NF, (qa, qb, qc, qd) => {
+            const mx = (qa[0] + qb[0] + qc[0] + qd[0]) / 4;
+            const my = (qa[1] + qb[1] + qc[1] + qd[1]) / 4;
+            return [mx, my - yB, 0]; // radial-out from the spine
+        });
+    }
+    // Horizontal louvers filling the front half-ellipse opening.
+    addArchLouvers(p, n, uv, a, b, yB, zF - d * 0.04, slats);
+}
+// ─── Style: half-round (D-shaped louver vent) ─────────────────────────────
+function addHalfRound(p, n, uv, w, d, h, yB, slats) {
+    const a = w / 2;
+    // Cap the crown at a true half-round — never bulge past a semicircle, so the
+    // top reads as a clean, smaller-radius arch. `height` flattens it further.
+    const b = Math.min(h, a);
+    const zF = d / 2;
+    const zB = -d / 2;
+    const NF = 20;
+    const ringF = halfRing(a, b, yB, zF, 1, NF);
+    const ringB = halfRing(a, b, yB, zB, 1, NF);
+    // Curved top shell (constant cross section).
+    addBand(p, n, uv, ringB, ringF, NF, (qa, qb, qc, qd) => {
+        const mx = (qa[0] + qb[0] + qc[0] + qd[0]) / 4;
+        const my = (qa[1] + qb[1] + qc[1] + qd[1]) / 4;
+        return [mx, my - yB, 0];
+    });
+    // Back cap — fan the rear semicircle, facing -Z.
+    const backCenter = [0, yB, zB];
+    for (let j = 0; j < NF; j++) {
+        pushTri(p, n, uv, backCenter, ringB[j + 1], ringB[j], [0, 0, -1]);
+    }
+    // Louvered front face (a slat count bumped up — the D-vent reads denser).
+    addArchLouvers(p, n, uv, a, b, yB, zF - d * 0.04, slats > 0 ? Math.max(slats, 4) : 0);
+}
+// ─── Style: slant-box (low hooded box) ────────────────────────────────────
+function addSlantBox(p, n, uv, w, d, h, yB, slats, backRatio) {
+    const hw = w / 2;
+    const zF = d / 2;
+    const zB = -d / 2;
+    const yFront = yB + h; // tall front — the louvered/screened opening
+    const yBack = yB + h * backRatio; // lower at the back, top slopes down to it
+    // Corner shorthands.
+    const fbl = [-hw, yB, zF];
+    const fbr = [hw, yB, zF];
+    const ftl = [-hw, yFront, zF];
+    const ftr = [hw, yFront, zF];
+    const bbl = [-hw, yB, zB];
+    const bbr = [hw, yB, zB];
+    const btl = [-hw, yBack, zB];
+    const btr = [hw, yBack, zB];
+    // Sides (trapezoids), slanted top, back wall.
+    pushQuad(p, n, uv, fbr, bbr, btr, ftr, [1, 0, 0]);
+    pushQuad(p, n, uv, bbl, fbl, ftl, btl, [-1, 0, 0]);
+    pushQuad(p, n, uv, ftl, ftr, btr, btl, [0, 1, 0]);
+    pushQuad(p, n, uv, bbl, bbr, btr, btl, [0, 0, -1]);
+    // Front frame: a face plate at z = zF with a rectangular hole. The louvers
+    // and screen live RECESSED inside that hole, so they're fully contained by
+    // the box — never poking out past the front face or above the opening.
+    const frame = Math.min(0.04, Math.min(w, h) * 0.14);
+    const oL = -hw + frame;
+    const oR = hw - frame;
+    const oB = yB + frame;
+    const oT = yFront - frame;
+    // Four frame rails around the opening (front face, +Z).
+    pushQuad(p, n, uv, [-hw, oT, zF], [hw, oT, zF], ftr, ftl, [0, 0, 1]); // top
+    pushQuad(p, n, uv, fbl, fbr, [hw, oB, zF], [-hw, oB, zF], [0, 0, 1]); // bottom
+    pushQuad(p, n, uv, [-hw, oB, zF], [oL, oB, zF], [oL, oT, zF], [-hw, oT, zF], [0, 0, 1]); // left
+    pushQuad(p, n, uv, [oR, oB, zF], [hw, oB, zF], [hw, oT, zF], [oR, oT, zF], [0, 0, 1]); // right
+    // Recessed screen panel at the back of the pocket (blocks see-through).
+    const screenZ = zF - d * 0.2;
+    pushQuad(p, n, uv, [oL, oB, screenZ], [oR, oB, screenZ], [oR, oT, screenZ], [oL, oT, screenZ], [0, 0, 1]);
+    // Horizontal louvers inside the pocket — bounded by the opening in height
+    // and recessed in depth between the frame face and the screen.
+    addRectLouvers(p, n, uv, oR, oB, oT, zF - d * 0.07, slats);
+}
+// ─── Louver helpers ───────────────────────────────────────────────────────
+// Angled horizontal slats filling a half-ellipse opening (radius a × b,
+// flat side on the plate at `yB`), set just inside the face at `z`.
+function addArchLouvers(p, n, uv, a, b, yB, z, slats) {
+    if (slats <= 0)
+        return;
+    const drop = (b / (slats + 1)) * 0.55;
+    const back = Math.max(0.012, b * 0.12);
+    const thick = Math.max(0.004, drop * 0.32);
+    for (let k = 1; k <= slats; k++) {
+        const s = k / (slats + 1); // height fraction up the semicircle (sin φ)
+        const y = yB + b * s;
+        const halfX = a * Math.sqrt(Math.max(0, 1 - s * s)) * 0.96;
+        if (halfX < 1e-3)
+            continue;
+        addSlab(p, n, uv, [-halfX, y, z], [halfX, y, z], [halfX, y - drop, z - back], [-halfX, y - drop, z - back], thick);
+    }
+}
+// Angled horizontal slats across a rectangular opening (±halfX, yB..yTop) set
+// just inside the face at `z`.
+function addRectLouvers(p, n, uv, halfX, yB, yTop, z, slats) {
+    if (slats <= 0)
+        return;
+    const span = yTop - yB;
+    const drop = (span / (slats + 1)) * 0.55;
+    const back = Math.max(0.012, span * 0.18);
+    const thick = Math.max(0.004, drop * 0.32);
+    for (let k = 1; k <= slats; k++) {
+        const y = yB + (span * k) / (slats + 1);
+        addSlab(p, n, uv, [-halfX, y, z], [halfX, y, z], [halfX, y - drop, z - back], [-halfX, y - drop, z - back], thick);
+    }
+}
+// Extrude a planar quad (a→b→c→d) into a thin solid slab of `t` thickness
+// along its normal — gives louver blades real depth so they don't read as
+// paper-thin at a grazing angle. Each of the 6 faces is oriented outward from
+// the slab centre, so winding is correct without hand-tracing.
+function addSlab(p, n, uv, a, b, c, d, t) {
+    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 len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    nx = (nx / len) * (t / 2);
+    ny = (ny / len) * (t / 2);
+    nz = (nz / len) * (t / 2);
+    const up = (q) => [q[0] + nx, q[1] + ny, q[2] + nz];
+    const dn = (q) => [q[0] - nx, q[1] - ny, q[2] - nz];
+    const aT = up(a);
+    const bT = up(b);
+    const cT = up(c);
+    const dT = up(d);
+    const aB = dn(a);
+    const bB = dn(b);
+    const cB = dn(c);
+    const dB = dn(d);
+    let cx = 0;
+    let cy = 0;
+    let cz = 0;
+    for (const v of [aT, bT, cT, dT, aB, bB, cB, dB]) {
+        cx += v[0] / 8;
+        cy += v[1] / 8;
+        cz += v[2] / 8;
+    }
+    const face = (q0, q1, q2, q3) => {
+        const mx = (q0[0] + q1[0] + q2[0] + q3[0]) / 4;
+        const my = (q0[1] + q1[1] + q2[1] + q3[1]) / 4;
+        const mz = (q0[2] + q1[2] + q2[2] + q3[2]) / 4;
+        pushQuad(p, n, uv, q0, q1, q2, q3, [mx - cx, my - cy, mz - cz]);
+    };
+    face(aT, bT, cT, dT); // top
+    face(aB, bB, cB, dB); // bottom
+    face(aT, bT, bB, aB); // leading edge
+    face(bT, cT, cB, bB); // right
+    face(cT, dT, dB, cB); // trailing edge
+    face(dT, aT, aB, dB); // left
+}
+// Half-ellipse ring (flat side down on `yB`): φ from 0 (+x) to π (−x).
+function halfRing(a, b, yB, z, scale, steps) {
+    const row = [];
+    for (let j = 0; j <= steps; j++) {
+        const phi = (Math.PI * j) / steps;
+        row.push([a * scale * Math.cos(phi), yB + b * scale * Math.sin(phi), z]);
+    }
+    return row;
+}
+// ─── Primitives ───────────────────────────────────────────────────────────
+function addBand(p, n, uv, rA, rB, lng, hintFn) {
+    for (let j = 0; j < lng; j++) {
+        const a = rA[j];
+        const b = rA[j + 1];
+        const c = rB[j + 1];
+        const d = rB[j];
+        pushQuad(p, n, uv, a, b, c, d, hintFn(a, b, c, d));
+    }
+}
+// Append a reversed-winding, negated-normal copy of every triangle already in
+// the buffers, making the mesh render from both sides under a FrontSide
+// material. `triCount` is snapshotted up front so we only mirror the originals.
+function doubleSide(p, n, uv) {
+    const triCount = Math.floor(p.length / 9);
+    for (let t = 0; t < triCount; t++) {
+        const o = t * 9;
+        const u = t * 6;
+        // verts v0, v2, v1 (reverse the last two to flip the face).
+        p.push(p[o], p[o + 1], p[o + 2], p[o + 6], p[o + 7], p[o + 8], p[o + 3], p[o + 4], p[o + 5]);
+        n.push(-n[o], -n[o + 1], -n[o + 2], -n[o + 6], -n[o + 7], -n[o + 8], -n[o + 3], -n[o + 4], -n[o + 5]);
+        uv.push(uv[u], uv[u + 1], uv[u + 4], uv[u + 5], uv[u + 2], uv[u + 3]);
+    }
+}
+// ─── Winding-safe primitives ─────────────────────────────────────────────
+function pushQuad(positions, normals, uvs, a, b, c, d, hint) {
+    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 u = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    const v = Math.hypot(d[0] - a[0], d[1] - a[1], d[2] - a[2]);
+    if (flip) {
+        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, v);
+        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, v, 0, v);
+    }
+    else {
+        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, v, 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, v, u, v);
+    }
+    for (let i = 0; i < 6; i++)
+        normals.push(nx, ny, nz);
+}
+function pushTri(positions, normals, uvs, a, b, c, hint) {
+    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);
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/eyebrow-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/eyebrow-vent/index.js

@@ -0,0 +1,3 @@
+export { eyebrowVentDefinition } from './definition';
+export { buildEyebrowVentGeometry } from './geometry';
+export { EyebrowVentNode } from './schema';

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

@@ -0,0 +1,13 @@
+import { type EyebrowVentNode } from '@pascal-app/core';
+/**
+ * Eyebrow-vent move tool. Mirrors the box-vent / cupola 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.
+ */
+export default function MoveEyebrowVentTool({ node }: {
+    node: EyebrowVentNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=move-tool.d.ts.map

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

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