@pascal-app/nodes 0.1.1

package/dist/door/parametrics.js

@@ -0,0 +1,27 @@
+/**
+ * Stage E inspector for door. Mounts the kind-owned panel
+ * (`panel.tsx`) via `customPanel` — door has 29+ controls (segments,
+ * hardware, hinges, panic bar, opening shape, etc.) that can't fit
+ * into the generic auto-inspector. The `groups` entries stay populated
+ * so the registry still considers door "parametric" (for tooling that
+ * lists kinds with editable schema).
+ */
+export const doorParametrics = {
+    groups: [
+        {
+            label: 'Dimensions',
+            fields: [
+                { key: 'width', kind: 'number', unit: 'm', min: 0.5, max: 6, step: 0.05 },
+                { key: 'height', kind: 'number', unit: 'm', min: 1.0, max: 4, step: 0.05 },
+            ],
+        },
+        {
+            label: 'Frame',
+            fields: [
+                { key: 'frameThickness', kind: 'number', unit: 'm', min: 0.01, max: 0.2, step: 0.005 },
+                { key: 'frameDepth', kind: 'number', unit: 'm', min: 0.01, max: 0.3, step: 0.005 },
+            ],
+        },
+    ],
+    customPanel: () => import('./panel'),
+};

package/dist/door/preview.d.ts

@@ -0,0 +1,18 @@
+import type { DoorNode } from './schema';
+/**
+ * Translucent preview of a door — used by the placement tool's floating ghost.
+ *
+ * Builds the door mesh via buildDoorPreviewMesh (so the preview shape stays in
+ * lockstep with committed doors), then applies ghost treatment (translucent,
+ * raycast-off, tinted red if invalid).
+ *
+ * The root mesh's layer is set to EDITOR_LAYER because the invisible hitbox
+ * material on SCENE_LAYER would poison the WebGPU MRT pass (project gotcha).
+ */
+declare const DoorPreview: ({ node, invalid, valid, }: {
+    node: DoorNode;
+    invalid?: boolean;
+    valid?: boolean;
+}) => import("react").JSX.Element;
+export default DoorPreview;
+//# sourceMappingURL=preview.d.ts.map

package/dist/door/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/door/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;GASG;AACH,QAAA,MAAM,WAAW,GAAI,2BAIlB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,gCAwBA,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/door/preview.js

@@ -0,0 +1,36 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { buildDoorPreviewMesh } from '@pascal-app/viewer';
+import { useEffect, useMemo } from 'react';
+import { applyGhost } from '../shared/ghost-materials';
+/**
+ * Translucent preview of a door — used by the placement tool's floating ghost.
+ *
+ * Builds the door mesh via buildDoorPreviewMesh (so the preview shape stays in
+ * lockstep with committed doors), then applies ghost treatment (translucent,
+ * raycast-off, tinted red if invalid).
+ *
+ * The root mesh's layer is set to EDITOR_LAYER because the invisible hitbox
+ * material on SCENE_LAYER would poison the WebGPU MRT pass (project gotcha).
+ */
+const DoorPreview = ({ node, invalid, valid, }) => {
+    const mesh = useMemo(() => {
+        const m = buildDoorPreviewMesh(node);
+        m.layers.set(EDITOR_LAYER);
+        return m;
+    }, [node]);
+    // Ghost treatment (clone + tint + raycast-off) re-applies if the tint flips;
+    // its cleanup only disposes the clones it made.
+    useEffect(() => applyGhost(mesh, { invalid, valid }), [mesh, invalid, valid]);
+    // Geometry is freshly built per `mesh` and owned here — dispose it only
+    // when the mesh itself is replaced/unmounted, never on an `invalid` toggle.
+    useEffect(() => () => {
+        mesh.traverse((obj) => {
+            const m = obj;
+            m.geometry?.dispose();
+        });
+    }, [mesh]);
+    return _jsx("primitive", { object: mesh });
+};
+export default DoorPreview;

package/dist/door/renderer.d.ts

@@ -0,0 +1,6 @@
+import { type DoorNode } from '@pascal-app/core';
+export declare const DoorRenderer: ({ node }: {
+    node: DoorNode;
+}) => import("react").JSX.Element;
+export default DoorRenderer;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/door/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/door/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAA+C,MAAM,kBAAkB,CAAA;AAQ7F,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAmCxD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/door/renderer.js

@@ -0,0 +1,26 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useRegistry, useScene } from '@pascal-app/core';
+import { useNodeEvents } from '@pascal-app/viewer';
+import { useLayoutEffect, useRef } from 'react';
+import { MeshBasicMaterial } from 'three';
+import { RoofFaceHostFrame } from '../shared/roof-face-host';
+const doorHitboxMaterial = new MeshBasicMaterial({ visible: false });
+export const DoorRenderer = ({ node }) => {
+    const ref = useRef(null);
+    useRegistry(node.id, 'door', ref);
+    useLayoutEffect(() => {
+        useScene.getState().markDirty(node.id);
+    }, [node.id]);
+    const handlers = useNodeEvents(node, 'door');
+    const liveVisible = useLiveNodeOverrides((s) => {
+        const visible = s.get(node.id)?.visible;
+        return typeof visible === 'boolean' ? visible : undefined;
+    });
+    const isTransient = !!node.metadata?.isTransient;
+    const mesh = (_jsx("mesh", { castShadow: true, material: doorHitboxMaterial, position: node.position, receiveShadow: true, ref: ref, rotation: node.rotation, visible: liveVisible ?? node.visible, ...(isTransient ? {} : handlers), children: _jsx("boxGeometry", { args: [0, 0, 0] }) }));
+    if (!node.roofSegmentId)
+        return mesh;
+    return (_jsx(RoofFaceHostFrame, { roofFace: node.roofFace, roofSegmentId: node.roofSegmentId, children: mesh }));
+};
+export default DoorRenderer;

