@pascal-app/nodes 1.0.6 → 1.1.0

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.',
+    },
+};

package/dist/site/ground-hole.d.ts

@@ -8,7 +8,7 @@ import { type UndergroundEdge } from '@pascal-app/viewer';
  * in a soft feather and a thin light line marks the cut itself.
  *
  * The footprint is a signed-distance field baked on the CPU into a small texture when the
- * footprints change (the polygons the grade ring is drawn from), so the ground's mask costs one
+ * footprints change, so the ground's mask costs one
  * texture fetch and one noise lookup per fragment, whatever the building's outline. How far the
  * hole is open (0 to 1, eased, 0 in a capture) is the viewer's `groundHoleOpenNode`.
  */
@@ -70,8 +70,8 @@ export declare function groundHoleShadowNode(): () => any;
  */
 export declare function groundHoleColorNode(shadeColor: string): import("three/webgpu").Node<"vec3">;
 /**
- * Feeds the hole the footprints it is cut over (the polygons the grade ring runs along: the level
- * shown and the ones between it and grade), and says to the rest of the viewer whether the scene
+ * Feeds the hole the footprints it is cut over (the level shown and the ones between it and
+ * grade), and says to the rest of the viewer whether the scene
  * has a level below grade at all (`present`): the ground materials carry the hole's mask, and the
  * eye's fill light is mounted, from then on, once, so that changing floors only changes uniforms.
  *

package/dist/site/ground-hole.js

@@ -18,7 +18,7 @@ import { EDGE_LOOKS } from './underground-edge.js';
  * in a soft feather and a thin light line marks the cut itself.
  *
  * The footprint is a signed-distance field baked on the CPU into a small texture when the
- * footprints change (the polygons the grade ring is drawn from), so the ground's mask costs one
+ * footprints change, so the ground's mask costs one
  * texture fetch and one noise lookup per fragment, whatever the building's outline. How far the
  * hole is open (0 to 1, eased, 0 in a capture) is the viewer's `groundHoleOpenNode`.
  */
@@ -263,8 +263,8 @@ export function groundHoleColorNode(shadeColor) {
     return mix(shaded, lineColor, line);
 }
 /**
- * Feeds the hole the footprints it is cut over (the polygons the grade ring runs along: the level
- * shown and the ones between it and grade), and says to the rest of the viewer whether the scene
+ * Feeds the hole the footprints it is cut over (the level shown and the ones between it and
+ * grade), and says to the rest of the viewer whether the scene
  * has a level below grade at all (`present`): the ground materials carry the hole's mask, and the
  * eye's fill light is mounted, from then on, once, so that changing floors only changes uniforms.
  *

package/dist/site/ground-veil.d.ts

@@ -1,4 +1,3 @@
-import type { TerrainField } from '@pascal-app/core';
 import { type BufferGeometry, type Material } from 'three';
 import { MeshBasicNodeMaterial } from 'three/webgpu';
 /** Presentation-only meshes are never picked: clicks fall through to what lies under them. */
@@ -16,24 +15,18 @@ export declare function horizonVeilMaterial(groundColor: string, lot: ReadonlyAr
     cz: number;
     radius: number;
 }): MeshBasicNodeMaterial;
-/** The grade ring's ribbon along one outline where the ground meets a level below grade. */
-export declare function gradeRingGeometry(outline: ReadonlyArray<Point>, field: TerrainField | null): BufferGeometry;
-export declare function gradeRingMaterial(): MeshBasicNodeMaterial;
 /**
  * Drawn only while the ground is veiled: the veil of one solid ground surface (the same geometry
- * in the same place), or the grade ring. A direct child of the site, as the surfaces are, so the
- * captures find it (`siteGround`) and hide it with the site's other surfaces.
- *
- * `shows` says when a live view draws it: `'window'` (a sheet: only where the ground window veils
- * a hillside in the eye's way; wholesale the ground is a hole, not a sheet) or `'veiled'` (the
- * ring: wherever any ground is veiled). A capture shows both by setting `visible` itself.
+ * in the same place). A direct child of the site, as the surfaces are, so the captures find it
+ * (`siteGround`) and hide it with the site's other surfaces. A live view draws it only where the
+ * ground window veils a hillside in the eye's way (wholesale the ground is a hole, not a sheet); a
+ * capture shows it by setting `visible` itself.
  */
