@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/shelf/definition.render.js

@@ -0,0 +1,124 @@
+import { shelfSlots } from '@pascal-app/core';
+import { staticBatchable } from '../shared/node-batch/batchable.js';
+import { sanitizeShelfDimensions } from './dimensions.js';
+import { buildShelfFloorplan } from './floorplan.js';
+import { buildShelfGeometry, shelfRowSurfaceYs } from './geometry.js';
+import { ShelfNode } from './schema.js';
+export const shelfRenderDefinition = {
+    kind: 'shelf',
+    schemaVersion: 2,
+    schema: ShelfNode,
+    category: 'furnish',
+    surfaceRole: 'joinery',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        width: 1,
+        depth: 0.5,
+        thickness: 0.05,
+        height: 1.8,
+        style: 'cubby',
+        rows: 3,
+        columns: 2,
+        withBack: true,
+        withSides: true,
+        withBottom: true,
+        bracketStyle: 'minimal',
+        // material / materialPreset left undefined — geometry falls back to
+        // the per-slot off-white default, and slot paint mode writes chosen
+        // catalog materials into `slots`.
+    }),
+    capabilities: {
+        batchable: staticBatchable,
+        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
+        revealOnEdit: ['width', 'depth', 'height', 'thickness', 'rows', 'columns', 'style'],
+        movable: { axes: ['x', 'z'], gridSnap: true },
+        rotatable: {
+            axes: ['y'],
+            snapAngles: [0, Math.PI / 4, Math.PI / 2, (3 * Math.PI) / 4, Math.PI],
+        },
+        // Multi-row hosting: each row's top board exposes a surface so items
+        // can stack on whichever row the cursor targets. `surfaces.top`
+        // points at the topmost board (legacy compatibility — code that
+        // assumes a single surface still works). `surfaces.custom` emits
+        // one `SurfacePoint` per row centered on (0, rowY, 0) — the
+        // placement coordinator's shelf strategy picks the closest by
+        // cursor local-Y and snaps there.
+        surfaces: {
+            top: { height: (n) => shelfRowSurfaceYs(n).at(-1) ?? 0 },
+            custom: (n) => shelfRowSurfaceYs(n).map((y) => ({
+                position: [0, y, 0],
+                normal: [0, 1, 0],
+            })),
+        },
+        selectable: { hitVolume: 'bbox' },
+        duplicable: { subtree: 'with-children' },
+        deletable: true,
+        slots: (n) => shelfSlots(n),
+        // Slab elevation lift via the generic `<FloorElevationSystem>` — a
+        // shelf sitting over a raised slab visually rests on top of it.
+        floorPlaced: {
+            footprint: (node) => {
+                const shelf = sanitizeShelfDimensions(node);
+                return {
+                    dimensions: [shelf.width, shelf.height, shelf.depth],
+                    rotation: shelf.rotation,
+                };
+            },
+            collides: true,
+        },
+    },
+    // Items host on shelves the same way they host on slabs / other items —
+    // declared here so the placement coordinator's shelf strategy can
+    // confirm parent-kind compatibility before reparenting.
+    relations: {
+        hosts: ['item', 'procedural-item'],
+        cascadeDelete: 'descendants',
+    },
+    // Three-checkbox composition: shelf needs only pure builder functions.
+    // The framework's <ParametricNodeRenderer> + <GeometrySystem> handle 3D
+    // mount and rebuild on dirty; the <FloorplanRegistryLayer> calls
+    // buildShelfFloorplan for the 2D top-down view. No renderer.tsx, no
+    // system.tsx, no inline floor-plan SVG — see
+    // `wiki/architecture/node-definitions.md`.
+    geometry: buildShelfGeometry,
+    // Boards/posts/back depend only on these fields — never on hosted
+    // `children`. Lets <GeometrySystem> skip the dispose+rebuild (and the
+    // pointer enter/leave churn it causes) when an item reparents onto a row.
+    geometryChildTypes: [],
+    geometryKey: (n) => {
+        const s = sanitizeShelfDimensions(n);
+        return JSON.stringify([
+            s.style,
+            s.width,
+            s.depth,
+            s.thickness,
+            s.height,
+            s.rows,
+            s.columns,
+            s.withBack,
+            s.withSides,
+            s.withBottom,
+            s.bracketStyle,
+            s.material,
+            s.materialPreset,
+            JSON.stringify(s.slots ?? null),
+        ]);
+    },
+    floorplan: buildShelfFloorplan,
+    presentation: {
+        label: 'Shelf',
+        description: 'A configurable shelving unit. Items host on each row.',
+        icon: { kind: 'url', src: '/icons/shelf.webp' },
+        paletteSection: 'furnish',
+        paletteOrder: 30,
+    },
+    mcp: {
+        description: 'A parametric shelving unit. Four styles (wall-shelf / bookshelf / open-rack / cubby) with configurable rows, columns, sides, and back. Items host on each row.',
+    },
+};

