@pascal-app/nodes 0.1.1

package/dist/pipe-trap/floorplan.d.ts

@@ -0,0 +1,10 @@
+import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { PipeTrapNode } from './schema';
+/**
+ * Floor-plan symbol — the conventional trap glyph: a short stub at the
+ * inlet (the fixture drop, drawn as a dot since it's vertical) and a
+ * solid line for the trap arm out to the outlet. Reads as the P-trap's
+ * arm in plan.
+ */
+export declare function buildPipeTrapFloorplan(node: PipeTrapNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/pipe-trap/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAkB,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE1F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAI5C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAqC1B"}

package/dist/pipe-trap/floorplan.js

@@ -0,0 +1,41 @@
+import { getPipeTrapPorts } from './ports';
+const PIPE_STROKE = '#57534e';
+/**
+ * Floor-plan symbol — the conventional trap glyph: a short stub at the
+ * inlet (the fixture drop, drawn as a dot since it's vertical) and a
+ * solid line for the trap arm out to the outlet. Reads as the P-trap's
+ * arm in plan.
+ */
+export function buildPipeTrapFloorplan(node, ctx) {
+    const ports = getPipeTrapPorts(node);
+    const inlet = ports.find((p) => p.id === 'inlet');
+    const outlet = ports.find((p) => p.id === 'outlet');
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const showSelectedChrome = (view?.selected || view?.highlighted) ?? false;
+    const stroke = showSelectedChrome && palette ? palette.selectedStroke : PIPE_STROKE;
+    const inletXZ = [inlet.position[0], inlet.position[2]];
+    const outletXZ = [outlet.position[0], outlet.position[2]];
+    const children = [
+        {
+            kind: 'polyline',
+            points: [inletXZ, outletXZ],
+            stroke,
+            strokeWidth: showSelectedChrome ? 2.5 : 1.8,
+            vectorEffect: 'non-scaling-stroke',
+            opacity: 0.9,
+        },
+        {
+            kind: 'circle',
+            cx: inletXZ[0],
+            cy: inletXZ[1],
+            r: 0.04,
+            fill: stroke,
+            opacity: 0.9,
+        },
+    ];
+    if (showSelectedChrome) {
+        children.push({ kind: 'move-handle', point: [node.position[0], node.position[2]] });
+    }
+    return { kind: 'group', children };
+}

package/dist/pipe-trap/geometry.d.ts

@@ -0,0 +1,16 @@
+import { Group, Vector3 } from 'three';
+import type { PipeTrapNode } from './schema';
+/**
+ * P-trap geometry in the LOCAL frame (origin at the trap weir, the low
+ * point of the U). Inlet stub rises +Y to the fixture tailpiece; a
+ * half-torus U-bend turns the flow; the trap arm runs +X toward the
+ * vented waste line. `<ParametricNodeRenderer>` applies position + yaw.
+ */
+export declare function buildPipeTrapGeometry(node: PipeTrapNode): Group;
+/** Local-frame port positions (before position/yaw): inlet at the top
+ *  of the riser facing +Y, outlet at the end of the arm facing +X. */
+export declare function localTrapPorts(node: PipeTrapNode): {
+    inlet: Vector3;
+    outlet: Vector3;
+};
+//# sourceMappingURL=geometry.d.ts.map

package/dist/pipe-trap/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,EAAuC,OAAO,EAAE,MAAM,OAAO,CAAA;AAGvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAc5C;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,GAAG,KAAK,CAmD/D;AAED;sEACsE;AACtE,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG;IAClD,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CAChB,CASA"}

package/dist/pipe-trap/geometry.js

@@ -0,0 +1,74 @@
+import { DoubleSide, Group, Mesh, SphereGeometry, TorusGeometry, Vector3 } from 'three';
+import { buildSection, INCHES_TO_METERS } from '../duct-segment/geometry';
+import { createPipeMaterial } from '../pipe-segment/geometry';
+const BEND_SEGMENTS = 24;
+const RADIAL_SEGMENTS = 20;
+/** Sphere hubs filling the U-bend → stub joints read as a coupling and,
+ *  more importantly, hide the wedge gap left where the horizontal arm's
+ *  flat end cap meets the bend's upward-facing opening at 90°. */
+const HUB_RADIUS_FACTOR = 1.12;
+/** Inlet drop and arm reach in pipe radii — keeps the trap proportional
+ *  to its size without per-size tuning. */
+const INLET_DROP_RADII = 2.6;
+const ARM_REACH_RADII = 3.2;
+/**
+ * P-trap geometry in the LOCAL frame (origin at the trap weir, the low
+ * point of the U). Inlet stub rises +Y to the fixture tailpiece; a
+ * half-torus U-bend turns the flow; the trap arm runs +X toward the
+ * vented waste line. `<ParametricNodeRenderer>` applies position + yaw.
+ */
+export function buildPipeTrapGeometry(node) {
+    const group = new Group();
+    const material = createPipeMaterial({ pipeMaterial: node.pipeMaterial, system: 'waste' });
+    // Double-sided so the thin pipe walls don't drop out at grazing angles,
+    // which read as cuts/holes on the bend and stub ends.
+    material.side = DoubleSide;
+    const radius = (node.diameter * INCHES_TO_METERS) / 2;
+    const bendR = radius * 1.6;
+    const hubRadius = radius * HUB_RADIUS_FACTOR;
+    // U-bend: half torus in the XY plane, opening upward. Sits so its two
+    // tops are at y = bendR (the inlet riser and the arm rise).
+    const bend = new Mesh(new TorusGeometry(bendR, radius, 12, BEND_SEGMENTS, Math.PI), material);
+    bend.rotation.z = Math.PI; // open side up
+    bend.position.set(bendR, bendR, 0);
+    bend.name = 'pipe-trap-bend';
+    group.add(bend);
+    // Inlet riser: from the left top of the U straight up to the fixture.
+    const inletDrop = radius * INLET_DROP_RADII;
+    const inletTop = new Vector3(0, bendR + inletDrop, 0);
+    const inletStub = buildSection(new Vector3(0, bendR, 0), inletTop, radius, material, 'pipe-trap-inlet');
+    if (inletStub)
+        group.add(inletStub);
+    // Trap arm: from the right top of the U horizontally along +X.
+    const armReach = Math.max(radius * ARM_REACH_RADII, node.armLengthM);
+    const armStart = new Vector3(bendR * 2, bendR, 0);
+    const armEnd = new Vector3(bendR * 2 + armReach, bendR, 0);
+    const arm = buildSection(armStart, armEnd, radius, material, 'pipe-trap-arm');
+    if (arm)
+        group.add(arm);
+    // Coupling hubs at the two U-bend tops where the straight stubs meet the
+    // torus. They fill the 90° miter wedge (the visible "cut") and read as
+    // the trap's slip-joint nuts.
+    for (const [i, center] of [
+        new Vector3(0, bendR, 0),
+        new Vector3(bendR * 2, bendR, 0),
+    ].entries()) {
+        const hub = new Mesh(new SphereGeometry(hubRadius, RADIAL_SEGMENTS, 12), material);
+        hub.name = `pipe-trap-hub-${i}`;
+        hub.position.copy(center);
+        group.add(hub);
+    }
+    return group;
+}
+/** Local-frame port positions (before position/yaw): inlet at the top
+ *  of the riser facing +Y, outlet at the end of the arm facing +X. */
+export function localTrapPorts(node) {
+    const radius = (node.diameter * INCHES_TO_METERS) / 2;
+    const bendR = radius * 1.6;
+    const inletDrop = radius * INLET_DROP_RADII;
+    const armReach = Math.max(radius * ARM_REACH_RADII, node.armLengthM);
+    return {
+        inlet: new Vector3(0, bendR + inletDrop, 0),
+        outlet: new Vector3(bendR * 2 + armReach, bendR, 0),
+    };
+}

package/dist/pipe-trap/index.d.ts

@@ -0,0 +1,5 @@
+export { pipeTrapDefinition } from './definition';
+export { buildPipeTrapGeometry } from './geometry';
+export { getPipeTrapPorts } from './ports';
+export { PipeTrapNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/pipe-trap/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA"}

package/dist/pipe-trap/index.js

@@ -0,0 +1,4 @@
+export { pipeTrapDefinition } from './definition';
+export { buildPipeTrapGeometry } from './geometry';
+export { getPipeTrapPorts } from './ports';
+export { PipeTrapNode } from './schema';

package/dist/pipe-trap/parametrics.d.ts

@@ -0,0 +1,4 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { PipeTrapNode } from './schema';
+export declare const pipeTrapParametrics: ParametricDescriptor<PipeTrapNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/pipe-trap/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C,eAAO,MAAM,mBAAmB,EAAE,oBAAoB,CAAC,YAAY,CAelE,CAAA"}

package/dist/pipe-trap/parametrics.js

@@ -0,0 +1,16 @@
+export const pipeTrapParametrics = {
+    groups: [
+        {
+            label: 'Trap',
+            fields: [
+                { key: 'diameter', kind: 'number', unit: 'in', min: 1.25, max: 4, step: 0.25 },
+                { key: 'pipeMaterial', kind: 'enum', options: ['pvc', 'abs', 'cast-iron'] },
+                { key: 'armLengthM', kind: 'number', unit: 'm', min: 0, max: 4, step: 0.05 },
+            ],
+        },
+        {
+            label: 'Placement',
+            fields: [{ key: 'position', kind: 'vec3' }],
+        },
+    ],
+};

package/dist/pipe-trap/ports.d.ts

@@ -0,0 +1,11 @@
+import type { NodePort } from '@pascal-app/core';
+import type { PipeTrapNode } from './schema';
+/**
+ * `def.ports` — the trap's inlet (up, to the fixture) and outlet (the
+ * trap arm, toward the vented waste line), transformed by position +
+ * yaw into level-local space. Both carry the trap diameter and the
+ * 'waste' system tag so the pipe tool and system graph treat them like
+ * any other DWV joint.
+ */
+export declare function getPipeTrapPorts(node: PipeTrapNode): NodePort[];
+//# sourceMappingURL=ports.d.ts.map

package/dist/pipe-trap/ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/ports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,QAAQ,EAAE,CAsB/D"}

package/dist/pipe-trap/ports.js

@@ -0,0 +1,32 @@
+import { Vector3 } from 'three';
+import { localTrapPorts } from './geometry';
+/**
+ * `def.ports` — the trap's inlet (up, to the fixture) and outlet (the
+ * trap arm, toward the vented waste line), transformed by position +
+ * yaw into level-local space. Both carry the trap diameter and the
+ * 'waste' system tag so the pipe tool and system graph treat them like
+ * any other DWV joint.
+ */
+export function getPipeTrapPorts(node) {
+    const { inlet, outlet } = localTrapPorts(node);
+    const yaw = node.rotation;
+    const offset = new Vector3(node.position[0], node.position[1], node.position[2]);
+    const place = (local, dir) => {
+        const position = local
+            .clone()
+            .applyAxisAngle(new Vector3(0, 1, 0), yaw)
+            .add(offset);
+        const direction = dir
+            .clone()
+            .applyAxisAngle(new Vector3(0, 1, 0), yaw)
+            .normalize();
+        return {
+            id: local === inlet ? 'inlet' : 'outlet',
+            position: [position.x, position.y, position.z],
+            direction: [direction.x, direction.y, direction.z],
+            diameter: node.diameter,
+            system: 'waste',
+        };
+    };
+    return [place(inlet, new Vector3(0, 1, 0)), place(outlet, new Vector3(1, 0, 0))];
+}

package/dist/pipe-trap/schema.d.ts

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

package/dist/pipe-trap/schema.d.ts.map

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

package/dist/pipe-trap/schema.js

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

package/dist/pipe-trap/tool.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Click-place tool for P-traps. The ghost follows the cursor on the
+ * floor. **R / T** rotate the arm ±45°; grid snap follows the active
+ * snapping mode (the contextual HUD chip — Shift cycles it). The pipe
+ * tool then draws the trap arm off the outlet toward the vent.
+ */
+declare const PipeTrapTool: () => import("react").JSX.Element | null;
+export default PipeTrapTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/pipe-trap/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CA4GjB,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/pipe-trap/tool.js

@@ -0,0 +1,99 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, PipeTrapNode, useScene } from '@pascal-app/core';
+import { isGridSnapActive, triggerSFX, useEditor } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Html } from '@react-three/drei';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { LevelOffsetGroup } from '../shared/level-offset-group';
+import { pipeTrapDefinition } from './definition';
+import { buildPipeTrapGeometry } from './geometry';
+const PREVIEW_OPACITY = 0.55;
+const ROTATE_STEP_RAD = Math.PI / 4;
+function snap(value, step) {
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+/**
+ * Click-place tool for P-traps. The ghost follows the cursor on the
+ * floor. **R / T** rotate the arm ±45°; grid snap follows the active
+ * snapping mode (the contextual HUD chip — Shift cycles it). The pipe
+ * tool then draws the trap arm off the outlet toward the vent.
+ */
+const PipeTrapTool = () => {
+    const activeLevelId = useViewer((s) => s.selection.levelId);
+    const [cursor, setCursor] = useState(null);
+    const [yaw, setYaw] = useState(0);
+    const [diameter] = useState(pipeTrapDefinition.defaults().diameter);
+    const yawRef = useRef(0);
+    const diameterRef = useRef(diameter);
+    diameterRef.current = diameter;
+    const previewNode = useMemo(() => PipeTrapNode.parse({
+        ...pipeTrapDefinition.defaults(),
+        diameter,
+    }), [diameter]);
+    const ghost = useMemo(() => {
+        const group = buildPipeTrapGeometry(previewNode);
+        group.traverse((child) => {
+            const mesh = child;
+            if (mesh.material) {
+                mesh.material.transparent = true;
+                mesh.material.opacity = PREVIEW_OPACITY;
+            }
+        });
+        return group;
+    }, [previewNode]);
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        const resolve = (event) => {
+            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            return {
+                position: [snap(event.localPosition[0], step), 0, snap(event.localPosition[2], step)],
+                diameter: diameterRef.current,
+            };
+        };
+        const onMove = (event) => {
+            setCursor(resolve(event).position);
+        };
+        const onClick = (event) => {
+            const r = resolve(event);
+            const trap = PipeTrapNode.parse({
+                ...pipeTrapDefinition.defaults(),
+                diameter: r.diameter,
+                position: r.position,
+                rotation: yawRef.current,
+            });
+            useScene.getState().createNode(trap, activeLevelId);
+            useViewer.getState().setSelection({ selectedIds: [trap.id] });
+            triggerSFX('sfx:item-place');
+        };
+        const onKeyDown = (e) => {
+            const tag = e.target?.tagName;
+            if (tag === 'INPUT' || tag === 'TEXTAREA')
+                return;
+            const key = e.key;
+            if (key === 'r' || key === 'R' || key === 't' || key === 'T') {
+                e.preventDefault();
+                e.stopPropagation();
+                const steps = key === 't' || key === 'T' || e.shiftKey ? -1 : 1;
+                yawRef.current += steps * ROTATE_STEP_RAD;
+                setYaw(yawRef.current);
+                triggerSFX('sfx:item-rotate');
+            }
+        };
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', onClick);
+        window.addEventListener('keydown', onKeyDown, true);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', onClick);
+            window.removeEventListener('keydown', onKeyDown, true);
+        };
+    }, [activeLevelId]);
+    if (!activeLevelId || !cursor)
+        return null;
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx("group", { position: cursor, rotation: [0, yaw, 0], children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [cursor[0], cursor[1] + 0.5, cursor[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [_jsxs("span", { className: "font-medium text-foreground", children: [diameter, "\" Trap"] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" })] }) })] }));
+};
+export default PipeTrapTool;

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

@@ -0,0 +1,16 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { RidgeVentNode } from './schema';
+/**
+ * Ridge vent — a ventilation strip running along the ridge of a roof
+ * segment. Parented to a `roof-segment`; position is segment-local.
+ *
+ * Three-checkbox model — same shape as box-vent: custom `def.renderer`
+ * (parent segment transform lookup + live-transform follow), pure
+ * geometry builder shared with the placement preview + future tests,
+ * no animation or per-frame system.
+ *
+ * The placement tool snaps to the nearest ridge/break line wherever the
+ * cursor lands on a segment.
+ */
+export declare const ridgeVentDefinition: NodeDefinition<typeof RidgeVentNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAwIxC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,CA2DpE,CAAA"}

package/dist/ridge-vent/definition.js

@@ -0,0 +1,195 @@
+import { RidgeVentNode as RidgeVentNodeSchema, } from '@pascal-app/core';
+import { surfacePaintCapability } from '../shared/surface-paint';
+import { buildRidgeVentFloorplan } from './floorplan';
+import { ridgeVentParametrics } from './parametrics';
+import { RidgeVentNode } from './schema';
+// Edge-to-arrow-center offset, matching the box-vent / chimney cadence.
+const SIDE_HANDLE_OFFSET = 0.25;
+const HEIGHT_HANDLE_OFFSET = 0.15;
+// Snug to the vent corner — keeps the rotate icon close to the item.
+const ROTATE_CORNER_OFFSET = 0.1;
+// Ridge vents are long but thin — minimums let users shrink without
+// collapsing the geometry past the point where the cross-section
+// degenerates. Default length is 2.0, default width 0.3, default
+// height 0.08, so these are well below the defaults.
+const MIN_LENGTH = 0.2;
+const MIN_WIDTH = 0.1;
+const MIN_HEIGHT = 0.02;
+// Mid-Y of the vent body in vent-mesh-local frame. The base sits at the
+// ridge line (Y=0) and the cap peaks at Y=height — so side / rotate
+// chevrons place at half-height to read as "beside the body".
+function getBodyMidY(n) {
+    return Math.max(MIN_HEIGHT, n.height) / 2;
+}
+// Length arrow on ±X (the ridge direction). Asymmetric: drag one end
+// outward and the opposite end stays world-fixed by recentering
+// `position` along the vent's own +X arm in segment frame (yaw-aware
+// math, matches box-vent / chimney). The ridge vent typically straddles
+// a portion of the ridge, so dragging one end is the natural extend /
+// shorten gesture.
+function ridgeVentLengthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: side === 'right' ? 'min' : 'max',
+        min: MIN_LENGTH,
+        currentValue: (n) => n.length,
+        apply: (initial, newLength) => {
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.length / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.length / 2) * armZ;
+            const newCenterX = anchorX + sign * (newLength / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newLength / 2) * armZ;
+            return {
+                length: newLength,
+                position: [newCenterX, initial.position[1], newCenterZ],
+            };
+        },
+        placement: {
+            position: (n) => [sign * (n.length / 2 + SIDE_HANDLE_OFFSET), getBodyMidY(n), 0],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+    };
+}
+// Width arrow on +Z (across the ridge). Symmetric — the vent geometry
+// straddles the ridge line (Z=0) so growing the width pushes both edges
+// outward by the same amount. A single chevron on +Z reads as "this is
+// the width dimension"; keeping it symmetric also stays inside the same
+// handle-count budget the chimney / dormer / box-vent already document.
+function ridgeVentWidthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'center',
+        min: MIN_WIDTH,
+        currentValue: (n) => n.width,
+        apply: (_n, newValue) => ({ width: newValue }),
+        placement: {
+            position: (n) => [0, getBodyMidY(n), n.width / 2 + SIDE_HANDLE_OFFSET],
+        },
+    };
+}
+// Height arrow above the cap peak. anchor='min' so the base stays
+// pinned to the ridge line (Y=0) and the peak follows the cursor. Plain
+// chevron — at default 0.08 m a dashed tracker leader would be visual
+// noise rather than a dimension cue.
+function ridgeVentHeightHandle() {
+    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],
+        },
+    };
+}
+// Whole-vent rotation gizmo at the +X+Z corner of the body footprint.
+// Negate the cursor delta to match three.js Y-rotation handedness. The
+// registered group already centres on the vent and applies its yaw,
+// so the default rotation pivot is correct.
+function ridgeVentRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: (n) => [
+                n.length / 2 + ROTATE_CORNER_OFFSET,
+                getBodyMidY(n),
+                n.width / 2 + ROTATE_CORNER_OFFSET,
+            ],
+            // Two-headed icon's natural bias is along +X; aim along the
+            // +X+Z corner bisector so it sits visually flush with the
+            // rotate gesture's swing direction.
+            rotationY: () => -Math.PI / 4,
+        },
+        // Guide ring centred on the vent, sized to pass through the corner icon
+        // so the icon rides the ring — matches solar-panel / skylight.
+        decoration: {
+            kind: 'ring',
+            radius: (n) => Math.hypot(n.length / 2 + ROTATE_CORNER_OFFSET, n.width / 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 ridgeVentHandles = [
+    ridgeVentLengthHandle('right'),
+    ridgeVentLengthHandle('left'),
+    ridgeVentWidthHandle(),
+    ridgeVentHeightHandle(),
+    ridgeVentRotateHandle(),
+].map((h) => ({ ...h, portal: 'grandparent' }));
+/**
+ * Ridge vent — a ventilation strip running along the ridge of a roof
+ * segment. Parented to a `roof-segment`; position is segment-local.
+ *
+ * Three-checkbox model — same shape as box-vent: custom `def.renderer`
+ * (parent segment transform lookup + live-transform follow), pure
+ * geometry builder shared with the placement preview + future tests,
+ * no animation or per-frame system.
+ *
+ * The placement tool snaps to the nearest ridge/break line wherever the
+ * cursor lands on a segment.
+ */
+export const ridgeVentDefinition = {
+    kind: 'ridge-vent',
+    schemaVersion: 1,
+    schema: RidgeVentNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = RidgeVentNodeSchema.parse({
+            id: 'rvent_default',
+            type: 'ridge-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
+        // ridge — no `buildCut`, just the dirty cascade so the parent
+        // roof's merged shell rebuilds when the vent moves / resizes.
+        roofAccessory: {},
+    },
+    parametrics: ridgeVentParametrics,
+    handles: ridgeVentHandles,
+    floorplan: buildRidgeVentFloorplan,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    preview: () => import('./preview'),
+    tool: () => import('./tool'),
+    affordanceTools: {
+        move: () => import('./move-tool'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place ridge vent on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Ridge Vent',
+        description: 'Ventilation strip running along the ridge of a roof segment.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 121,
+    },
+    mcp: {
+        description: 'A ridge vent — three styles (standard curved cap / shingled / metal), optional end caps, length / width / height parametric.',
+    },
+};

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

@@ -0,0 +1,15 @@
+import type { FloorplanGeometry, GeometryContext, RidgeVentNode } from '@pascal-app/core';
+/**
+ * Floor-plan builder for a ridge vent — a ventilation strip running along
+ * a roof ridge. Seen from above it's a long thin band straddling the
+ * ridge crest, with a centre crest line, end caps where closed, and tab
+ * dividers for the shingled style.
+ *
+ * Coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → vent), same as the chimney builder. `position`
+ * is segment-local; the run (`length`) is along local +X and the small
+ * cross-`width` straddles the ridge along local Z (centred at Z = 0).
+ * `rotation` is yaw, negated for the floor plan's y-down convention.
+ */
+export declare function buildRidgeVentFloorplan(node: RidgeVentNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EAEjB,eAAe,EACf,aAAa,EAGd,MAAM,kBAAkB,CAAA;AAMzB;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA0H1B"}