@pascal-app/nodes 1.0.7 → 1.1.1

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

@@ -1,13 +1,69 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { DuctTerminalNode } from './schema.js';
-/**
- * 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>;
+export declare const ductTerminalDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`duct-terminal_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"duct-terminal">>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+    terminalType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        diffuser: "diffuser";
+        "return-grille": "return-grille";
+        "supply-register": "supply-register";
+    }>>;
+    mount: import("zod").ZodDefault<import("zod").ZodEnum<{
+        ceiling: "ceiling";
+        floor: "floor";
+        wall: "wall";
+    }>>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    collarShape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        oval: "oval";
+        rect: "rect";
+        round: "round";
+    }>>;
+    collarDiameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    collarWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    collarHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGlC,CAAA"}

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

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { DuctTerminalNode } from './schema.js';
+export declare const ductTerminalEditContribution: NodeEditContribution<typeof DuctTerminalNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAAC,OAAO,gBAAgB,CAUtF,CAAA"}

package/dist/duct-terminal/definition.edit.js

@@ -0,0 +1,12 @@
+import { ductTerminalParametrics } from './parametrics.js';
+export const ductTerminalEditContribution = {
+    snapProfile: 'item',
+    parametrics: ductTerminalParametrics,
+    tool: () => import('./tool.js'),
+    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' },
+    ],
+};

package/dist/duct-terminal/definition.js

@@ -1,87 +1,4 @@
-import { buildDuctTerminalFloorplan } from './floorplan.js';
-import { buildDuctTerminalGeometry } from './geometry.js';
-import { ductTerminalParametrics } from './parametrics.js';
-import { getDuctTerminalPorts } from './ports.js';
-import { DuctTerminalNode } from './schema.js';
-/**
- * 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.js'),
-    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.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { ductTerminalEditContribution } from './definition.edit.js';
+import { ductTerminalRenderDefinition } from './definition.render.js';
+export const ductTerminalDefinition = composeNodeDefinition(ductTerminalRenderDefinition, ductTerminalEditContribution);

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

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { DuctTerminalNode } from './schema.js';
+export declare const ductTerminalRenderDefinition: NodeRenderDefinition<typeof DuctTerminalNode> & {
+    kind: 'duct-terminal';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAE3C,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAAC,OAAO,gBAAgB,CAAC,GAAG;IACzF,IAAI,EAAE,eAAe,CAAA;CAmEtB,CAAA"}

package/dist/duct-terminal/definition.render.js

@@ -0,0 +1,68 @@
+import { buildDuctTerminalFloorplan } from './floorplan.js';
+import { buildDuctTerminalGeometry } from './geometry.js';
+import { getDuctTerminalPorts } from './ports.js';
+import { DuctTerminalNode } from './schema.js';
+export const ductTerminalRenderDefinition = {
+    kind: 'duct-terminal',
+    schemaVersion: 1,
+    schema: DuctTerminalNode,
+    category: 'utility',
+    distributionRole: 'terminal',
+    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',
+        },
+    },
+    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,
+    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/geometry.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,EAIN,MAAM,OAAO,CAAA;AAId,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

@@ -1,5 +1,6 @@
 import { BoxGeometry, CylinderGeometry, Group, Mesh, MeshStandardMaterial, Vector3, } from 'three';
-import { createOvalSectionGeometry, INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { createOvalSectionGeometry } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 import { COLLAR_LENGTH, mountQuaternion, terminalSystem } from './ports.js';
 const RADIAL_SEGMENTS = 20;
 /** Radial clearance (meters) the collar sleeve carries over the duct's

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

@@ -1 +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"}
+{"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,CAqE1E,CAAA"}

package/dist/duct-terminal/parametrics.js

@@ -1,4 +1,5 @@
 export const ductTerminalParametrics = {
+    trailingSection: () => import('../shared/duct-collar-inspector.js'),
     groups: [
         {
             label: 'Terminal',

package/dist/duct-terminal/ports.js

@@ -1,5 +1,5 @@
 import { Euler, Quaternion, Vector3 } from 'three';
-import { equivalentDiameterIn, ovalEquivalentDiameterIn } from '../duct-segment/geometry.js';
+import { equivalentDiameterIn, ovalEquivalentDiameterIn } from '../duct-segment/profile.js';
 /** Collar stub length in meters behind the face. */
 export const COLLAR_LENGTH = 0.12;
 /**

package/dist/elevator/__bench__/runtime.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/elevator/__bench__/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/elevator/__bench__/runtime.ts"],"names":[],"mappings":""}

package/dist/elevator/__bench__/runtime.js

@@ -0,0 +1,38 @@
+import { BlockNode, BuildingNode, ElevatorNode, LevelNode, stepElevatorRuntimes, useInteractive, useScene, } from '@pascal-app/core';
+const building = BuildingNode.parse({});
+const levels = [0, 1].map((level) => LevelNode.parse({ parentId: building.id, level, height: 3 }));
+const elevators = Array.from({ length: 20 }, () => ElevatorNode.parse({
+    parentId: building.id,
+    fromLevelId: levels[0].id,
+    toLevelId: levels[1].id,
+}));
+building.children = [
+    ...levels.map((level) => level.id),
+    ...elevators.map((elevator) => elevator.id),
+];
+const values = [
+    building,
+    ...levels,
+    ...elevators,
+    ...Array.from({ length: 2000 }, () => BlockNode.parse({ parentId: levels[0].id })),
+];
+let scans = 0;
+const nodes = new Proxy(Object.fromEntries(values.map((node) => [node.id, node])), {
+    ownKeys(target) {
+        scans++;
+        return Reflect.ownKeys(target);
+    },
+});
+useScene.setState({ nodes });
+useInteractive.setState({ elevators: {} });
+stepElevatorRuntimes(0, 1 / 60);
+const warmupScans = scans;
+for (let frame = 1; frame <= 100; frame++)
+    stepElevatorRuntimes((frame * 1000) / 60, 1 / 60);
+console.log(JSON.stringify({
+    nodes: values.length,
+    elevators: elevators.length,
+    idleFrames: 100,
+    warmupSceneScans: warmupScans,
+    idleSceneScans: scans - warmupScans,
+}));

package/dist/elevator/definition.d.ts

@@ -1,11 +1,118 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { ElevatorNode } from './schema.js';
-/**
- * Elevator — Stage A registration. Wrap-exports the legacy renderer +
- * the three legacy systems (runtime / interaction / opening) bundled
- * as one `def.system`. Move / inspector still go through legacy
- * (`MoveElevatorTool`, `<ElevatorPanel>`) via panel-manager's
- * hardcoded switch.
- */
-export declare const elevatorDefinition: NodeDefinition<typeof ElevatorNode>;
+export declare const elevatorDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`elevator_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"elevator">>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    shaftDepth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    shaftWallThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        glass: "glass";
+        solid: "solid";
+    }>>;
+    cabHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    doorWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    doorHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    doorStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "center-opening": "center-opening";
+        "single-left": "single-left";
+        "single-right": "single-right";
+    }>>;
+    doorPanelStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "glass-frame": "glass-frame";
+        "segmented-panel": "segmented-panel";
+        "solid-panel": "solid-panel";
+    }>>;
+    fromLevelId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    toLevelId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    servedLevelIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    disabledLevelIds: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    serviceOnlyLevelIds: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    defaultLevelId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    speed: import("zod").ZodDefault<import("zod").ZodNumber>;
+    doorDurationMs: import("zod").ZodDefault<import("zod").ZodNumber>;
+    dwellMs: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/elevator/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/elevator/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAUL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAqJvC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CAgHlE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/elevator/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG9B,CAAA"}

package/dist/elevator/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { ElevatorNode } from './schema.js';
+export declare const elevatorEditContribution: NodeEditContribution<typeof ElevatorNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/elevator/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/elevator/definition.edit.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAKvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAsJ5C,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,OAAO,YAAY,CA4B9E,CAAA"}