package/dist/site/definition.d.ts

@@ -1,10 +1,313 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { SiteNode } from './schema.js';
-/**
- * Site — Stage A. Top-level container under the scene root; holds
- * buildings + property-line polygon + zones. No system (sites don't
- * have per-frame work). Not movable / deletable — they're the scene
- * root.
- */
-export declare const siteDefinition: NodeDefinition<typeof SiteNode>;
+export declare const siteDefinition: 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<`site_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"site">>;
+    polygon: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"polygon">;
+        points: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    }, import("zod/v4/core").$strip>>>;
+    terrain: import("zod").ZodOptional<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"heightfield">;
+        origin: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        spacing: import("zod").ZodNumber;
+        cols: import("zod").ZodNumber;
+        rows: import("zod").ZodNumber;
+        step: import("zod").ZodNumber;
+        heights: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    showGround: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    presentation: import("zod").ZodOptional<import("zod").ZodObject<{
+        theme: import("zod").ZodOptional<import("zod").ZodString>;
+        exposure: import("zod").ZodOptional<import("zod").ZodNumber>;
+        shading: import("zod").ZodOptional<import("zod").ZodEnum<{
+            rendered: "rendered";
+            solid: "solid";
+        }>>;
+        edges: import("zod").ZodOptional<import("zod").ZodEnum<{
+            off: "off";
+            soft: "soft";
+            strong: "strong";
+        }>>;
+        shadows: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        lighting: import("zod").ZodOptional<import("zod").ZodObject<{
+            background: import("zod").ZodOptional<import("zod").ZodString>;
+            backgroundSky: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            ground: import("zod").ZodOptional<import("zod").ZodString>;
+            ambient: import("zod").ZodOptional<import("zod").ZodObject<{
+                color: import("zod").ZodString;
+                intensity: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            hemi: import("zod").ZodOptional<import("zod").ZodObject<{
+                sky: import("zod").ZodString;
+                ground: import("zod").ZodString;
+                intensity: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            lights: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                color: import("zod").ZodString;
+                intensity: import("zod").ZodNumber;
+                position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                target: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                castShadow: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                shadow: import("zod").ZodOptional<import("zod").ZodObject<{
+                    intensity: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    bias: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    normalBias: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    radius: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    mapSize: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<512>, import("zod").ZodLiteral<1024>, import("zod").ZodLiteral<2048>, import("zod").ZodLiteral<4096>]>>;
+                    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+                        left: import("zod").ZodNumber;
+                        right: import("zod").ZodNumber;
+                        top: import("zod").ZodNumber;
+                        bottom: import("zod").ZodNumber;
+                        near: import("zod").ZodNumber;
+                        far: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>>;
+            environment: import("zod").ZodOptional<import("zod").ZodObject<{
+                source: import("zod").ZodEnum<{
+                    gradient: "gradient";
+                    none: "none";
+                    room: "room";
+                }>;
+                intensity: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+        postprocessing: import("zod").ZodOptional<import("zod").ZodObject<{
+            ambientOcclusion: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            colorGrading: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        display: import("zod").ZodOptional<import("zod").ZodObject<{
+            mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                construction: "construction";
+                finished: "finished";
+                systems: "systems";
+            }>>;
+            families: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodEnum<{
+                device: "device";
+                "exposed-structure": "exposed-structure";
+                fill: "fill";
+                finish: "finish";
+                foundation: "foundation";
+                framing: "framing";
+                inspection: "inspection";
+                insulation: "insulation";
+                masonry: "masonry";
+                membrane: "membrane";
+                run: "run";
+                "service-space": "service-space";
+                sheathing: "sheathing";
+            }> & import("zod/v4/core").$partial, import("zod").ZodBoolean>>;
+            disciplines: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodEnum<{
+                electrical: "electrical";
+                fire: "fire";
+                "low-voltage": "low-voltage";
+                mechanical: "mechanical";
+                plumbing: "plumbing";
+            }> & import("zod/v4/core").$partial, import("zod").ZodBoolean>>;
+            xray: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            colorBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                material: "material";
+                service: "service";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    address: import("zod").ZodOptional<import("zod").ZodObject<{
+        street: import("zod").ZodOptional<import("zod").ZodString>;
+        city: import("zod").ZodOptional<import("zod").ZodString>;
+        state: import("zod").ZodOptional<import("zod").ZodString>;
+        zip: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+    parcel: import("zod").ZodOptional<import("zod").ZodObject<{
+        apn: import("zod").ZodOptional<import("zod").ZodString>;
+        source: import("zod").ZodOptional<import("zod").ZodString>;
+        county: import("zod").ZodOptional<import("zod").ZodString>;
+        state: import("zod").ZodOptional<import("zod").ZodString>;
+        lotAreaSqFt: import("zod").ZodOptional<import("zod").ZodNumber>;
+        originLngLat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+        resolvedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        layer: import("zod").ZodOptional<import("zod").ZodString>;
+        notes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>>;
+    setbacks: import("zod").ZodOptional<import("zod").ZodObject<{
+        front: import("zod").ZodNumber;
+        side: import("zod").ZodNumber;
+        rear: import("zod").ZodNumber;
+        left: import("zod").ZodOptional<import("zod").ZodNumber>;
+        right: import("zod").ZodOptional<import("zod").ZodNumber>;
+        streetSide: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    setbacksSource: import("zod").ZodOptional<import("zod").ZodString>;
+    zone: import("zod").ZodOptional<import("zod").ZodString>;
+    frontEdge: import("zod").ZodOptional<import("zod").ZodNumber>;
+    streetEdges: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+    sightTriangleFt: import("zod").ZodOptional<import("zod").ZodNumber>;
+    northRotation: import("zod").ZodOptional<import("zod").ZodNumber>;
+    dossier: import("zod").ZodOptional<import("zod").ZodObject<{
+        provider: import("zod").ZodString;
+        asOf: import("zod").ZodString;
+        point: import("zod").ZodOptional<import("zod").ZodObject<{
+            lat: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lng: import("zod").ZodOptional<import("zod").ZodNumber>;
+            source: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        address: import("zod").ZodOptional<import("zod").ZodObject<{
+            formatted: import("zod").ZodOptional<import("zod").ZodString>;
+            precision: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        sections: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            status: import("zod").ZodString;
+            summary: import("zod").ZodOptional<import("zod").ZodString>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+            source: import("zod").ZodOptional<import("zod").ZodObject<{
+                name: import("zod").ZodOptional<import("zod").ZodString>;
+                kind: import("zod").ZodOptional<import("zod").ZodString>;
+                vintage: import("zod").ZodOptional<import("zod").ZodString>;
+                attribution: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$loose>>;
+        parcel: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        flood: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        codeBasis: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        zoning: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        utilities: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        soils: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        wetlands: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        structures: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        elevation: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        boundaries: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    }, import("zod/v4/core").$loose>>;
+    contourIntervalIn: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contours3d: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    terrainContours: import("zod").ZodOptional<import("zod").ZodObject<{
+        datum: import("zod").ZodString;
+        intervalFt: import("zod").ZodNumber;
+        source: import("zod").ZodOptional<import("zod").ZodString>;
+        lines: import("zod").ZodArray<import("zod").ZodObject<{
+            elevationFt: import("zod").ZodNumber;
+            points: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    wallTypes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        label: import("zod").ZodString;
+        assembly: import("zod").ZodObject<{
+            layers: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                role: import("zod").ZodEnum<{
+                    air: "air";
+                    covering: "covering";
+                    deck: "deck";
+                    fill: "fill";
+                    finish: "finish";
+                    furring: "furring";
+                    glazing: "glazing";
+                    insulation: "insulation";
+                    lining: "lining";
+                    membrane: "membrane";
+                    sheathing: "sheathing";
+                    shell: "shell";
+                    structure: "structure";
+                    substrate: "substrate";
+                    underlay: "underlay";
+                }>;
+                thickness: import("zod").ZodNumber;
+                core: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                spacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+                material: import("zod").ZodOptional<import("zod").ZodString>;
+                slot: import("zod").ZodOptional<import("zod").ZodString>;
+                returns: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                display: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    construction: "construction";
+                    finished: "finished";
+                }>>;
+                inset: import("zod").ZodOptional<import("zod").ZodNumber>;
+                bottom: import("zod").ZodOptional<import("zod").ZodNumber>;
+                lift: import("zod").ZodOptional<import("zod").ZodNumber>;
+                src: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            backing: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                role: import("zod").ZodEnum<{
+                    air: "air";
+                    covering: "covering";
+                    deck: "deck";
+                    fill: "fill";
+                    finish: "finish";
+                    furring: "furring";
+                    glazing: "glazing";
+                    insulation: "insulation";
+                    lining: "lining";
+                    membrane: "membrane";
+                    sheathing: "sheathing";
+                    shell: "shell";
+                    structure: "structure";
+                    substrate: "substrate";
+                    underlay: "underlay";
+                }>;
+                thickness: import("zod").ZodNumber;
+                core: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                spacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+                material: import("zod").ZodOptional<import("zod").ZodString>;
+                slot: import("zod").ZodOptional<import("zod").ZodString>;
+                returns: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                display: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    construction: "construction";
+                    finished: "finished";
+                }>>;
+                inset: import("zod").ZodOptional<import("zod").ZodNumber>;
+                bottom: import("zod").ZodOptional<import("zod").ZodNumber>;
+                lift: import("zod").ZodOptional<import("zod").ZodNumber>;
+                src: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            face: import("zod").ZodOptional<import("zod").ZodEnum<{
+                exterior: "exterior";
+                front: "front";
+            }>>;
+            presetId: import("zod").ZodOptional<import("zod").ZodString>;
+            cavityInsulation: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>>>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/site/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAGlF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAmD1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/site/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAoE,CAAA"}

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

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

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

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

package/dist/site/definition.edit.js

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

package/dist/site/definition.js

@@ -1,55 +1,4 @@
-import { SiteNode as SiteNodeSchema } from '@pascal-app/core';
-import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
-import { siteParametrics } from './parametrics.js';
-import { SiteNode } from './schema.js';
-/**
- * Site — Stage A. Top-level container under the scene root; holds
- * buildings + property-line polygon + zones. No system (sites don't
- * have per-frame work). Not movable / deletable — they're the scene
- * root.
- */
-export const siteDefinition = {
-    kind: 'site',
-    schemaVersion: 1,
-    schema: SiteNode,
-    category: 'site',
-    defaults: () => {
-        const stub = SiteNodeSchema.parse({ id: 'site_default', type: 'site' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        // Site is the root container — sidebar / property-line tool drive
-        // selection, never 3D click (event bubbling from descendants would
-        // override their selection). Same reasoning as `level`.
-        duplicable: false,
-        deletable: false,
-        presettable: false,
-    },
-    parametrics: siteParametrics,
-    measurement: {
-        features: (node) => polygonMeasurementFeatures({
-            featurePrefix: 'site',
-            height: 0,
-            label: 'Property',
-            polygon: node.polygon.points,
-        }),
-    },
-    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
-    dirtyTracking: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    presentation: {
-        label: 'Site',
-        description: 'The top-level container holding buildings, zones, and the property boundary.',
-        icon: { kind: 'url', src: '/icons/site-flag.webp' },
-        paletteSection: 'site',
-        paletteOrder: 5,
-    },
-    mcp: {
-        description: 'Top-level site container.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { siteEditContribution } from './definition.edit.js';
+import { siteRenderDefinition } from './definition.render.js';
+export const siteDefinition = composeNodeDefinition(siteRenderDefinition, siteEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/site/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CA4CxF,CAAA"}

package/dist/site/definition.render.js

@@ -0,0 +1,47 @@
+import { SiteNode as SiteNodeSchema } from '@pascal-app/core';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
+import { SiteNode } from './schema.js';
+export const siteRenderDefinition = {
+    kind: 'site',
+    schemaVersion: 1,
+    schema: SiteNode,
+    category: 'site',
+    defaults: () => {
+        const stub = SiteNodeSchema.parse({ id: 'site_default', type: 'site' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        // Site is the root container — sidebar / property-line tool drive
+        // selection, never 3D click (event bubbling from descendants would
+        // override their selection). Same reasoning as `level`.
+        duplicable: false,
+        deletable: false,
+        presettable: false,
+    },
+    measurement: {
+        features: (node) => polygonMeasurementFeatures({
+            featurePrefix: 'site',
+            height: 0,
+            label: 'Property',
+            polygon: node.polygon.points,
+        }),
+    },
+    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
+    dirtyTracking: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Site',
+        description: 'The top-level container holding buildings, zones, and the property boundary.',
+        icon: { kind: 'url', src: '/icons/site-flag.webp' },
+        paletteSection: 'site',
+        paletteOrder: 5,
+    },
+    mcp: {
+        description: 'Top-level site container.',
+    },
+};