@pascal-app/nodes 0.1.1

package/dist/duct-terminal/definition.d.ts

@@ -0,0 +1,13 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { DuctTerminalNode } from './schema';
+/**
+ * Phase 3 of the HVAC node system — duct terminals: supply registers,
+ * ceiling diffusers, return grilles. The end of the air loop. One typed
+ * port at the collar (mount-aware direction) so duct runs end onto a
+ * terminal like any other port.
+ *
+ * Composition: `def.geometry` only. Yaw-only rotation — the editor's
+ * default R-rotate works on a selected terminal.
+ */
+export declare const ductTerminalDefinition: NodeDefinition<typeof DuctTerminalNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/duct-terminal/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAoF1E,CAAA"}

package/dist/duct-terminal/definition.js

@@ -0,0 +1,87 @@
+import { buildDuctTerminalFloorplan } from './floorplan';
+import { buildDuctTerminalGeometry } from './geometry';
+import { ductTerminalParametrics } from './parametrics';
+import { getDuctTerminalPorts } from './ports';
+import { DuctTerminalNode } from './schema';
+/**
+ * Phase 3 of the HVAC node system — duct terminals: supply registers,
+ * ceiling diffusers, return grilles. The end of the air loop. One typed
+ * port at the collar (mount-aware direction) so duct runs end onto a
+ * terminal like any other port.
+ *
+ * Composition: `def.geometry` only. Yaw-only rotation — the editor's
+ * default R-rotate works on a selected terminal.
+ */
+export const ductTerminalDefinition = {
+    kind: 'duct-terminal',
+    schemaVersion: 1,
+    schema: DuctTerminalNode,
+    category: 'utility',
+    distributionRole: 'terminal',
+    snapProfile: 'item',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+        terminalType: 'supply-register',
+        mount: 'floor',
+        width: 0.3,
+        depth: 0.15,
+        collarShape: 'round',
+        collarDiameter: 6,
+        collarWidth: 10,
+        collarHeight: 6,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        movable: { axes: ['x', 'z'], gridSnap: true, portSnap: { systems: ['supply', 'return'] } },
+        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
+        duplicable: true,
+        deletable: true,
+        // A floor register rests on top of whatever slab is under it — the
+        // generic FloorElevationSystem lifts its mesh Y by the slab's elevation
+        // so the face sits on the slab surface instead of sinking into it.
+        // Ceiling / wall mounts derive their Y elsewhere, so `applies` skips them.
+        floorPlaced: {
+            footprint: (node) => {
+                const t = node;
+                return { dimensions: [t.width, 0, t.depth], rotation: [0, t.rotation, 0] };
+            },
+            applies: (node) => node.mount === 'floor',
+        },
+    },
+    parametrics: ductTerminalParametrics,
+    geometry: buildDuctTerminalGeometry,
+    geometryKey: (n) => JSON.stringify([
+        n.terminalType,
+        n.mount,
+        n.width,
+        n.depth,
+        n.collarShape,
+        n.collarDiameter,
+        n.collarWidth,
+        n.collarHeight,
+    ]),
+    ports: getDuctTerminalPorts,
+    floorplan: buildDuctTerminalFloorplan,
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Click', label: 'Place register' },
+        { key: 'M', label: 'Mount: floor / ceiling / wall' },
+        { key: 'R / T', label: 'Rotate ±45° (floor / ceiling)' },
+        { key: 'Esc', label: 'Exit' },
+    ],
+    presentation: {
+        label: 'Register',
+        description: 'Duct terminal — supply register, ceiling diffuser, or return grille. Duct runs end at its collar.',
+        icon: { kind: 'url', src: '/icons/registers.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 93,
+    },
+    mcp: {
+        description: 'A duct terminal (supply register, ceiling diffuser, or return grille) with a single collar port. Mount (floor/ceiling/wall) drives the face orientation and collar direction.',
+    },
+};

package/dist/duct-terminal/floorplan.d.ts