-export declare function GroundVeil({ geometry, material, position, rotation, shows, }: {
+export declare function GroundVeil({ geometry, material, position, rotation, }: {
     geometry: BufferGeometry;
     material: Material;
     position?: [number, number, number];
     rotation?: [number, number, number];
-    shows?: 'window' | 'veiled';
 }): import("react").JSX.Element;
 export {};
 //# sourceMappingURL=ground-veil.d.ts.map

package/dist/site/ground-veil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ground-veil.d.ts","sourceRoot":"","sources":["../../src/site/ground-veil.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAUpD,OAAO,EAAE,KAAK,cAAc,EAAc,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAatE,OAAO,EAAE,qBAAqB,EAAa,MAAM,cAAc,CAAA;AAW/D,8FAA8F;AAC9F,eAAO,MAAM,WAAW,YAAW,CAAA;AAKnC,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AA6BtC,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,yBAErD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,EACzB,MAAM,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,yBAMnD;AASD,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAC7B,KAAK,EAAE,YAAY,GAAG,IAAI,GACzB,cAAc,CAGhB;AAED,wBAAgB,iBAAiB,0BAShC;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,KAAgB,GACjB,EAAE;IACD,QAAQ,EAAE,cAAc,CAAA;IACxB,QAAQ,EAAE,QAAQ,CAAA;IAClB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAC5B,+BAiBA"}
+{"version":3,"file":"ground-veil.d.ts","sourceRoot":"","sources":["../../src/site/ground-veil.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,cAAc,EAAc,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAEtE,OAAO,EAAE,qBAAqB,EAAa,MAAM,cAAc,CAAA;AAQ/D,8FAA8F;AAC9F,eAAO,MAAM,WAAW,YAAW,CAAA;AAKnC,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AA6BtC,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,yBAErD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,EACzB,MAAM,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,yBAMnD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,cAAc,CAAA;IACxB,QAAQ,EAAE,QAAQ,CAAA;IAClB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,+BAaA"}

package/dist/site/ground-veil.js

@@ -1,16 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { anyGroundVeiled, groundWindowEnabledNode, inGroundWindowNode, SITE_GROUND, UNDERGROUND_RING, undergroundAmbianceNode, useViewer, } from '@pascal-app/viewer';
+import { groundWindowEnabledNode, inGroundWindowNode, SITE_GROUND, useViewer, } from '@pascal-app/viewer';
 import { DoubleSide } from 'three';
-import { color, float, mix, mrt, output, positionWorld, select, smoothstep, vec2, vec4, } from 'three/tsl';
+import { color, float, mrt, output, positionWorld, select, smoothstep, vec2, vec4 } from 'three/tsl';
 import { MeshBasicNodeMaterial } from 'three/webgpu';
-import { buildPatternedRibbon } from './line-ribbon.js';
 import { insideLotNode } from './lot-mask.js';
-import { buildDrapedPolyline } from './terrain-drape.js';
 // The ground over a level below grade. Wholesale (a level fully below grade, the ground on Auto)
 // the solid ground stays and a hole opens in it (`ground-hole.ts`); the veil sheets here are the
 // faint see-through ground of the ground window (a hillside in the eye's way) and of a capture
-// (which sets the solid ground aside and shows them), and the grade ring is drawn where the ground
-// meets the level below grade, in either.
+// (which sets the solid ground aside and shows them).
 /** Presentation-only meshes are never picked: clicks fall through to what lies under them. */
 export const noopRaycast = () => { };
 /** How much of the ground shows as a veil: enough to read where grade is, and no more. */
@@ -52,35 +49,14 @@ export function horizonVeilMaterial(groundColor, lot, bounds) {
     const outsideLot = insideLotNode(lot, positionWorld.xz).not();
     return veilMaterial(groundColor, select(outsideLot, fade, float(0)));
 }
-/** The grade ring: dark as the lot line, a little narrower, just over the ground. */
-const GRADE_RING_COLOR = '#1c1917';
-const GRADE_RING_WIDTH = 0.16;
-const GRADE_RING_LIFT = 0.015;
-/** One run, never broken: a ribbon pattern with no gap. */
-const UNBROKEN = [Number.POSITIVE_INFINITY, 0];
-/** The grade ring's ribbon along one outline where the ground meets a level below grade. */
-export function gradeRingGeometry(outline, field) {
-    const drape = buildDrapedPolyline({ points: outline, field, lift: GRADE_RING_LIFT, closed: true });
-    return buildPatternedRibbon(drape.positions, UNBROKEN, GRADE_RING_WIDTH);
-}
-export function gradeRingMaterial() {
-    const material = new MeshBasicNodeMaterial({ color: GRADE_RING_COLOR, side: DoubleSide });
-    // Under the ground's ambiance the ring is a light rim: a dark ring would vanish in the dark mode.
-    material.colorNode = mix(color(GRADE_RING_COLOR), color(UNDERGROUND_RING), undergroundAmbianceNode());
-    return material;
-}
 /**
  * Drawn only while the ground is veiled: the veil of one solid ground surface (the same geometry
- * in the same place), or the grade ring. A direct child of the site, as the surfaces are, so the
- * captures find it (`siteGround`) and hide it with the site's other surfaces.
- *
- * `shows` says when a live view draws it: `'window'` (a sheet: only where the ground window veils
- * a hillside in the eye's way; wholesale the ground is a hole, not a sheet) or `'veiled'` (the
- * ring: wherever any ground is veiled). A capture shows both by setting `visible` itself.
+ * in the same place). A direct child of the site, as the surfaces are, so the captures find it
+ * (`siteGround`) and hide it with the site's other surfaces. A live view draws it only where the
+ * ground window veils a hillside in the eye's way (wholesale the ground is a hole, not a sheet); a
+ * capture shows it by setting `visible` itself.
  */
-export function GroundVeil({ geometry, material, position, rotation, shows = 'window', }) {
-    const veiled = useViewer((state) => shows === 'veiled'
-        ? anyGroundVeiled(state)
-        : state.groundMode === 'auto' && state.groundWindowVeiled);
+export function GroundVeil({ geometry, material, position, rotation, }) {
+    const veiled = useViewer((state) => state.groundMode === 'auto' && state.groundWindowVeiled);
     return (_jsx("mesh", { geometry: geometry, material: material, position: position, raycast: noopRaycast, rotation: rotation, userData: { [SITE_GROUND]: 'veil', pascalExport: 'strip' }, visible: veiled }));
 }

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/site/panel.tsx"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,wBAAgB,aAAa,uCA+W5B;eAWc,aAAa"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/site/panel.tsx"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,wBAAgB,aAAa,uCAyc5B;eAWc,aAAa"}