@pascal-app/core 1.0.3 → 1.0.5

package/dist/schema/nodes/shelf.d.ts

@@ -35,13 +35,39 @@ export declare const ShelfNode: z.ZodObject<{
         position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         mode: z.ZodDefault<z.ZodEnum<{
-            perspective: "perspective";
             orthographic: "orthographic";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`shelf_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"shelf">>;
     children: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -53,10 +79,10 @@ export declare const ShelfNode: z.ZodObject<{
     thickness: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
     style: z.ZodDefault<z.ZodEnum<{
-        "wall-shelf": "wall-shelf";
         bookshelf: "bookshelf";
-        "open-rack": "open-rack";
         cubby: "cubby";
+        "open-rack": "open-rack";
+        "wall-shelf": "wall-shelf";
     }>>;
     rows: z.ZodDefault<z.ZodNumber>;
     columns: z.ZodDefault<z.ZodNumber>;
@@ -65,22 +91,22 @@ export declare const ShelfNode: z.ZodObject<{
     withBottom: z.ZodDefault<z.ZodBoolean>;
     bracketStyle: z.ZodDefault<z.ZodEnum<{
         hidden: "hidden";
-        minimal: "minimal";
         industrial: "industrial";
+        minimal: "minimal";
     }>>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
-            custom: "custom";
-            white: "white";
             brick: "brick";
             concrete: "concrete";
-            wood: "wood";
+            custom: "custom";
             glass: "glass";
+            marble: "marble";
             metal: "metal";
             plaster: "plaster";
             tile: "tile";
-            marble: "marble";
+            white: "white";
+            wood: "wood";
         }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -89,9 +115,9 @@ export declare const ShelfNode: z.ZodObject<{
             opacity: z.ZodDefault<z.ZodNumber>;
             transparent: z.ZodDefault<z.ZodBoolean>;
             side: z.ZodDefault<z.ZodEnum<{
-                front: "front";
                 back: "back";
                 double: "double";
+                front: "front";
             }>>;
         }, z.core.$strip>>;
         texture: z.ZodOptional<z.ZodObject<{

package/dist/schema/nodes/shelf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shelf.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/shelf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"shelf.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/shelf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/site-facts.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+/**
+ * Mailing / civic address the lot was resolved from. Every field is optional —
+ * a hand-drawn site has no address and must still parse.
+ */
+export declare const SiteAddress: z.ZodObject<{
+    street: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    zip: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SiteAddress = z.infer<typeof SiteAddress>;
+/**
+ * Provenance of the lot ring. Written by the site panel's "Find parcel" action
+ * from the host's parcel service. `originLngLat` is the geocoded point the polygon
+ * origin sits on (polygon points are metres, x east, z south).
+ */
+export declare const SiteParcel: z.ZodObject<{
+    apn: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    county: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    lotAreaSqFt: z.ZodOptional<z.ZodNumber>;
+    originLngLat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    resolvedAt: z.ZodOptional<z.ZodString>;
+    layer: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SiteParcel = z.infer<typeof SiteParcel>;
+/** Required yards, METRES. `left` / `right` override `side` per-edge when set. */
+export declare const SiteSetbacks: z.ZodObject<{
+    front: z.ZodNumber;
+    side: z.ZodNumber;
+    rear: z.ZodNumber;
+    left: z.ZodOptional<z.ZodNumber>;
+    right: z.ZodOptional<z.ZodNumber>;
+    streetSide: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type SiteSetbacks = z.infer<typeof SiteSetbacks>;
+/** The fields `migrateSiteMetadata` lifts onto a site node. */
+export type SiteMetadataPatch = {
+    setbacks?: SiteSetbacks;
+    setbacksSource?: string;
+    zone?: string;
+    parcel?: SiteParcel;
+};
+/**
+ * Read-side migration for scenes written before these fields existed, where
+ * the plan tooling parked the same values under `metadata`. Returns a patch
+ * (empty when there is nothing to lift) — callers merge it onto the node.
+ *
+ * Only cheap, unambiguous lifts are done here: `metadata.setbacks` (already
+ * metres), `metadata.setbacksSource`, `metadata.zone`, `metadata.apn` and
+ * `metadata.source`. Anything richer (full imported project records) is
+ * left in `metadata` for the workstream that owns it.
+ */
+export declare function migrateSiteMetadata(node: {
+    metadata?: unknown;
+    setbacks?: SiteSetbacks | undefined;
+    setbacksSource?: string | undefined;
+    zone?: string | undefined;
+    parcel?: SiteParcel | undefined;
+}): SiteMetadataPatch;
+//# sourceMappingURL=site-facts.d.ts.map

package/dist/schema/nodes/site-facts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"site-facts.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/site-facts.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;iBAKtB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;iBAWrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD,kFAAkF;AAClF,eAAO,MAAM,YAAY;;;;;;;iBAQvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD,+DAA+D;AAC/D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,EAAE,YAAY,CAAA;IACvB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,UAAU,CAAA;CACpB,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,YAAY,GAAG,SAAS,CAAA;IACnC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAA;CAChC,GAAG,iBAAiB,CAsBpB"}

package/dist/schema/nodes/site-facts.js

@@ -0,0 +1,73 @@
+// The site's facts — its address, parcel and setbacks — and their read-side lift from legacy
+// metadata, apart from the node schema so pure readers (the site brief) take no id minting.
+import { z } from 'zod';
+/**
+ * Mailing / civic address the lot was resolved from. Every field is optional —
+ * a hand-drawn site has no address and must still parse.
+ */
+export const SiteAddress = z.object({
+    street: z.string().optional(),
+    city: z.string().optional(),
+    state: z.string().optional(),
+    zip: z.string().optional(),
+});
+/**
+ * Provenance of the lot ring. Written by the site panel's "Find parcel" action
+ * from the host's parcel service. `originLngLat` is the geocoded point the polygon
+ * origin sits on (polygon points are metres, x east, z south).
+ */
+export const SiteParcel = z.object({
+    apn: z.string().optional(),
+    source: z.string().optional(),
+    county: z.string().optional(),
+    state: z.string().optional(),
+    lotAreaSqFt: z.number().optional(),
+    originLngLat: z.tuple([z.number(), z.number()]).optional(),
+    resolvedAt: z.string().optional(),
+    /** GIS layer / registry the polygon came from, e.g. `arcgis-fl`. */
+    layer: z.string().optional(),
+    notes: z.array(z.string()).optional(),
+});
+/** Required yards, METRES. `left` / `right` override `side` per-edge when set. */
+export const SiteSetbacks = z.object({
+    front: z.number(),
+    side: z.number(),
+    rear: z.number(),
+    left: z.number().optional(),
+    right: z.number().optional(),
+    /** A corner lot's second street side, metres; absent = the front setback. */
+    streetSide: z.number().optional(),
+});
+/**
+ * Read-side migration for scenes written before these fields existed, where
+ * the plan tooling parked the same values under `metadata`. Returns a patch
+ * (empty when there is nothing to lift) — callers merge it onto the node.
+ *
+ * Only cheap, unambiguous lifts are done here: `metadata.setbacks` (already
+ * metres), `metadata.setbacksSource`, `metadata.zone`, `metadata.apn` and
+ * `metadata.source`. Anything richer (full imported project records) is
+ * left in `metadata` for the workstream that owns it.
+ */
+export function migrateSiteMetadata(node) {
+    const meta = node.metadata;
+    if (!meta || typeof meta !== 'object' || Array.isArray(meta))
+        return {};
+    const patch = {};
+    if (!node.setbacks) {
+        const parsed = SiteSetbacks.safeParse(meta.setbacks);
+        if (parsed.success)
+            patch.setbacks = parsed.data;
+    }
+    if (!node.setbacksSource && typeof meta.setbacksSource === 'string') {
+        patch.setbacksSource = meta.setbacksSource;
+    }
+    if (!node.zone && typeof meta.zone === 'string')
+        patch.zone = meta.zone;
+    if (!node.parcel && (typeof meta.apn === 'string' || typeof meta.source === 'string')) {
+        patch.parcel = {
+            ...(typeof meta.apn === 'string' ? { apn: meta.apn } : {}),
+            ...(typeof meta.source === 'string' ? { source: meta.source } : {}),
+        };
+    }
+    return patch;
+}

package/dist/schema/nodes/site.d.ts

@@ -1,4 +1,39 @@
 import { z } from 'zod';
+export declare const SiteDossier: z.ZodObject<{
+    provider: z.ZodString;
+    asOf: z.ZodString;
+    point: z.ZodOptional<z.ZodObject<{
+        lat: z.ZodOptional<z.ZodNumber>;
+        lng: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    address: z.ZodOptional<z.ZodObject<{
+        formatted: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    sections: z.ZodRecord<z.ZodString, z.ZodObject<{
+        status: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodString>;
+            vintage: z.ZodOptional<z.ZodString>;
+            attribution: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>;
+    parcel: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    flood: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    codeBasis: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    zoning: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    utilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    soils: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    wetlands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    structures: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    elevation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    boundaries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+export type SiteDossier = z.infer<typeof SiteDossier>;
 export declare const SiteNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -8,13 +43,39 @@ export declare const SiteNode: z.ZodObject<{
         position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         mode: z.ZodDefault<z.ZodEnum<{
-            perspective: "perspective";
             orthographic: "orthographic";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`site_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"site">>;
     polygon: z.ZodDefault<z.ZodOptional<z.ZodObject<{
@@ -30,6 +91,179 @@ export declare const SiteNode: z.ZodObject<{
         step: z.ZodNumber;
         heights: z.ZodString;
     }, z.core.$strip>>;
+    showGround: z.ZodOptional<z.ZodBoolean>;
+    presentation: z.ZodOptional<z.ZodObject<{
+        theme: z.ZodOptional<z.ZodString>;
+        exposure: z.ZodOptional<z.ZodNumber>;
+        shading: z.ZodOptional<z.ZodEnum<{
+            rendered: "rendered";
+            solid: "solid";
+        }>>;
+        edges: z.ZodOptional<z.ZodEnum<{
+            off: "off";
+            soft: "soft";
+            strong: "strong";
+        }>>;
+        shadows: z.ZodOptional<z.ZodBoolean>;
+        lighting: z.ZodOptional<z.ZodObject<{
+            background: z.ZodOptional<z.ZodString>;
+            backgroundSky: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            ground: z.ZodOptional<z.ZodString>;
+            ambient: z.ZodOptional<z.ZodObject<{
+                color: z.ZodString;
+                intensity: z.ZodNumber;
+            }, z.core.$strip>>;
+            hemi: z.ZodOptional<z.ZodObject<{
+                sky: z.ZodString;
+                ground: z.ZodString;
+                intensity: z.ZodNumber;
+            }, z.core.$strip>>;
+            lights: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                color: z.ZodString;
+                intensity: z.ZodNumber;
+                position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                target: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+                castShadow: z.ZodOptional<z.ZodBoolean>;
+                shadow: z.ZodOptional<z.ZodObject<{
+                    intensity: z.ZodOptional<z.ZodNumber>;
+                    bias: z.ZodOptional<z.ZodNumber>;
+                    normalBias: z.ZodOptional<z.ZodNumber>;
+                    radius: z.ZodOptional<z.ZodNumber>;
+                    mapSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<512>, z.ZodLiteral<1024>, z.ZodLiteral<2048>, z.ZodLiteral<4096>]>>;
+                    camera: z.ZodOptional<z.ZodObject<{
+                        left: z.ZodNumber;
+                        right: z.ZodNumber;
+                        top: z.ZodNumber;
+                        bottom: z.ZodNumber;
+                        near: z.ZodNumber;
+                        far: z.ZodNumber;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            environment: z.ZodOptional<z.ZodObject<{
+                source: z.ZodEnum<{
+                    gradient: "gradient";
+                    none: "none";
+                    room: "room";
+                }>;
+                intensity: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        postprocessing: z.ZodOptional<z.ZodObject<{
+            ambientOcclusion: z.ZodOptional<z.ZodBoolean>;
+            colorGrading: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        display: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                construction: "construction";
+                finished: "finished";
+                systems: "systems";
+            }>>;
+            families: z.ZodOptional<z.ZodRecord<z.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";
+            }> & z.core.$partial, z.ZodBoolean>>;
+            disciplines: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+                electrical: "electrical";
+                fire: "fire";
+                "low-voltage": "low-voltage";
+                mechanical: "mechanical";
+                plumbing: "plumbing";
+            }> & z.core.$partial, z.ZodBoolean>>;
+            xray: z.ZodOptional<z.ZodBoolean>;
+            colorBy: z.ZodOptional<z.ZodEnum<{
+                material: "material";
+                service: "service";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    address: z.ZodOptional<z.ZodObject<{
+        street: z.ZodOptional<z.ZodString>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        zip: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    parcel: z.ZodOptional<z.ZodObject<{
+        apn: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        county: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        lotAreaSqFt: z.ZodOptional<z.ZodNumber>;
+        originLngLat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        resolvedAt: z.ZodOptional<z.ZodString>;
+        layer: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    setbacks: z.ZodOptional<z.ZodObject<{
+        front: z.ZodNumber;
+        side: z.ZodNumber;
+        rear: z.ZodNumber;
+        left: z.ZodOptional<z.ZodNumber>;
+        right: z.ZodOptional<z.ZodNumber>;
+        streetSide: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    setbacksSource: z.ZodOptional<z.ZodString>;
+    zone: z.ZodOptional<z.ZodString>;
+    frontEdge: z.ZodOptional<z.ZodNumber>;
+    streetEdges: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    sightTriangleFt: z.ZodOptional<z.ZodNumber>;
+    northRotation: z.ZodOptional<z.ZodNumber>;
+    dossier: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        asOf: z.ZodString;
+        point: z.ZodOptional<z.ZodObject<{
+            lat: z.ZodOptional<z.ZodNumber>;
+            lng: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        address: z.ZodOptional<z.ZodObject<{
+            formatted: z.ZodOptional<z.ZodString>;
+            precision: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        sections: z.ZodRecord<z.ZodString, z.ZodObject<{
+            status: z.ZodString;
+            summary: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                kind: z.ZodOptional<z.ZodString>;
+                vintage: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        parcel: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        flood: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        codeBasis: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        zoning: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        utilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        soils: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        wetlands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        structures: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        elevation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        boundaries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>;
+    contourIntervalIn: z.ZodOptional<z.ZodNumber>;
+    contours3d: z.ZodOptional<z.ZodBoolean>;
+    terrainContours: z.ZodOptional<z.ZodObject<{
+        datum: z.ZodString;
+        intervalFt: z.ZodNumber;
+        source: z.ZodOptional<z.ZodString>;
+        lines: z.ZodArray<z.ZodObject<{
+            elevationFt: z.ZodNumber;
+            points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     children: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type SiteNode = z.infer<typeof SiteNode>;

package/dist/schema/nodes/site.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/site.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/site.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsCvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BR,CAAA;AAChB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyFpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/site.js

@@ -2,12 +2,67 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
+import { SitePresentation } from '../site-presentation.js';
 import { TerrainData } from '../terrain.js';
+import { SiteAddress, SiteParcel, SiteSetbacks } from './site-facts.js';
 // 2D Polygon
 const PropertyLineData = z.object({
     type: z.literal('polygon'),
     points: z.array(z.tuple([z.number(), z.number()])),
 });
+/**
+ * What the site keeps of a Pascal Map location dossier
+ * (https://map.pascal.app/api/docs): when it was assembled, the point and
+ * address it was evaluated at, every section's status / summary / source,
+ * and the geometry-free data of the sections the plan set acts on. Loose
+ * records on purpose — the platform adds fields without a version bump and
+ * the plan set ignores what it does not know. A section that did not answer
+ * (`not_covered` / `not_available`) is recorded as such: never a negative
+ * finding.
+ */
+const DossierSectionRecord = z
+    .object({
+    status: z.string(),
+    summary: z.string().optional(),
+    reason: z.string().optional(),
+    source: z
+        .object({
+        name: z.string().optional(),
+        kind: z.string().optional(),
+        vintage: z.string().optional(),
+        attribution: z.string().optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+const Facts = z.record(z.string(), z.unknown());
+export const SiteDossier = z
+    .object({
+    provider: z.string(),
+    asOf: z.string(),
+    point: z
+        .object({
+        lat: z.number().optional(),
+        lng: z.number().optional(),
+        source: z.string().optional(),
+    })
+        .optional(),
+    address: z
+        .object({ formatted: z.string().optional(), precision: z.string().optional() })
+        .optional(),
+    sections: z.record(z.string(), DossierSectionRecord),
+    parcel: Facts.optional(),
+    flood: Facts.optional(),
+    codeBasis: Facts.optional(),
+    zoning: Facts.optional(),
+    utilities: Facts.optional(),
+    soils: Facts.optional(),
+    wetlands: Facts.optional(),
+    structures: Facts.optional(),
+    elevation: Facts.optional(),
+    boundaries: Facts.optional(),
+})
+    .passthrough();
 export const SiteNode = BaseNode.extend({
     id: objectId('site'),
     type: nodeType('site'),
@@ -28,10 +83,69 @@ export const SiteNode = BaseNode.extend({
      * so ~11 KB of base64 zeroes does not land in every saved scene.
      */
     terrain: TerrainData.optional(),
+    /** Hide site ground, including sculpted terrain, and the horizon when other geometry supplies them. */
+    showGround: z.boolean().optional(),
+    presentation: SitePresentation.optional(),
+    /**
+     * Address + parcel provenance. All optional so every scene that predates
+     * the parcel service keeps loading unchanged.
+     */
+    address: SiteAddress.optional(),
+    parcel: SiteParcel.optional(),
+    /** Required yards in METRES (the UI takes feet and converts). */
+    setbacks: SiteSetbacks.optional(),
+    /** Where the setback numbers came from — 'zoning-code', 'manual', a citation. */
+    setbacksSource: z.string().optional(),
+    /** Zoning district label, e.g. 'RS-60'. */
+    zone: z.string().optional(),
+    /**
+     * Index into `polygon.points` of the edge that faces the street — the edge
+     * that takes the FRONT setback. The edge runs from point[frontEdge] to
+     * point[(frontEdge + 1) % n]. Undefined = derive the most north-facing edge.
+     */
+    frontEdge: z.number().int().nonnegative().optional(),
+    /** Every edge that fronts a street per the parcel fabric (a corner lot has two or more); the front is one of them. */
+    streetEdges: z.array(z.number().int().nonnegative()).optional(),
+    /** The corner sight (clear-vision) triangle's leg along each right-of-way line, FEET; absent = none drawn. */
+    sightTriangleFt: z.number().nonnegative().optional(),
+    /** Rotation of true north relative to plan −z (up), RADIANS, clockwise. */
+    northRotation: z.number().optional(),
+    /** The Pascal Map dossier the lot was dropped in with — see SiteDossier. */
+    dossier: SiteDossier.optional(),
+    /**
+     * Contour interval for the site plan's terrain lines, INCHES (6, 12, 24…).
+     * Absent = 12 in; 0 = no contours. The generate panel's terrain setting.
+     */
+    contourIntervalIn: z.number().nonnegative().optional(),
+    /** Draw the contour lines on the 3D ground too (thin, translucent black). Default off. */
+    contours3d: z.boolean().optional(),
+    /**
+     * Surveyed contour lines in the site frame (metres, x east, z south) —
+     * the Pascal Map dossier's USGS 3DEP bare-earth 1-ft lines, NAVD88 feet.
+     * The site plan draws these when present (at the chosen interval) instead
+     * of contouring the heightfield.
+     */
+    terrainContours: z
+        .object({
+        datum: z.string(),
+        intervalFt: z.number().positive(),
+        source: z.string().optional(),
+        lines: z.array(z.object({
+            elevationFt: z.number(),
+            points: z.array(z.tuple([z.number(), z.number()])),
+        })),
+    })
+        .optional(),
     children: z.array(z.string()).default([]),
 }).describe(dedent `
   Site node - used to represent a site
-  - polygon: polygon data
+  - polygon: polygon data (metres, x east, z south, origin = geocoded point)
   - terrain: optional sculpted heightfield; absent means flat ground
+  - showGround: false hides site ground (including sculpted terrain) and horizon in 3D; buildings and parcel lines remain
+  - presentation: optional project rendering defaults (theme, lighting, exposure, shading, edges and postprocessing); local viewer choices override them
+  - address / parcel: civic address + GIS parcel provenance (optional)
+  - setbacks: required yards in metres; setbacksSource / zone cite them
+  - frontEdge: index of the street-facing polygon edge
+  - northRotation: true north offset from plan up, radians
   - children: array of child node ids (buildings, items)
   `);