@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/box-vent/definition.js

@@ -1,212 +1,4 @@
-import { BoxVentNode as BoxVentNodeSchema, boxVentSlots, } from '@pascal-app/core';
-import { buildBoxVentFloorplan } from './floorplan.js';
-import { boxVentPaint } from './paint.js';
-import { boxVentParametrics } from './parametrics.js';
-import { BoxVentNode } from './schema.js';
-// Edge-to-arrow-center offset, matching the chimney / dormer cadence.
-const SIDE_HANDLE_OFFSET = 0.25;
-const HEIGHT_HANDLE_OFFSET = 0.2;
-// Snug to the vent corner — vents are small (default 0.4 m), so the big
-// chimney/dormer offset floated the rotate icon far off the item.
-const ROTATE_CORNER_OFFSET = 0.1;
-// Min sizes — vents are small (default 0.4 × 0.4 × 0.15), so the floor
-// is well below the default values to allow shrinking without locking.
-const MIN_DIM = 0.1;
-const MIN_HEIGHT = 0.05;
-// Mid-Y of the vent body in vent-mesh-local. The vent sits with its base
-// at y=0 on the slope, so mid is half the height. Side / depth / rotate
-// chevrons all place their handle at this Y to read as "this dimension
-// is the vent body".
-function getBodyMidY(n) {
-    return Math.max(0.001, n.height) / 2;
-}
-// Width arrow on the +X (right) or -X (left) side of the vent body.
-// Asymmetric resize — anchored edge stays world-fixed by recentering
-// `position` along the vent's own +X arm in segment frame (matches the
-// chimney / dormer width handle math). The slope tilt rotates around
-// the vent's base point, so segment-local XZ of the anchored edge stays
-// the same regardless of tilt; only the yaw matters for the projection.
-function boxVentWidthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: side === 'right' ? 'min' : 'max',
-        min: MIN_DIM,
-        currentValue: (n) => n.width,
-        apply: (initial, newWidth) => {
-            const rotY = initial.rotation ?? 0;
-            const armX = Math.cos(rotY);
-            const armZ = -Math.sin(rotY);
-            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
-            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
-            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
-            return {
-                width: newWidth,
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
-        placement: {
-            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), getBodyMidY(n), 0],
-            // Flip the left chevron so it points outward toward -X. The
-            // generic LinearArrow auto-orients for axis 'z'; +X / -X facing
-            // is up to the descriptor.
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-    };
-}
-// Depth arrow on the +Z side. Symmetric (anchor 'center') matches the
-// chimney / dormer handle count budget — splitting into asymmetric front /
-// back chevrons here would push the vent over the same TSL/MRT pipeline
-// threshold those nodes already document. Single symmetric chevron grows
-// the depth from the centre.
-function boxVentDepthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'z',
-        anchor: 'center',
-        min: MIN_DIM,
-        currentValue: (n) => n.depth,
-        apply: (_n, newValue) => ({ depth: newValue }),
-        placement: {
-            position: (n) => [0, getBodyMidY(n), n.depth / 2 + SIDE_HANDLE_OFFSET],
-        },
-    };
-}
-// Height arrow above the top of the vent. anchor='min' so the base stays
-// pinned to the slope at vent-local y=0 and the top edge follows the
-// pointer. Plain chevron (not tracker) — at default sizes (~0.15 m) a
-// dashed leader from base to top reads as visual noise rather than a
-// dimension cue.
-function boxVentHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_HEIGHT,
-        currentValue: (n) => n.height,
-        apply: (_n, newValue) => ({ height: Math.max(MIN_HEIGHT, newValue) }),
-        placement: {
-            position: (n) => [0, Math.max(n.height, MIN_HEIGHT) + HEIGHT_HANDLE_OFFSET, 0],
-        },
-    };
-}
-// Whole-vent rotation gizmo at the +X/+Z corner of the body footprint.
-// The registered group already centres on the vent and applies its
-// composed slope+yaw quaternion, so the default rotation pivot is
-// correct — no `rotationCenter` override needed.
-function boxVentRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
-        placement: {
-            position: (n) => [
-                n.width / 2 + ROTATE_CORNER_OFFSET,
-                getBodyMidY(n),
-                n.depth / 2 + ROTATE_CORNER_OFFSET,
-            ],
-            // Aim the two-headed icon along the +X+Z corner bisector.
-            rotationY: () => -Math.PI / 4,
-        },
-        // Guide ring centred on the vent (drawn at the handle-frame origin),
-        // sized to pass through the corner icon so the icon rides the ring and
-        // the whole control reads as encircling the item — matches solar-panel.
-        decoration: {
-            kind: 'ring',
-            radius: (n) => Math.hypot(n.width / 2 + ROTATE_CORNER_OFFSET, n.depth / 2 + ROTATE_CORNER_OFFSET),
-            y: (n) => getBodyMidY(n),
-        },
-    };
-}
-// `portal: 'grandparent'` on every handle: the vent mesh is mounted under
-// the roof's `roof-elements` group (reproducing the segment transform), so
-// the handle rig must ride the roof→segment→node frame chain — same as
-// solar-panel / skylight. Without it the handles (and the rotate arc) mount
-// in the bare segment-mesh frame and render offset from the vent.
-const boxVentHandles = [
-    boxVentWidthHandle('right'),
-    boxVentWidthHandle('left'),
-    boxVentDepthHandle(),
-    boxVentHeightHandle(),
-    boxVentRotateHandle(),
-].map((h) => ({ ...h, portal: 'grandparent' }));
-/**
- * Box vent — a small louvered ventilation box that sits on a roof
- * slope. Parented to a `roof-segment`; position is segment-local;
- * rotation rotates the vent around the segment's vertical axis after
- * the slope tilt is applied.
- *
- * Composition (three-checkbox model):
- *  - **`renderer` (custom)** — the box-vent needs the parent segment's
- *    position + rotation + slope geometry to position itself, and the
- *    registry-era roof-segment renderer doesn't auto-nest children
- *    (its mesh is filled by `RoofSystem`). The custom renderer reads
- *    the segment from `useScene`, applies the transform stack, and
- *    follows the segment's `useLiveTransforms` override during a
- *    parent drag.
- *  - **no `geometry`** — geometry is created inside the renderer via
- *    the shared pure builder in `./geometry`. We could lift it to
- *    `def.geometry` once roof-segment migrates to the parametric path
- *    (Phase 5 Stage B); for now keeping it inside the renderer
- *    matches the legacy mount semantics one-for-one.
- *  - **no `system`** — no animations, no cross-kind cascades.
- *
- * The bespoke move flow (segment-hopping with hit-tests against every
- * sibling roof-segment) ports later as `affordanceTools.move`. The
- * placement `def.tool` listens to `roof:*` events and creates a new
- * vent on click.
- */
-export const boxVentDefinition = {
-    kind: 'box-vent',
-    schemaVersion: 3,
-    schema: BoxVentNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    defaults: () => {
-        const stub = BoxVentNodeSchema.parse({ id: 'bvent_default', type: 'box-vent' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        slots: boxVentSlots,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        paint: boxVentPaint,
-        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
-        // slope — no `buildCut`, just the dirty cascade so the parent
-        // roof's merged shell rebuilds when the vent moves / resizes.
-        roofAccessory: {},
-    },
-    parametrics: boxVentParametrics,
-    handles: boxVentHandles,
-    floorplan: buildBoxVentFloorplan,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Place box vent on roof' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Box Vent',
-        description: 'Small louvered exhaust vent that sits on a roof slope.',
-        icon: { kind: 'url', src: '/icons/box-vent.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 120,
-    },
-    mcp: {
-        description: 'A louvered box vent sitting on a roof segment. Style: standard / low-profile / dome. Width/depth/height/hoodOverhang parametric.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { boxVentEditContribution } from './definition.edit.js';
+import { boxVentRenderDefinition } from './definition.render.js';
+export const boxVentDefinition = composeNodeDefinition(boxVentRenderDefinition, boxVentEditContribution);

package/dist/box-vent/definition.render.d.ts

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

package/dist/box-vent/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/box-vent/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,OAAO,WAAW,CAAC,GAAG;IAC/E,IAAI,EAAE,UAAU,CAAA;CAuCjB,CAAA"}

package/dist/box-vent/definition.render.js

@@ -0,0 +1,40 @@
+import { BoxVentNode as BoxVentNodeSchema, boxVentSlots } from '@pascal-app/core';
+import { BoxVentNode } from './schema.js';
+export const boxVentRenderDefinition = {
+    kind: 'box-vent',
+    schemaVersion: 3,
+    schema: BoxVentNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = BoxVentNodeSchema.parse({ id: 'bvent_default', type: 'box-vent' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        slots: boxVentSlots,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
+        // slope — no `buildCut`, just the dirty cascade so the parent
+        // roof's merged shell rebuilds when the vent moves / resizes.
+        roofAccessory: {},
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Box Vent',
+        description: 'Small louvered exhaust vent that sits on a roof slope.',
+        icon: { kind: 'url', src: '/icons/box-vent.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 120,
+    },
+    mcp: {
+        description: 'A louvered box vent sitting on a roof segment. Style: standard / low-profile / dome. Width/depth/height/hoodOverhang parametric.',
+    },
+};

package/dist/box-vent/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/box-vent/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,sCAiOtE"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/box-vent/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AA0BzB;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,sCAkOtE"}

package/dist/box-vent/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
-import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { consumePlacementDragRelease, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useCallback, useEffect, useState } from 'react';
 import * as THREE from 'three';
 import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag.js';
@@ -56,9 +56,9 @@ export default function MoveBoxVentTool({ node }) {
             if (!rawTarget)
                 return null;
             return snapRoofSurfaceNodeTarget({
-                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true),
+                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.altKey === true),
                 node,
-                bypass: event.nativeEvent?.shiftKey === true,
+                bypass: !isMagneticSnapActive() || event.nativeEvent?.altKey === true,
             });
         };
         const updatePreview = (event) => {
@@ -70,7 +70,8 @@ export default function MoveBoxVentTool({ node }) {
             lastTarget = target;
             const sx = Math.round(target.localX * 20) / 20;
             const sz = Math.round(target.localZ * 20) / 20;
-            if (event.nativeEvent?.shiftKey !== true &&
+            if (isGridSnapActive() &&
+                event.nativeEvent?.altKey !== true &&
                 (!lastSnap || lastSnap[0] !== sx || lastSnap[1] !== sz)) {
                 triggerSFX('sfx:grid-snap');
                 lastSnap = [sx, sz];
@@ -127,7 +128,7 @@ export default function MoveBoxVentTool({ node }) {
                 position: [target.localX, target.localY, target.localZ],
                 rotation: original.rotation,
                 visible: true,
-                metadata: {},
+                metadata: stripPlacementMetadataFlags(original.metadata),
             });
             useScene.temporal.getState().pause();
             st.dirtyNodes.add(targetSegmentId);

package/dist/building/definition.d.ts

@@ -1,12 +1,50 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { BuildingNode } from './schema.js';
-/**
- * Building — Stage A. Container for levels; can be translated /
- * rotated as a whole (movable + rotatable on Y). The legacy
- * `MoveBuildingContent` handles building-wide drag; the registry
- * fallback would translate position, which is close to right —
- * but kept legacy at Stage A to avoid disturbing the building's
- * world-space group transform handling.
- */
-export declare const buildingDefinition: NodeDefinition<typeof BuildingNode>;
+export declare const buildingDefinition: 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<`building_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"building">>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`level_${string}`>>, import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`elevator_${string}`>>, import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`unit_${string}`>>]>>>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    groundLevelId: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`level_${string}`>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/building/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAE1F,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CAiDlE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/building/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG9B,CAAA"}

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

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

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

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

package/dist/building/definition.edit.js

@@ -0,0 +1,10 @@
+import { buildingParametrics } from './parametrics.js';
+export const buildingEditContribution = {
+    // Building-wide drag (whole-building translate + R/T rotation). Routed
+    // through `MoveTool`'s registry-affordance lookup rather than a
+    // hardcoded dispatcher arm.
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    parametrics: buildingParametrics,
+};

package/dist/building/definition.js

@@ -1,54 +1,4 @@
-import { BuildingNode as BuildingNodeSchema } from '@pascal-app/core';
-import { buildingParametrics } from './parametrics.js';
-import { BuildingNode } from './schema.js';
-/**
- * Building — Stage A. Container for levels; can be translated /
- * rotated as a whole (movable + rotatable on Y). The legacy
- * `MoveBuildingContent` handles building-wide drag; the registry
- * fallback would translate position, which is close to right —
- * but kept legacy at Stage A to avoid disturbing the building's
- * world-space group transform handling.
- */
-export const buildingDefinition = {
-    kind: 'building',
-    schemaVersion: 3,
-    schema: BuildingNode,
-    category: 'site',
-    defaults: () => {
-        const stub = BuildingNodeSchema.parse({ id: 'building_default', type: 'building' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: false,
-        // Building is a container — sidebar / building switcher drive
-        // selection, never 3D click. Same reasoning as `level` / `site`.
-        duplicable: false,
-        deletable: false,
-        floorplanLevelContainer: true,
-        presettable: false,
-    },
-    // Building-wide drag (whole-building translate + R/T rotation). Routed
-    // through `MoveTool`'s registry-affordance lookup rather than a
-    // hardcoded dispatcher arm.
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    parametrics: buildingParametrics,
-    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
-    dirtyTracking: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    presentation: {
-        label: 'Building',
-        description: 'A building container holding one or more levels.',
-        icon: { kind: 'url', src: '/icons/building.webp' },
-        paletteSection: 'site',
-        paletteOrder: 6,
-    },
-    mcp: {
-        description: 'A building container that groups levels.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { buildingEditContribution } from './definition.edit.js';
+import { buildingRenderDefinition } from './definition.render.js';
+export const buildingDefinition = composeNodeDefinition(buildingRenderDefinition, buildingEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/building/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,OAAO,YAAY,CAAC,GAAG;IACjF,IAAI,EAAE,UAAU,CAAA;CAoCjB,CAAA"}

package/dist/building/definition.render.js

@@ -0,0 +1,38 @@
+import { BuildingNode as BuildingNodeSchema } from '@pascal-app/core';
+import { BuildingNode } from './schema.js';
+export const buildingRenderDefinition = {
+    kind: 'building',
+    schemaVersion: 3,
+    schema: BuildingNode,
+    category: 'site',
+    defaults: () => {
+        const stub = BuildingNodeSchema.parse({ id: 'building_default', type: 'building' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: false,
+        // Building is a container — sidebar / building switcher drive
+        // selection, never 3D click. Same reasoning as `level` / `site`.
+        duplicable: false,
+        deletable: false,
+        floorplanLevelContainer: true,
+        presettable: false,
+    },
+    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
+    dirtyTracking: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Building',
+        description: 'A building container holding one or more levels.',
+        icon: { kind: 'url', src: '/icons/building.webp' },
+        paletteSection: 'site',
+        paletteOrder: 6,
+    },
+    mcp: {
+        description: 'A building container that groups levels.',
+    },
+};