@@ -0,0 +1,11 @@
+import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { DuctTerminalNode } from './schema';
+/**
+ * Floor-plan symbol for a duct terminal: the face rectangle (rotated by
+ * yaw) with the conventional register cross-slats hinted as a single
+ * mid-line, tinted by system. Wall mounts render the same footprint —
+ * the face projects to a thin strip, which is close enough for plan
+ * reading at this stage.
+ */
+export declare function buildDuctTerminalFloorplan(node: DuctTerminalNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/duct-terminal/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAkB,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE1F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAOhD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAqD1B"}

package/dist/duct-terminal/floorplan.js

@@ -0,0 +1,61 @@
+import { terminalSystem } from './ports';
+const SUPPLY_COLOR = '#d4825a';
+const RETURN_COLOR = '#5a8ad4';
+const FRAME_STROKE = '#6b7280';
+const FACE_FILL = '#e5e7eb';
+/**
+ * Floor-plan symbol for a duct terminal: the face rectangle (rotated by
+ * yaw) with the conventional register cross-slats hinted as a single
+ * mid-line, tinted by system. Wall mounts render the same footprint —
+ * the face projects to a thin strip, which is close enough for plan
+ * reading at this stage.
+ */
+export function buildDuctTerminalFloorplan(node, ctx) {
+    const [cx, , cz] = node.position;
+    const cos = Math.cos(node.rotation);
+    const sin = Math.sin(node.rotation);
+    const hw = node.width / 2;
+    const hd = (node.mount === 'wall' ? 0.06 : node.depth) / 2;
+    const corner = (lx, lz) => [
+        cx + lx * cos + lz * sin,
+        cz - lx * sin + lz * cos,
+    ];
+    const points = [
+        corner(-hw, -hd),
+        corner(hw, -hd),
+        corner(hw, hd),
+        corner(-hw, hd),
+    ];
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const showSelectedChrome = (view?.selected || view?.highlighted) ?? false;
+    const accent = terminalSystem(node) === 'supply' ? SUPPLY_COLOR : RETURN_COLOR;
+    const stroke = showSelectedChrome && palette ? palette.selectedStroke : FRAME_STROKE;
+    const mid1 = corner(-hw * 0.8, 0);
+    const mid2 = corner(hw * 0.8, 0);
+    const children = [
+        {
+            kind: 'polygon',
+            points,
+            fill: FACE_FILL,
+            stroke,
+            strokeWidth: showSelectedChrome ? 0.025 : 0.015,
+            opacity: 0.92,
+        },
+        {
+            kind: 'line',
+            x1: mid1[0],
+            y1: mid1[1],
+            x2: mid2[0],
+            y2: mid2[1],
+            stroke: accent,
+            strokeWidth: 1.5,
+            vectorEffect: 'non-scaling-stroke',
+            opacity: 0.9,
+        },
+    ];
+    if (showSelectedChrome) {
+        children.push({ kind: 'move-handle', point: [cx, cz] });
+    }
+    return { kind: 'group', children };
+}

package/dist/duct-terminal/geometry.d.ts

@@ -0,0 +1,14 @@
+import { Group } from 'three';
+import type { DuctTerminalNode } from './schema';
+/**
+ * Pure geometry builder for a duct terminal, in the node's LOCAL frame —
+ * `<ParametricNodeRenderer>` applies `position` + yaw, and the builder
+ * applies the mount orientation itself.
+ *
+ * Canonical (floor) frame before the mount rotation: face plate lying
+ * in XZ at y=0 with its normal +Y, louver slats just above it, collar
+ * cylinder going -Y toward the duct side. Ceiling mounts flip it; wall
+ * mounts stand it up facing +Z.
+ */
+export declare function buildDuctTerminalGeometry(node: DuctTerminalNode): Group;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/duct-terminal/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,EAIN,MAAM,OAAO,CAAA;AAGd,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAchD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,gBAAgB,GAAG,KAAK,CAqEvE"}

package/dist/duct-terminal/geometry.js

@@ -0,0 +1,78 @@
+import { BoxGeometry, CylinderGeometry, Group, Mesh, MeshStandardMaterial, Vector3, } from 'three';
+import { createOvalSectionGeometry, INCHES_TO_METERS } from '../duct-segment/geometry';
+import { COLLAR_LENGTH, mountQuaternion, terminalSystem } from './ports';
+const RADIAL_SEGMENTS = 20;
+/** Radial clearance (meters) the collar sleeve carries over the duct's
+ *  nominal cross-section, so a run leaving at the advertised size nests
+ *  inside the sleeve instead of z-fighting its faces. ~5 mm ≈ a slip joint. */
+const COLLAR_CLEARANCE_M = 0.005;
+const FRAME_COLOR = '#e3e5e8';
+const SLAT_SUPPLY_COLOR = '#cdd1d6';
+const SLAT_RETURN_COLOR = '#aeb4bb';
+const COLLAR_COLOR = '#c2c2c2';
+/**
+ * Pure geometry builder for a duct terminal, in the node's LOCAL frame —
+ * `<ParametricNodeRenderer>` applies `position` + yaw, and the builder
+ * applies the mount orientation itself.
+ *
+ * Canonical (floor) frame before the mount rotation: face plate lying
+ * in XZ at y=0 with its normal +Y, louver slats just above it, collar
+ * cylinder going -Y toward the duct side. Ceiling mounts flip it; wall
+ * mounts stand it up facing +Z.
+ */
+export function buildDuctTerminalGeometry(node) {
+    const group = new Group();
+    const oriented = new Group();
+    oriented.quaternion.copy(mountQuaternion(node.mount));
+    group.add(oriented);
+    const frameMaterial = new MeshStandardMaterial({
+        color: FRAME_COLOR,
+        metalness: 0.4,
+        roughness: 0.5,
+    });
+    const slatMaterial = new MeshStandardMaterial({
+        color: terminalSystem(node) === 'return' ? SLAT_RETURN_COLOR : SLAT_SUPPLY_COLOR,
+        metalness: 0.45,
+        roughness: 0.55,
+    });
+    const frameThickness = 0.018;
+    const frame = new Mesh(new BoxGeometry(node.width, frameThickness, node.depth), frameMaterial);
+    frame.name = 'terminal-frame';
+    frame.position.set(0, frameThickness / 2, 0);
+    oriented.add(frame);
+    // Louver slats across the face. Return grilles read denser; diffusers
+    // get concentric-ish wide slats via the same simple pattern.
+    const slatCount = node.terminalType === 'return-grille' ? 7 : 4;
+    const innerDepth = node.depth * 0.82;
+    const slatDepth = (innerDepth / slatCount) * 0.55;
+    for (let i = 0; i < slatCount; i++) {
+        const slat = new Mesh(new BoxGeometry(node.width * 0.86, 0.006, slatDepth), slatMaterial);
+        slat.name = `terminal-slat-${i}`;
+        const z = -innerDepth / 2 + (innerDepth / slatCount) * (i + 0.5);
+        slat.position.set(0, frameThickness + 0.002, z);
+        slat.rotation.x = node.terminalType === 'diffuser' ? 0 : -0.5;
+        oriented.add(slat);
+    }
+    // Collar runs along -Y from the face toward the duct. Round is a
+    // cylinder; rect a box; oval the flat-oval prism (its extrude basis
+    // already puts the run length on Y, matching the collar axis). The
+    // sleeve is grown one clearance on every side so a duct run leaving at
+    // the advertised size nests inside it instead of z-fighting its faces.
+    const grow = 2 * COLLAR_CLEARANCE_M;
+    let collarGeom;
+    if (node.collarShape === 'rect') {
+        collarGeom = new BoxGeometry(node.collarWidth * INCHES_TO_METERS + grow, COLLAR_LENGTH, node.collarHeight * INCHES_TO_METERS + grow);
+    }
+    else if (node.collarShape === 'oval') {
+        collarGeom = createOvalSectionGeometry(node.collarWidth * INCHES_TO_METERS + grow, node.collarHeight * INCHES_TO_METERS + grow, COLLAR_LENGTH);
+    }
+    else {
+        const radius = (node.collarDiameter * INCHES_TO_METERS + grow) / 2;
+        collarGeom = new CylinderGeometry(radius, radius, COLLAR_LENGTH, RADIAL_SEGMENTS, 1, false);
+    }
+    const collar = new Mesh(collarGeom, new MeshStandardMaterial({ color: COLLAR_COLOR, metalness: 0.6, roughness: 0.4 }));
+    collar.name = 'terminal-collar';
+    collar.position.copy(new Vector3(0, -COLLAR_LENGTH / 2, 0));
+    oriented.add(collar);
+    return group;
+}

package/dist/duct-terminal/index.d.ts

@@ -0,0 +1,5 @@
+export { ductTerminalDefinition } from './definition';
+export { buildDuctTerminalGeometry } from './geometry';
+export { getDuctTerminalPorts } from './ports';
+export { DuctTerminalNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/duct-terminal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA"}

package/dist/duct-terminal/index.js

@@ -0,0 +1,4 @@
+export { ductTerminalDefinition } from './definition';
+export { buildDuctTerminalGeometry } from './geometry';
+export { getDuctTerminalPorts } from './ports';
+export { DuctTerminalNode } from './schema';

package/dist/duct-terminal/parametrics.d.ts

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

package/dist/duct-terminal/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,gBAAgB,CAoE1E,CAAA"}

package/dist/duct-terminal/parametrics.js

@@ -0,0 +1,69 @@
+export const ductTerminalParametrics = {
+    groups: [
+        {
+            label: 'Terminal',
+            fields: [
+                {
+                    key: 'terminalType',
+                    kind: 'enum',
+                    options: ['supply-register', 'diffuser', 'return-grille'],
+                },
+                {
+                    key: 'mount',
+                    kind: 'enum',
+                    options: ['floor', 'ceiling', 'wall'],
+                    display: 'segmented',
+                },
+            ],
+        },
+        {
+            label: 'Face',
+            fields: [
+                { key: 'width', kind: 'number', unit: 'm', min: 0.1, max: 1.5, step: 0.05 },
+                { key: 'depth', kind: 'number', unit: 'm', min: 0.05, max: 1.5, step: 0.05 },
+            ],
+        },
+        {
+            label: 'Collar',
+            fields: [
+                {
+                    key: 'collarShape',
+                    kind: 'enum',
+                    options: ['round', 'rect', 'oval'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'collarDiameter',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 4,
+                    max: 20,
+                    step: 1,
+                    visibleIf: (n) => n.collarShape === 'round',
+                },
+                {
+                    key: 'collarWidth',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 4,
+                    max: 20,
+                    step: 1,
+                    visibleIf: (n) => n.collarShape !== 'round',
+                },
+                {
+                    key: 'collarHeight',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 3,
+                    max: 20,
+                    step: 1,
+                    visibleIf: (n) => n.collarShape !== 'round',
+                },
+            ],
+        },
+        {
+            label: 'Placement',
+            fields: [{ key: 'position', kind: 'vec3' }],
+        },
+    ],
+};

package/dist/duct-terminal/ports.d.ts

@@ -0,0 +1,27 @@
+import type { NodePort } from '@pascal-app/core';
+import { Quaternion } from 'three';
+import type { DuctTerminalNode } from './schema';
+/** Collar stub length in meters behind the face. */
+export declare const COLLAR_LENGTH = 0.12;
+/**
+ * Mount orientation: rotation applied to the canonical floor frame
+ * (face normal +Y, collar pointing -Y). Ceiling flips it; wall stands
+ * it up so the face looks along +Z and the collar points -Z (into the
+ * wall). Yaw is applied on top by the renderer / port transform.
+ */
+export declare function mountQuaternion(mount: DuctTerminalNode['mount']): Quaternion;
+export declare function terminalSystem(node: DuctTerminalNode): 'supply' | 'return';
+/**
+ * Diameter (inches) the collar advertises at its port. Rect / oval
+ * collars report the area-equivalent round diameter so round runs mate
+ * at a sensible size — the same convention duct segments use.
+ */
+export declare function collarPortDiameterIn(node: DuctTerminalNode): number;
+/**
+ * `def.ports` — the single collar port in level-local space. Canonical
+ * frame: collar tip at (0, -COLLAR_LENGTH, 0) pointing -Y (away from the
+ * face); mount + yaw + position transform it. Direction points OUT of
+ * the terminal — i.e. toward the duct that should connect.
+ */
+export declare function getDuctTerminalPorts(node: DuctTerminalNode): NodePort[];
+//# sourceMappingURL=ports.d.ts.map

package/dist/duct-terminal/ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/ports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAS,UAAU,EAAW,MAAM,OAAO,CAAA;AAElD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,oDAAoD;AACpD,eAAO,MAAM,aAAa,OAAO,CAAA;AAEjC;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,GAAG,UAAU,CAI5E;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,CAE1E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAMnE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,QAAQ,EAAE,CAoBvE"}

package/dist/duct-terminal/ports.js

@@ -0,0 +1,60 @@
+import { Euler, Quaternion, Vector3 } from 'three';
+import { equivalentDiameterIn, ovalEquivalentDiameterIn } from '../duct-segment/geometry';
+/** Collar stub length in meters behind the face. */
+export const COLLAR_LENGTH = 0.12;
+/**
+ * Mount orientation: rotation applied to the canonical floor frame
+ * (face normal +Y, collar pointing -Y). Ceiling flips it; wall stands
+ * it up so the face looks along +Z and the collar points -Z (into the
+ * wall). Yaw is applied on top by the renderer / port transform.
+ */
+export function mountQuaternion(mount) {
+    if (mount === 'ceiling')
+        return new Quaternion().setFromEuler(new Euler(Math.PI, 0, 0));
+    if (mount === 'wall')
+        return new Quaternion().setFromEuler(new Euler(Math.PI / 2, 0, 0));
+    return new Quaternion();
+}
+export function terminalSystem(node) {
+    return node.terminalType === 'return-grille' ? 'return' : 'supply';
+}
+/**
+ * Diameter (inches) the collar advertises at its port. Rect / oval
+ * collars report the area-equivalent round diameter so round runs mate
+ * at a sensible size — the same convention duct segments use.
+ */
+export function collarPortDiameterIn(node) {
+    if (node.collarShape === 'rect')
+        return equivalentDiameterIn(node.collarWidth, node.collarHeight);
+    if (node.collarShape === 'oval') {
+        return ovalEquivalentDiameterIn(node.collarWidth, node.collarHeight);
+    }
+    return node.collarDiameter;
+}
+/**
+ * `def.ports` — the single collar port in level-local space. Canonical
+ * frame: collar tip at (0, -COLLAR_LENGTH, 0) pointing -Y (away from the
+ * face); mount + yaw + position transform it. Direction points OUT of
+ * the terminal — i.e. toward the duct that should connect.
+ */
+export function getDuctTerminalPorts(node) {
+    const transform = new Quaternion()
+        .setFromEuler(new Euler(0, node.rotation, 0))
+        .multiply(mountQuaternion(node.mount));
+    const position = new Vector3(0, -COLLAR_LENGTH, 0)
+        .applyQuaternion(transform)
+        .add(new Vector3(node.position[0], node.position[1], node.position[2]));
+    const direction = new Vector3(0, -1, 0).applyQuaternion(transform).normalize();
+    return [
+        {
+            id: 'collar',
+            position: [position.x, position.y, position.z],
+            direction: [direction.x, direction.y, direction.z],
+            diameter: collarPortDiameterIn(node),
+            system: terminalSystem(node),
+            shape: node.collarShape,
+            width: node.collarWidth,
+            height: node.collarHeight,
+        },
+    ];
+}

package/dist/duct-terminal/schema.d.ts

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

package/dist/duct-terminal/schema.d.ts.map

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

package/dist/duct-terminal/schema.js

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

package/dist/duct-terminal/tool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Click-place tool for duct terminals (registers / diffusers / grilles).
+ *
+ * **Mount drives the target surface** (cycle with **M**): a floor register
+ * snaps to the floor grid, a ceiling diffuser snaps to a horizontal plane at
+ * ceiling height (derived from the level's ceilings/walls), and a wall
+ * register snaps flush onto whichever wall the cursor is over, its face
+ * oriented along the wall's outward normal. **R / T** rotate the floor/ceiling
+ * yaw ±45°; wall yaw is fixed by the wall it mates to.
+ */
+declare const DuctTerminalTool: () => import("react").JSX.Element | null;
+export default DuctTerminalTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/duct-terminal/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/tool.tsx"],"names":[],"mappings":"AA4IA;;;;;;;;;GASG;AACH,QAAA,MAAM,gBAAgB,0CAuSrB,CAAA;AAED,eAAe,gBAAgB,CAAA"}