@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/lean-to-extension/definition.js

@@ -1,433 +1,4 @@
-import { findLevelAncestorId, leanToSlots, } from '@pascal-app/core';
-import { clearStructuralElevationGuide, publishResolvedElevationGuide, } from '@pascal-app/editor';
-import { buildLeanToExtensionFloorplan } from './floorplan.js';
-import { leanToResizeAffordance, leanToRotateAffordance } from './floorplan-affordances.js';
-import { leanToFloorplanMoveTarget } from './floorplan-move.js';
-import { buildLeanToExtensionGeometry, leanToExtensionGeometryKey } from './geometry.js';
-import { leanToWallLocalPose, resolveLeanToEdgeSnapTargets, resolveLeanToHighEdgeHeightSnap, resolveLeanToLayout, resolveLeanToSpanResizeProposal, } from './layout.js';
-import { leanToManagedPreviewOverrides } from './managed-preview.js';
-import { leanToPaint } from './paint.js';
-import { deriveLeanToResizePatch, leanToExtensionParametrics } from './parametrics.js';
-import { applyLeanToRoofAttachment, resolveLeanToRoofAttachment } from './roof-attachment.js';
-import { LeanToExtensionNode } from './schema.js';
-const HEIGHT_HANDLE_OFFSET = 0.25;
-const SPAN_HANDLE_OFFSET = 0.3;
-const PITCH_HANDLE_OFFSET = 0.3;
-const ROOF_EDGE_SNAP_TOLERANCE = 0.3;
-const MIN_PITCH = 1;
-const MAX_PITCH = 45;
-function resolveConicalHost(node, sceneApi) {
-    if (!(node.hostKind === 'conical-roof' && node.parentId))
-        return null;
-    const segment = sceneApi.get(node.parentId);
-    return segment?.type === 'roof-segment' && segment.roofType === 'conical' ? segment : null;
-}
-function resolveHostWall(node, sceneApi) {
-    if (!node.parentId)
-        return null;
-    const wall = sceneApi.get(node.parentId);
-    return wall?.type === 'wall' ? wall : null;
-}
-function resolveAdjacentHeightSnap(node, newValue, sceneApi) {
-    const wall = resolveHostWall(node, sceneApi);
-    if (!wall)
-        return null;
-    return resolveLeanToHighEdgeHeightSnap(node, newValue, resolveLeanToEdgeSnapTargets(node, wall, sceneApi.nodes()));
-}
-function resolveHighEdgeConnectionSnap(node, newValue, sceneApi) {
-    const wall = resolveHostWall(node, sceneApi);
-    if (!wall)
-        return newValue;
-    const attachment = resolveLeanToRoofAttachment({ ...node, highEdgeHeight: newValue }, wall, sceneApi.nodes());
-    if (attachment && Math.abs(attachment.highEdgeHeight - newValue) <= ROOF_EDGE_SNAP_TOLERANCE) {
-        return attachment.highEdgeHeight;
-    }
-    return resolveAdjacentHeightSnap(node, newValue, sceneApi)?.highEdgeHeight ?? newValue;
-}
-function publishAdjacentHeightGuide(node, sceneApi) {
-    const wall = resolveHostWall(node, sceneApi);
-    const nodes = sceneApi.nodes();
-    const match = wall ? resolveAdjacentHeightSnap(node, node.highEdgeHeight, sceneApi) : null;
-    if (!(wall && match) || Math.abs(match.highEdgeHeight - node.highEdgeHeight) > 1e-4) {
-        clearStructuralElevationGuide(node.id);
-        return;
-    }
-    const pose = leanToWallLocalPose(wall, node, 0);
-    publishResolvedElevationGuide({
-        nodeId: node.id,
-        levelId: findLevelAncestorId(node.id, nodes),
-        anchor: [pose.position[0], pose.position[2]],
-    }, {
-        id: `${match.target.nodeId ?? 'lean-to'}:high-edge`,
-        elevation: match.target.roofEdgeY,
-        anchor: match.target.anchor ?? [pose.position[0], pose.position[2]],
-        label: 'Neighbor shed edge',
-    });
-}
-function highEdgeHeightPatch(node, newValue, sceneApi) {
-    if (node.hostKind === 'slab-edge') {
-        return {
-            ...deriveLeanToResizePatch(node, { highEdgeHeight: newValue }),
-            hostHeightOffset: node.hostHeightOffset + newValue - node.highEdgeHeight,
-            connectionMode: 'manual',
-        };
-    }
-    const conicalHost = resolveConicalHost(node, sceneApi);
-    if (conicalHost) {
-        return {
-            ...deriveLeanToResizePatch(node, { highEdgeHeight: newValue }),
-            hostHeightOffset: newValue - conicalHost.wallHeight,
-            connectionMode: 'manual',
-            hostRoofId: undefined,
-            hostRoofSegmentId: undefined,
-            hostRoofEdge: undefined,
-            hostRoofEdgeRange: undefined,
-            connectionInset: 0,
-        };
-    }
-    const wall = resolveHostWall(node, sceneApi);
-    const attachment = wall
-        ? resolveLeanToRoofAttachment({ ...node, highEdgeHeight: newValue }, wall, sceneApi.nodes())
-        : null;
-    if (attachment && Math.abs(attachment.highEdgeHeight - newValue) <= 1e-4) {
-        const connected = applyLeanToRoofAttachment(node, attachment);
-        return {
-            highEdgeHeight: connected.highEdgeHeight,
-            lowEdgeHeight: connected.lowEdgeHeight,
-            connectionMode: connected.connectionMode,
-            hostRoofId: connected.hostRoofId,
-            hostRoofSegmentId: connected.hostRoofSegmentId,
-            hostRoofEdge: connected.hostRoofEdge,
-            hostRoofEdgeRange: connected.hostRoofEdgeRange,
-            connectionInset: connected.connectionInset,
-            span: connected.span,
-            position: connected.position,
-            roofThickness: connected.roofThickness,
-            shingleThickness: connected.shingleThickness,
-        };
-    }
-    return {
-        ...deriveLeanToResizePatch(node, { highEdgeHeight: newValue }),
-        connectionMode: 'manual',
-        hostRoofId: undefined,
-        hostRoofSegmentId: undefined,
-        hostRoofEdge: undefined,
-        hostRoofEdgeRange: undefined,
-        connectionInset: 0,
-    };
-}
-function highEdgeHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        shape: 'tracker',
-        min: 0.8,
-        max: 1000,
-        currentValue: (node) => node.highEdgeHeight,
-        connectionSnap: resolveHighEdgeConnectionSnap,
-        apply: highEdgeHeightPatch,
-        previewOverrides: (node, newValue, sceneApi) => leanToManagedPreviewOverrides(node, highEdgeHeightPatch(node, newValue, sceneApi), sceneApi),
-        onDrag: publishAdjacentHeightGuide,
-        onDragEnd: (node) => clearStructuralElevationGuide(node.id),
-        placement: {
-            position: (node) => [0, node.highEdgeHeight + HEIGHT_HANDLE_OFFSET, 0],
-        },
-        measureLabel: 'High edge height',
-    };
-}
-function pitchPatch(node, lowEdgeHeight) {
-    const pitch = Math.max(MIN_PITCH, Math.min(MAX_PITCH, (Math.atan2(node.highEdgeHeight - lowEdgeHeight, Math.max(0.001, node.projection)) * 180) /
-        Math.PI));
-    return {
-        pitch,
-        lowEdgeHeight: node.highEdgeHeight - node.projection * Math.tan((pitch * Math.PI) / 180),
-    };
-}
-function pitchHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: (node) => resolveLeanToLayout({ ...node, pitch: MAX_PITCH }).lowEdgeHeight,
-        max: (node) => resolveLeanToLayout({ ...node, pitch: MIN_PITCH }).lowEdgeHeight,
-        gridSnap: true,
-        currentValue: (node) => resolveLeanToLayout(node).lowEdgeHeight,
-        apply: (node, lowEdgeHeight) => pitchPatch(node, lowEdgeHeight),
-        previewOverrides: (node, lowEdgeHeight, sceneApi) => leanToManagedPreviewOverrides(node, pitchPatch(node, lowEdgeHeight), sceneApi),
-        placement: {
-            position: (node) => {
-                const layout = resolveLeanToLayout(node);
-                return [
-                    0,
-                    layout.lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
-                    node.projection + Math.max(0, node.lowOverhang) + PITCH_HANDLE_OFFSET,
-                ];
-            },
-        },
-    };
-}
-function spanPatch(node, span, side, sceneApi) {
-    const wall = sceneApi ? resolveHostWall(node, sceneApi) : null;
-    if (wall && sceneApi) {
-        const proposal = resolveLeanToSpanResizeProposal({
-            node,
-            wall,
-            rawSpan: span,
-            side,
-            edgeSnapTargets: resolveLeanToEdgeSnapTargets(node, wall, sceneApi.nodes()),
-            tolerance: 1e-4,
-        });
-        return {
-            span: proposal.span,
-            autoSpan: false,
-            position: proposal.position,
-            ...(proposal.target
-                ? {
-                    highEdgeHeight: proposal.highEdgeHeight,
-                    lowEdgeHeight: proposal.lowEdgeHeight,
-                    pitch: proposal.pitch,
-                }
-                : {}),
-        };
-    }
-    const localSign = side === 'right' ? 1 : -1;
-    const centerShift = (localSign * (span - node.span)) / 2;
-    const cos = Math.cos(node.rotation[1]);
-    const sin = Math.sin(node.rotation[1]);
-    const deltaX = centerShift * cos;
-    const deltaZ = -centerShift * sin;
-    return {
-        span,
-        autoSpan: false,
-        position: [
-            Math.abs(deltaX) < 1e-12 ? node.position[0] : node.position[0] + deltaX,
-            node.position[1],
-            Math.abs(deltaZ) < 1e-12 ? node.position[2] : node.position[2] + deltaZ,
-        ],
-    };
-}
-function spanHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: side === 'right' ? 'min' : 'max',
-        min: 0.5,
-        max: (node, sceneApi) => {
-            const wall = resolveHostWall(node, sceneApi);
-            return wall
-                ? resolveLeanToSpanResizeProposal({
-                    node,
-                    wall,
-                    rawSpan: 100,
-                    side,
-                    tolerance: 0,
-                }).span
-                : 100;
-        },
-        currentValue: (node) => node.span,
-        connectionSnap: (node, span, sceneApi) => {
-            const wall = resolveHostWall(node, sceneApi);
-            if (!wall)
-                return span;
-            return resolveLeanToSpanResizeProposal({
-                node,
-                wall,
-                rawSpan: span,
-                side,
-                edgeSnapTargets: resolveLeanToEdgeSnapTargets(node, wall, sceneApi.nodes()),
-            }).span;
-        },
-        apply: (node, span, sceneApi) => spanPatch(node, span, side, sceneApi),
-        previewOverrides: (node, span, sceneApi) => leanToManagedPreviewOverrides(node, spanPatch(node, span, side, sceneApi), sceneApi),
-        visible: (node) => node.hostKind !== 'conical-roof',
-        placement: {
-            position: (node) => {
-                const layout = resolveLeanToLayout(node);
-                return [
-                    sign * (node.span / 2 + SPAN_HANDLE_OFFSET),
-                    layout.lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
-                    node.projection,
-                ];
-            },
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-        measureLabel: 'Span',
-    };
-}
-function circularRadiusPatch(node, radius) {
-    return {
-        span: 2 * Math.PI * radius,
-        autoSpan: true,
-        position: [0, node.position[1], radius],
-        spanArcCenterZ: -radius,
-        spanArcRadius: radius,
-    };
-}
-function circularRadiusHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: side === 'right' ? 'min' : 'max',
-        min: 0.25,
-        max: 12.5,
-        gridSnap: true,
-        currentValue: (node) => node.spanArcRadius ?? node.span / (2 * Math.PI),
-        apply: (node, radius) => circularRadiusPatch(node, radius),
-        previewOverrides: (node, radius, sceneApi) => {
-            const patch = circularRadiusPatch(node, radius);
-            const host = resolveConicalHost(node, sceneApi);
-            const entries = host
-                ? [[host.id, { width: radius * 2, depth: radius * 2 }]]
-                : [];
-            entries.push(...leanToManagedPreviewOverrides(node, patch, sceneApi));
-            return entries;
-        },
-        commit: (node, patch, sceneApi) => {
-            const host = resolveConicalHost(node, sceneApi);
-            const radius = patch.spanArcRadius;
-            if (!(host && typeof radius === 'number'))
-                return;
-            sceneApi.update(host.id, {
-                width: radius * 2,
-                depth: radius * 2,
-            });
-        },
-        visible: (node, sceneApi) => resolveConicalHost(node, sceneApi) !== null,
-        placement: {
-            position: (node) => {
-                const layout = resolveLeanToLayout(node);
-                const radius = node.spanArcRadius ?? node.span / (2 * Math.PI);
-                return [
-                    sign * (radius + layout.projection + node.lowOverhang + SPAN_HANDLE_OFFSET),
-                    layout.lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
-                    -radius,
-                ];
-            },
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-        measureLabel: 'Host radius',
-    };
-}
-function freestandingRotationHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (node, delta) => ({
-            rotation: [node.rotation[0], node.rotation[1] - delta, node.rotation[2]],
-        }),
-        visible: (node) => node.hostKind === 'freestanding',
-        placement: {
-            position: (node) => [
-                node.span / 2 + SPAN_HANDLE_OFFSET,
-                resolveLeanToLayout(node).lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
-                node.projection / 2,
-            ],
-            rotationY: () => -Math.PI / 4,
-        },
-        decoration: {
-            kind: 'ring',
-            radius: (node) => Math.hypot(node.span / 2, node.projection / 2) + 0.12,
-            y: (node) => resolveLeanToLayout(node).lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
-        },
-    };
-}
-const leanToExtensionHandles = [
-    highEdgeHeightHandle(),
-    pitchHandle(),
-    freestandingRotationHandle(),
-];
-leanToExtensionHandles.push({
-    kind: 'linear-resize',
-    axis: 'z',
-    anchor: 'min',
-    min: 0.5,
-    max: 1000,
-    currentValue: (node) => node.projection,
-    apply: (node, projection) => ({
-        projection,
-        ...deriveLeanToResizePatch(node, { projection }),
-    }),
-    placement: {
-        position: (node) => {
-            const layout = resolveLeanToLayout(node);
-            return [0, layout.lowEdgeHeight + HEIGHT_HANDLE_OFFSET, node.projection];
-        },
-    },
-    measureLabel: 'Projection',
-});
-leanToExtensionHandles.push(spanHandle('right'), spanHandle('left'));
-leanToExtensionHandles.push(circularRadiusHandle('right'), circularRadiusHandle('left'));
-export const leanToExtensionDefinition = {
-    kind: 'lean-to-extension',
-    schemaVersion: 13,
-    schema: LeanToExtensionNode,
-    category: 'structure',
-    snapProfile: 'structural',
-    extensions: {
-        'pascal:editor/floorplan': {
-            tool: () => import('./floorplan-tool.js'),
-        },
-    },
-    defaults: () => {
-        const parsed = LeanToExtensionNode.parse({});
-        const { id: _id, type: _type, ...defaults } = parsed;
-        return defaults;
-    },
-    capabilities: {
-        exterior: true,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        slots: () => leanToSlots(),
-        paint: leanToPaint,
-    },
-    relations: {
-        cascadeDelete: 'descendants',
-        hosts: ['column', 'roof'],
-    },
-    parametrics: leanToExtensionParametrics,
-    handles: leanToExtensionHandles,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    geometry: buildLeanToExtensionGeometry,
-    geometryKey: leanToExtensionGeometryKey,
-    system: {
-        module: () => import('./system.js'),
-        priority: 1,
-    },
-    floorplan: buildLeanToExtensionFloorplan,
-    floorplanMoveTarget: leanToFloorplanMoveTarget,
-    floorplanAffordances: {
-        'lean-to-resize': leanToResizeAffordance,
-        'lean-to-rotate': leanToRotateAffordance,
-    },
-    affordanceTools: { move: () => import('./move-tool.js') },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    toolHints: [
-        {
-            key: 'Left click',
-            label: 'Place canopy or set the next run point',
-        },
-        { key: 'R / T', label: 'Rotate or flip the run side' },
-        { key: 'F', label: 'Cycle mono / gable / butterfly' },
-        { key: 'Esc', label: 'End run / cancel' },
-    ],
-    presentation: {
-        label: 'Canopy',
-        description: 'An attached mono-pitch or freestanding mono, gable, or butterfly canopy with managed structure and drainage.',
-        icon: { kind: 'url', src: '/icons/lean-to-extension.webp' },
-        paletteSection: 'structure',
-        paletteGroup: 'roof-features',
-        paletteOrder: 105,
-    },
-    mcp: {
-        description: 'An open canopy that can attach to a wall or upper slab edge, stand freestanding with a mono, gable, or butterfly roof, or wrap around a conical roof base. It composes standard roof segments, gutters, downspouts, editable column children, framing, and beams.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { leanToExtensionEditContribution } from './definition.edit.js';
+import { leanToExtensionRenderDefinition } from './definition.render.js';
+export const leanToExtensionDefinition = composeNodeDefinition(leanToExtensionRenderDefinition, leanToExtensionEditContribution);

package/dist/lean-to-extension/definition.render.d.ts

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

package/dist/lean-to-extension/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAE9C,eAAO,MAAM,+BAA+B,EAAE,oBAAoB,CAAC,OAAO,mBAAmB,CAAC,GAAG;IAC/F,IAAI,EAAE,mBAAmB,CAAA;CA6C1B,CAAA"}

package/dist/lean-to-extension/definition.render.js

@@ -0,0 +1,46 @@
+import { leanToSlots } from '@pascal-app/core';
+import { buildLeanToExtensionGeometry, leanToExtensionGeometryKey } from './geometry.js';
+import { LeanToExtensionNode } from './schema.js';
+export const leanToExtensionRenderDefinition = {
+    kind: 'lean-to-extension',
+    schemaVersion: 13,
+    schema: LeanToExtensionNode,
+    category: 'structure',
+    defaults: () => {
+        const parsed = LeanToExtensionNode.parse({});
+        const { id: _id, type: _type, ...defaults } = parsed;
+        return defaults;
+    },
+    capabilities: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        slots: () => leanToSlots(),
+    },
+    relations: {
+        cascadeDelete: 'descendants',
+        hosts: ['column', 'roof'],
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    geometry: buildLeanToExtensionGeometry,
+    geometryKey: leanToExtensionGeometryKey,
+    system: {
+        module: () => import('./system.js'),
+        priority: 1,
+    },
+    presentation: {
+        label: 'Canopy',
+        description: 'An attached mono-pitch or freestanding mono, gable, or butterfly canopy with managed structure and drainage.',
+        icon: { kind: 'url', src: '/icons/lean-to-extension.webp' },
+        paletteSection: 'structure',
+        paletteGroup: 'roof-features',
+        paletteOrder: 105,
+    },
+    mcp: {
+        description: 'An open canopy that can attach to a wall or upper slab edge, stand freestanding with a mono, gable, or butterfly roof, or wrap around a conical roof base. It composes standard roof segments, gutters, downspouts, editable column children, framing, and beams.',
+    },
+};

package/dist/level/definition.d.ts

@@ -1,9 +1,50 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { LevelNode } from './schema.js';
-/**
- * Level — Stage A. Container for walls / slabs / ceilings / etc. on
- * a single floor. `LevelSystem` does level-wide work (Y-position
- * snapping to true positions when levels reorder); wrap-exported.
- */
-export declare const levelDefinition: NodeDefinition<typeof LevelNode>;
+export declare const levelDefinition: 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<`level_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"level">>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<`beam_${string}` | `block_${string}` | `ceiling_${string}` | `column_${string}` | `construction-dimension_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `slab_${string}` | `spawn_${string}` | `stair_${string}` | `structural-grid_${string}` | `wall_${string}` | `zone_${string}`, string>>>>;
+    level: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseElevation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

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

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

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

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

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

package/dist/level/definition.edit.js

@@ -0,0 +1,4 @@
+import { levelParametrics } from './parametrics.js';
+export const levelEditContribution = {
+    parametrics: levelParametrics,
+};

package/dist/level/definition.js

@@ -1,60 +1,4 @@
-import { DEFAULT_LEVEL_HEIGHT, LevelNode as LevelNodeSchema, } from '@pascal-app/core';
-import { levelParametrics } from './parametrics.js';
-import { LevelNode } from './schema.js';
-/**
- * Level — Stage A. Container for walls / slabs / ceilings / etc. on
- * a single floor. `LevelSystem` does level-wide work (Y-position
- * snapping to true positions when levels reorder); wrap-exported.
- */
-export const levelDefinition = {
-    kind: 'level',
-    schemaVersion: 2,
-    schema: LevelNode,
-    category: 'site',
-    defaults: () => {
-        const stub = LevelNodeSchema.parse({
-            id: 'level_default',
-            type: 'level',
-            height: DEFAULT_LEVEL_HEIGHT,
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: false,
-        // Level is a container — selection happens via the sidebar tree
-        // and the floating level switcher, never via 3D click. Declaring
-        // `selectable` here would make `getSelectableKinds()` add the
-        // kind to `SelectionManager`'s subscription list, and the event
-        // would fire on every wall/slab/ceiling click that bubbled to the
-        // level group — selecting the level instead of the actual node
-        // hit. Legacy `allTypes` deliberately omitted containers; we
-        // mirror that.
-        duplicable: false,
-        deletable: true,
-        // Container kind — saving a level as a standalone preset has no
-        // meaning (its contents make sense only inside a building).
-        presettable: false,
-    },
-    parametrics: levelParametrics,
-    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
-    dirtyTracking: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    system: {
-        module: () => import('./system.js'),
-        priority: 1,
-    },
-    presentation: {
-        label: 'Level',
-        description: 'A single floor of a building, holding walls / slabs / ceilings / items.',
-        icon: { kind: 'url', src: '/icons/level.webp' },
-        paletteSection: 'site',
-        paletteOrder: 7,
-    },
-    mcp: {
-        description: 'A level (floor) container under a building.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { levelEditContribution } from './definition.edit.js';
+import { levelRenderDefinition } from './definition.render.js';
+export const levelDefinition = composeNodeDefinition(levelRenderDefinition, levelEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/level/definition.render.ts"],"names":[],"mappings":"AACA,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;CAkD3F,CAAA"}