package/dist/door/schema.d.ts

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

package/dist/door/schema.d.ts.map

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

package/dist/door/schema.js

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

package/dist/door/slots.d.ts

@@ -0,0 +1,9 @@
+import type { SlotDeclaration } from '@pascal-app/core';
+export type DoorSlotId = 'panel' | 'frame' | 'glass' | 'hardware';
+/**
+ * A door exposes four paintable slots: `panel` (leaf faces), `frame`, `glass`,
+ * and `hardware` (handle / hinges / closer / panic bar). The opening reveal
+ * keeps its own material.
+ */
+export declare function doorSlots(): SlotDeclaration[];
+//# sourceMappingURL=slots.d.ts.map

package/dist/door/slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/door/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,CAAA;AAUjE;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,eAAe,EAAE,CAO7C"}

package/dist/door/slots.js

@@ -0,0 +1,20 @@
+// Picker swatches. Rendering falls back to the live body/glass/hardware defaults
+// (which already track shading + theme), so these are just the indicator colours.
+const PANEL_DEFAULT = 'library:preset-softwhite';
+const FRAME_DEFAULT = 'library:preset-softwhite';
+const GLASS_DEFAULT = 'library:preset-glass';
+// Chrome — a flat (non-PBR) catalog metal finish.
+const HARDWARE_DEFAULT = 'library:metal-chrome';
+/**
+ * A door exposes four paintable slots: `panel` (leaf faces), `frame`, `glass`,
+ * and `hardware` (handle / hinges / closer / panic bar). The opening reveal
+ * keeps its own material.
+ */
+export function doorSlots() {
+    return [
+        { slotId: 'panel', label: 'Panel', default: PANEL_DEFAULT },
+        { slotId: 'frame', label: 'Frame', default: FRAME_DEFAULT },
+        { slotId: 'glass', label: 'Glass', default: GLASS_DEFAULT },
+        { slotId: 'hardware', label: 'Hardware', default: HARDWARE_DEFAULT },
+    ];
+}

package/dist/door/system.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Registry-driven door system bundle.
+ *
+ *  - **`DoorSystem`** — rebuilds frame / leaf / glass / hardware
+ *    geometry from `dirtyNodes`. Cascades dirty to the parent wall so
+ *    the wall cutout reflects the new door footprint.
+ *  - **`DoorAnimationSystem`** — advances `operationState` (open/close
+ *    angle for hinged, slide offset for sliding/pocket, fold angle for
+ *    folding) at frame priority 2, then marks the door dirty so the
+ *    geometry system rebuilds at priority 3.
+ *
+ * Future: extract the geometry into a pure `buildDoorGeometry(node, ctx)`
+ * and migrate to `def.geometry`. The animation system stays as
+ * `def.system` (it's a real per-frame concern, not a geometry build).
+ */
+declare const DoorSystems: () => import("react").JSX.Element;
+export default DoorSystems;
+//# sourceMappingURL=system.d.ts.map

package/dist/door/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/door/system.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,WAAW,mCAOhB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/door/system.js

@@ -0,0 +1,22 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { DoorAnimationSystem, DoorSystem } from '@pascal-app/viewer';
+/**
+ * Registry-driven door system bundle.
+ *
+ *  - **`DoorSystem`** — rebuilds frame / leaf / glass / hardware
+ *    geometry from `dirtyNodes`. Cascades dirty to the parent wall so
+ *    the wall cutout reflects the new door footprint.
+ *  - **`DoorAnimationSystem`** — advances `operationState` (open/close
+ *    angle for hinged, slide offset for sliding/pocket, fold angle for
+ *    folding) at frame priority 2, then marks the door dirty so the
+ *    geometry system rebuilds at priority 3.
+ *
+ * Future: extract the geometry into a pure `buildDoorGeometry(node, ctx)`
+ * and migrate to `def.geometry`. The animation system stays as
+ * `def.system` (it's a real per-frame concern, not a geometry build).
+ */
+const DoorSystems = () => {
+    return (_jsxs(_Fragment, { children: [_jsx(DoorAnimationSystem, {}), _jsx(DoorSystem, {})] }));
+};
+export default DoorSystems;

package/dist/door/tool.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Door tool — places DoorNodes on walls and on roof-segment wall faces
+ * (the generated base walls under a roof, including coplanar gable ends).
+ * Doors always sit at floor level (clampedY = height/2 — segment base for
+ * roof-hosted doors).
+ *
+ * The ghost follows the cursor everywhere (like moving an item): over open
+ * floor it floats as an invalid (unplaceable) ghost; the moment the cursor
+ * ray hovers a wall (or roof-segment face) the real draft snaps onto it.
+ * Snapping engages only on an actual mesh hover — no proximity magnet — since
+ * the wall side faces are big raycast targets.
+ */
+declare const DoorTool: React.FC;
+export default DoorTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/door/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/door/tool.tsx"],"names":[],"mappings":"AA8DA;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAmnBrB,CAAA;AAED,eAAe,QAAQ,CAAA"}