@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/spawn/definition.edit.js

@@ -0,0 +1,64 @@
+import { buildSpawnFloorplan } from './floorplan.js';
+import { spawnRotateAffordance } from './floorplan-affordances.js';
+import { spawnFloorplanMoveTarget } from './floorplan-move.js';
+import { spawnParametrics } from './parametrics.js';
+const SPAWN_FOOTPRINT = 0.6;
+const SPAWN_HANDLE_HEIGHT = 0.46;
+const MOVE_FRONT_OFFSET = 0.35;
+const ROTATE_CORNER_OFFSET = 0.32;
+const ROTATE_RING_OFFSET = 0.04;
+function spawnRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: () => [
+                SPAWN_FOOTPRINT / 2,
+                SPAWN_HANDLE_HEIGHT,
+                SPAWN_FOOTPRINT / 2 + ROTATE_CORNER_OFFSET,
+            ],
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: () => Math.hypot(SPAWN_FOOTPRINT / 2, SPAWN_FOOTPRINT / 2) + ROTATE_RING_OFFSET,
+            y: () => SPAWN_HANDLE_HEIGHT,
+        },
+    };
+}
+function spawnMoveHandle() {
+    return {
+        kind: 'translate',
+        placement: {
+            // Low to the floor at the front edge (matches the item move grip).
+            position: () => [0, 0.02, SPAWN_FOOTPRINT / 2 + MOVE_FRONT_OFFSET],
+        },
+        apply: (_n, pos) => ({ position: [pos[0], pos[1], pos[2]] }),
+        snapExtents: () => [SPAWN_FOOTPRINT, SPAWN_FOOTPRINT],
+    };
+}
+export const spawnEditContribution = {
+    snapProfile: 'item',
+    parametrics: spawnParametrics,
+    handles: [spawnRotateHandle(), spawnMoveHandle()],
+    // Stage C migration: floor-plan rendering via def.floorplan.
+    // floorplan-panel.tsx's `floorplanSpawnEntries` short-circuits to []
+    // when `nodeRegistry.has('spawn')`, so this builder is the single
+    // path. FloorplanRegistryLayer renders + handles click-to-select;
+    // FloorplanRegistryActionMenu handles move / duplicate (disabled) /
+    // delete. Legacy spawn click handlers in FloorplanNodeLayer become
+    // dead code once Phase 6 cleanup removes the [] entries path.
+    floorplan: buildSpawnFloorplan,
+    floorplanMoveTarget: spawnFloorplanMoveTarget,
+    floorplanAffordances: {
+        'spawn-rotate': spawnRotateAffordance,
+    },
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Left click', label: 'Place spawn point' },
+        { key: 'R / T', label: 'Rotate spawn point' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/spawn/definition.js

@@ -1,109 +1,4 @@
-import { buildSpawnFloorplan } from './floorplan.js';
-import { spawnRotateAffordance } from './floorplan-affordances.js';
-import { spawnFloorplanMoveTarget } from './floorplan-move.js';
-import { spawnParametrics } from './parametrics.js';
-import { SpawnNode } from './schema.js';
-const SPAWN_FOOTPRINT = 0.6;
-const SPAWN_HANDLE_HEIGHT = 0.46;
-const MOVE_FRONT_OFFSET = 0.35;
-const ROTATE_CORNER_OFFSET = 0.32;
-const ROTATE_RING_OFFSET = 0.04;
-function spawnRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
-        placement: {
-            position: () => [
-                SPAWN_FOOTPRINT / 2,
-                SPAWN_HANDLE_HEIGHT,
-                SPAWN_FOOTPRINT / 2 + ROTATE_CORNER_OFFSET,
-            ],
-            rotationY: () => -Math.PI / 4,
-        },
-        decoration: {
-            kind: 'ring',
-            radius: () => Math.hypot(SPAWN_FOOTPRINT / 2, SPAWN_FOOTPRINT / 2) + ROTATE_RING_OFFSET,
-            y: () => SPAWN_HANDLE_HEIGHT,
-        },
-    };
-}
-function spawnMoveHandle() {
-    return {
-        kind: 'translate',
-        placement: {
-            // Low to the floor at the front edge (matches the item move grip).
-            position: () => [0, 0.02, SPAWN_FOOTPRINT / 2 + MOVE_FRONT_OFFSET],
-        },
-        apply: (_n, pos) => ({ position: [pos[0], pos[1], pos[2]] }),
-        snapExtents: () => [SPAWN_FOOTPRINT, SPAWN_FOOTPRINT],
-    };
-}
-export const spawnDefinition = {
-    kind: 'spawn',
-    snapProfile: 'item',
-    schemaVersion: 1,
-    schema: SpawnNode,
-    category: 'site',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        position: [0, 0, 0],
-        rotation: 0,
-    }),
-    capabilities: {
-        movable: { axes: ['x', 'z'], gridSnap: true },
-        rotatable: {
-            axes: ['y'],
-            snapAngles: [0, Math.PI / 4, Math.PI / 2, (3 * Math.PI) / 4, Math.PI],
-        },
-        duplicable: false, // singleton per level
-        deletable: true,
-        selectable: { hitVolume: 'bbox' },
-        // Spawn is a singleton anchor — no meaning as a reusable preset.
-        presettable: false,
-        // Slab elevation lift via the generic `<FloorElevationSystem>`. The
-        // spawn marker is a 1.8m-tall figure with a ~0.6m ring footprint.
-        floorPlaced: {
-            footprint: () => ({ dimensions: [0.6, 1.8, 0.6], rotation: [0, 0, 0] }),
-        },
-    },
-    parametrics: spawnParametrics,
-    handles: [spawnRotateHandle(), spawnMoveHandle()],
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    // Stage C migration: floor-plan rendering via def.floorplan.
-    // floorplan-panel.tsx's `floorplanSpawnEntries` short-circuits to []
-    // when `nodeRegistry.has('spawn')`, so this builder is the single
-    // path. FloorplanRegistryLayer renders + handles click-to-select;
-    // FloorplanRegistryActionMenu handles move / duplicate (disabled) /
-    // delete. Legacy spawn click handlers in FloorplanNodeLayer become
-    // dead code once Phase 6 cleanup removes the [] entries path.
-    floorplan: buildSpawnFloorplan,
-    floorplanMoveTarget: spawnFloorplanMoveTarget,
-    floorplanAffordances: {
-        'spawn-rotate': spawnRotateAffordance,
-    },
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Left click', label: 'Place spawn point' },
-        { key: 'R / T', label: 'Rotate spawn point' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Spawn Point',
-        description: 'Player or camera origin within a level. One per level.',
-        icon: { kind: 'url', src: '/icons/spawn-point.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 90, // bottom of structure list — matches legacy palette order
-    },
-    mcp: {
-        description: 'A singleton spawn point marker placed inside a level.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { spawnEditContribution } from './definition.edit.js';
+import { spawnRenderDefinition } from './definition.render.js';
+export const spawnDefinition = composeNodeDefinition(spawnRenderDefinition, spawnEditContribution);

package/dist/spawn/definition.render.d.ts

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

package/dist/spawn/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAAC,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CA8C3F,CAAA"}

package/dist/spawn/definition.render.js

@@ -0,0 +1,48 @@
+import { SpawnNode } from './schema.js';
+export const spawnRenderDefinition = {
+    kind: 'spawn',
+    schemaVersion: 1,
+    schema: SpawnNode,
+    category: 'site',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+    }),
+    capabilities: {
+        movable: { axes: ['x', 'z'], gridSnap: true },
+        rotatable: {
+            axes: ['y'],
+            snapAngles: [0, Math.PI / 4, Math.PI / 2, (3 * Math.PI) / 4, Math.PI],
+        },
+        duplicable: false,
+        // singleton per level
+        deletable: true,
+        selectable: { hitVolume: 'bbox' },
+        // Spawn is a singleton anchor — no meaning as a reusable preset.
+        presettable: false,
+        // Slab elevation lift via the generic `<FloorElevationSystem>`. The
+        // spawn marker is a 1.8m-tall figure with a ~0.6m ring footprint.
+        floorPlaced: {
+            footprint: () => ({ dimensions: [0.6, 1.8, 0.6], rotation: [0, 0, 0] }),
+        },
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Spawn Point',
+        description: 'Player or camera origin within a level. One per level.',
+        icon: { kind: 'url', src: '/icons/spawn-point.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 90, // bottom of structure list — matches legacy palette order
+    },
+    mcp: {
+        description: 'A singleton spawn point marker placed inside a level.',
+    },
+};

package/dist/stair/definition.d.ts

@@ -1,9 +1,335 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { StairNode } from './schema.js';
-/**
- * Stair — Stage A. Composite node like roof: owns overall framing,
- * `stair-segment` children own per-flight geometry. Wrap-exports the
- * legacy `StairRenderer` + `StairSystem`.
- */
-export declare const stairDefinition: NodeDefinition<typeof StairNode>;
+export declare const stairDefinition: 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<`stair_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"stair">>;
+    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>;
+    railingMaterial: 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>>;
+    railingMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    treadMaterial: 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>>;
+    treadMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    sideMaterial: 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>>;
+    sideMaterialPreset: 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>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+    stairType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        curved: "curved";
+        spiral: "spiral";
+        straight: "straight";
+    }>>;
+    fromLevelId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    toLevelId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    deckSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+    slabOpeningMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        destination: "destination";
+        none: "none";
+    }>>;
+    openingOffset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    totalRise: import("zod").ZodOptional<import("zod").ZodNumber>;
+    designTargets: import("zod").ZodOptional<import("zod").ZodObject<{
+        maxRiserHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+        minimumGoing: import("zod").ZodDefault<import("zod").ZodNumber>;
+        targetGoing: import("zod").ZodDefault<import("zod").ZodNumber>;
+        minimumHeadroom: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    uniformRisers: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    stepCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    autoSurfaceSnap: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    destinationSurfaceId: import("zod").ZodOptional<import("zod").ZodString>;
+    thickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    fillToFloor: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    construction: import("zod").ZodOptional<import("zod").ZodObject<{
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            "center-stringer": "center-stringer";
+            open: "open";
+            "side-stringers": "side-stringers";
+            solid: "solid";
+            waist: "waist";
+        }>>;
+        waistThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+        treadThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+        riserThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+        nosing: import("zod").ZodDefault<import("zod").ZodNumber>;
+        finishThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+        closedRisers: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        stringerWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+        stringerDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    structure: import("zod").ZodOptional<import("zod").ZodObject<{
+        type: import("zod").ZodDefault<import("zod").ZodEnum<{
+            concrete: "concrete";
+            "steel-stringers": "steel-stringers";
+            "wood-stringers": "wood-stringers";
+        }>>;
+        stringerStock: import("zod").ZodDefault<import("zod").ZodEnum<{
+            "2x10": "2x10";
+            "2x12": "2x12";
+        }>>;
+        stringerType: import("zod").ZodDefault<import("zod").ZodEnum<{
+            cut: "cut";
+            housed: "housed";
+        }>>;
+        stringerSpacing: import("zod").ZodDefault<import("zod").ZodNumber>;
+        stringerCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+        treadStock: import("zod").ZodOptional<import("zod").ZodEnum<{
+            "2x12": "2x12";
+            "2x6-pair": "2x6-pair";
+            "5/4x6-pair": "5/4x6-pair";
+            "plywood-finish": "plywood-finish";
+        }>>;
+        closedRisers: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        treated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        nosing: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    innerRadius: import("zod").ZodDefault<import("zod").ZodNumber>;
+    sweepAngle: import("zod").ZodDefault<import("zod").ZodNumber>;
+    topLandingMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        integrated: "integrated";
+        none: "none";
+    }>>;
+    topLandingDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    showCenterColumn: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    showStepSupports: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    railingMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        both: "both";
+        left: "left";
+        none: "none";
+        right: "right";
+    }>>;
+    railingHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    railingStyle: import("zod").ZodOptional<import("zod").ZodEnum<{
+        balusters: "balusters";
+        boards: "boards";
+        cable: "cable";
+        glass: "glass";
+        metal: "metal";
+        "post-and-rail": "post-and-rail";
+    }>>;
+    railingPath: import("zod").ZodOptional<import("zod").ZodEnum<{
+        continuous: "continuous";
+        original: "original";
+    }>>;
+    handrail: import("zod").ZodOptional<import("zod").ZodObject<{
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            both: "both";
+            left: "left";
+            none: "none";
+            right: "right";
+        }>>;
+        height: import("zod").ZodDefault<import("zod").ZodNumber>;
+        diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+        offset: import("zod").ZodDefault<import("zod").ZodNumber>;
+        bottom: import("zod").ZodOptional<import("zod").ZodObject<{
+            extension: import("zod").ZodDefault<import("zod").ZodNumber>;
+            return: import("zod").ZodDefault<import("zod").ZodEnum<{
+                floor: "floor";
+                none: "none";
+                post: "post";
+                wall: "wall";
+            }>>;
+            returnLength: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        top: import("zod").ZodOptional<import("zod").ZodObject<{
+            extension: import("zod").ZodDefault<import("zod").ZodNumber>;
+            return: import("zod").ZodDefault<import("zod").ZodEnum<{
+                floor: "floor";
+                none: "none";
+                post: "post";
+                wall: "wall";
+            }>>;
+            returnLength: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    railingTopPost: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    railingTopReach: import("zod").ZodOptional<import("zod").ZodNumber>;
+    railingPostThrough: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`sseg_${string}`>>>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAWpB,MAAM,kBAAkB,CAAA;AAiYzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAiI5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAsE,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/stair/definition.edit.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAavE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA8XzC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CA2DxE,CAAA"}