@pascal-app/core 1.0.1 → 1.0.4

package/dist/schema/nodes/site.js

@@ -8,6 +8,96 @@ const PropertyLineData = z.object({
     type: z.literal('polygon'),
     points: z.array(z.tuple([z.number(), z.number()])),
 });
+/**
+ * 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(),
+});
+/**
+ * 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 +118,97 @@ export const SiteNode = BaseNode.extend({
      * so ~11 KB of base64 zeroes does not land in every saved scene.
      */
     terrain: TerrainData.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
+  - 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)
   `);
+/**
+ * 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/skylight.d.ts

@@ -14,9 +14,9 @@ export declare const SkylightType: z.ZodEnum<{
 }>;
 export type SkylightType = (typeof SKYLIGHT_TYPE_ORDER)[number];
 export declare const SkylightOpeningSide: z.ZodEnum<{
-    top: "top";
-    right: "right";
     left: "left";
+    right: "right";
+    top: "top";
     bottom: "bottom";
 }>;
 export type SkylightOpeningSide = z.infer<typeof SkylightOpeningSide>;
@@ -169,6 +169,32 @@ export declare const SkylightNode: z.ZodObject<{
         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<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`skylight_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"skylight">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -256,9 +282,9 @@ export declare const SkylightNode: z.ZodObject<{
     lanternTopScale: z.ZodDefault<z.ZodNumber>;
     openingAngle: z.ZodDefault<z.ZodNumber>;
     openingSide: z.ZodDefault<z.ZodEnum<{
-        top: "top";
-        right: "right";
         left: "left";
+        right: "right";
+        top: "top";
         bottom: "bottom";
     }>>;
     operationState: z.ZodDefault<z.ZodNumber>;

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

@@ -1 +1 @@
-{"version":3,"file":"skylight.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/skylight.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB;;;EAA6B,CAAA;AAC9D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE,eAAO,MAAM,mBAAmB,+DAAgE,CAAA;AAEhG,eAAO,MAAM,YAAY;;;;;;EAA8B,CAAA;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE/D,eAAO,MAAM,mBAAmB;;;;;EAA6C,CAAA;AAC7E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,eAAO,MAAM,sBAAsB;;;EAAqB,CAAA;AACxD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,OAAO,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,mBAAmB,CAAA;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,OAAO,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,sBAAsB,CAAA;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0G2B,CAAA;AAI7D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"skylight.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/skylight.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB;;;EAA6B,CAAA;AAC9D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE,eAAO,MAAM,mBAAmB,+DAAgE,CAAA;AAEhG,eAAO,MAAM,YAAY;;;;;;EAA8B,CAAA;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE/D,eAAO,MAAM,mBAAmB;;;;;EAA6C,CAAA;AAC7E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,eAAO,MAAM,sBAAsB;;;EAAqB,CAAA;AACxD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,OAAO,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,mBAAmB,CAAA;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,OAAO,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,sBAAsB,CAAA;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0G2B,CAAA;AAI7D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

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

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 export declare const MIN_SLAB_THICKNESS = 0.02;
+export declare const MIN_GROUND_FLOOR_THICKNESS = 0.01;
+export declare const DEFAULT_SLAB_ELEVATION = 0.05;
 export declare const SlabNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -16,6 +18,32 @@ export declare const SlabNode: z.ZodObject<{
         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<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"slab">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -59,15 +87,71 @@ export declare const SlabNode: z.ZodObject<{
             stair: "stair";
             elevator: "elevator";
             manual: "manual";
+            room: "room";
+            "floor-opening": "floor-opening";
         }>>;
+        openingId: z.ZodOptional<z.ZodString>;
         stairId: z.ZodOptional<z.ZodString>;
         elevatorId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     elevation: z.ZodDefault<z.ZodNumber>;
+    floorHeight: z.ZodOptional<z.ZodNumber>;
+    referenceFloorElevation: z.ZodOptional<z.ZodNumber>;
+    foundation: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            solid: "solid";
+            none: "none";
+        }>;
+        material: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+                custom: "custom";
+                white: "white";
+                brick: "brick";
+                concrete: "concrete";
+                wood: "wood";
+                glass: "glass";
+                metal: "metal";
+                plaster: "plaster";
+                tile: "tile";
+                marble: "marble";
+            }>>>;
+            properties: z.ZodOptional<z.ZodObject<{
+                color: z.ZodDefault<z.ZodString>;
+                roughness: z.ZodDefault<z.ZodNumber>;
+                metalness: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+                transparent: z.ZodDefault<z.ZodBoolean>;
+                side: z.ZodDefault<z.ZodEnum<{
+                    front: "front";
+                    back: "back";
+                    double: "double";
+                }>>;
+            }, z.core.$strip>>;
+            texture: z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+                repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                scale: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>;
     thickness: z.ZodDefault<z.ZodNumber>;
     recessed: z.ZodDefault<z.ZodBoolean>;
     recessedRimElevation: z.ZodOptional<z.ZodNumber>;
     fillToTerrain: z.ZodOptional<z.ZodBoolean>;
+    boundary: z.ZodOptional<z.ZodLiteral<"auto">>;
+    support: z.ZodOptional<z.ZodLiteral<"open">>;
+    plateRole: z.ZodOptional<z.ZodEnum<{
+        base: "base";
+        platform: "platform";
+        sunken: "sunken";
+    }>>;
+    railing: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>>>;
+    zoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    associatedZoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     autoFromWalls: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type SlabNode = z.infer<typeof SlabNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"slab.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/slab.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAEtC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"slab.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/slab.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAGtC,eAAO,MAAM,0BAA0B,OAAO,CAAA;AAC9C,eAAO,MAAM,sBAAsB,OAAO,CAAA;AAE1C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoEpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/slab.js

@@ -7,6 +7,10 @@ import { SurfaceHoleMetadata } from './surface-hole-metadata.js';
 // −0.01 underside offset. Applies to edits only; migration writes legacy
 // intervals verbatim (including degenerate zero-thickness slabs).
 export const MIN_SLAB_THICKNESS = 0.02;
+// A ground-bearing base plate has no ceiling under it, so it may be thinner;
+// it is never zero (a zero-thickness plate renders as a hole).
+export const MIN_GROUND_FLOOR_THICKNESS = 0.01;
+export const DEFAULT_SLAB_ELEVATION = 0.05;
 export const SlabNode = BaseNode.extend({
     id: objectId('slab'),
     type: nodeType('slab'),
@@ -19,11 +23,38 @@ export const SlabNode = BaseNode.extend({
     polygon: z.array(z.tuple([z.number(), z.number()])),
     holes: z.array(z.array(z.tuple([z.number(), z.number()]))).default([]),
     holeMetadata: z.array(SurfaceHoleMetadata).default([]),
-    elevation: z.number().default(0.05), // Walking surface (slab top), meters above the level plane
+    elevation: z.number().default(DEFAULT_SLAB_ELEVATION), // Walking surface (slab top), meters above the level plane
+    floorHeight: z
+        .number()
+        .finite()
+        .optional()
+        .describe('Ground-contact base plate only: authored floor top in level-local meters; upper floors change thickness to raise their top.'),
+    referenceFloorElevation: z
+        .number()
+        .finite()
+        .optional()
+        .describe('Base plate reference walking surface in level-local meters. Absent follows terrain and support. The resolved top minus this reference is the footprint lift; only an atomic floor-reference rebase may change it.'),
+    foundation: z
+        .object({
+        type: z.enum(['solid', 'none']),
+        material: z.union([z.string(), MaterialSchema]).optional(),
+    })
+        .optional(),
     thickness: z.number().default(0.05), // Grows downward from the surface
     recessed: z.boolean().default(false),
     recessedRimElevation: z.number().finite().optional(),
     fillToTerrain: z.boolean().optional(),
+    boundary: z.literal('auto').optional(),
+    support: z.literal('open').optional(),
+    plateRole: z.enum(['base', 'platform', 'sunken']).optional(),
+    railing: z
+        .array(z.object({
+        start: z.tuple([z.number(), z.number()]),
+        end: z.tuple([z.number(), z.number()]),
+    }))
+        .optional(),
+    zoneIds: z.array(z.string()).optional(),
+    associatedZoneIds: z.array(z.string()).optional(),
     autoFromWalls: z.boolean().default(false),
 }).describe(dedent `
   Slab node - used to represent a slab/floor in the building
@@ -31,9 +62,13 @@ export const SlabNode = BaseNode.extend({
   - holes: array of [x, z] polygons representing cutouts in the slab
   - holeMetadata: metadata parallel to holes, used to preserve manual and auto-managed cutouts
   - elevation: the walking surface (slab top), in meters above the level plane
+  - floorHeight: ground-contact base plate authored top in level-local meters; absent follows terrain. Upper base plates use thickness with a fixed underside.
+  - referenceFloorElevation: base plate reference top (level-local meters); absent follows terrain and support. Ordinary floor edits keep this datum.
+  - associatedZoneIds: rooms whose authored construction overlaps this manual slab, resolved once during legacy migration.
+  - foundation: base plate exterior support to terrain; solid or none, with its own material (default concrete).
   - thickness: grows downward from the surface; the solid occupies [elevation - thickness, elevation]
   - recessed: open recess (pool) whose floor sits at elevation
   - recessedRimElevation: optional rim anchor for a raised/lowered recess; absent means the level plane
-  - fillToTerrain: extends a solid slab's perimeter downward to terrain without changing its flat top or authored thickness
+  - fillToTerrain: manual slabs only; extends a solid slab's perimeter downward to terrain without changing its flat top or authored thickness
   - autoFromWalls: whether the slab is automatically generated from a closed wall loop
   `);

package/dist/schema/nodes/solar-panel.d.ts

@@ -20,6 +20,32 @@ export declare const SolarPanelNode: z.ZodObject<{
         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<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`solarpanel_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"solar-panel">>;
     material: z.ZodOptional<z.ZodObject<{

package/dist/schema/nodes/solar-panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solar-panel.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/solar-panel.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,sBAAsB;;;EAA6B,CAAA;AAChE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmD1B,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}
+{"version":3,"file":"solar-panel.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/solar-panel.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,sBAAsB;;;EAA6B,CAAA;AAChE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmD1B,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

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

@@ -15,6 +15,32 @@ export declare const SpawnNode: z.ZodObject<{
         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<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`spawn_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"spawn">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

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

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

package/dist/schema/nodes/stair-construction.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+/** Explicit construction details; absence preserves the original stair body. */
+export declare const StairConstruction: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        solid: "solid";
+        open: "open";
+        waist: "waist";
+        "side-stringers": "side-stringers";
+        "center-stringer": "center-stringer";
+    }>>;
+    waistThickness: z.ZodDefault<z.ZodNumber>;
+    treadThickness: z.ZodDefault<z.ZodNumber>;
+    riserThickness: z.ZodDefault<z.ZodNumber>;
+    nosing: z.ZodDefault<z.ZodNumber>;
+    finishThickness: z.ZodDefault<z.ZodNumber>;
+    closedRisers: z.ZodDefault<z.ZodBoolean>;
+    stringerWidth: z.ZodDefault<z.ZodNumber>;
+    stringerDepth: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type StairConstruction = z.infer<typeof StairConstruction>;
+//# sourceMappingURL=stair-construction.d.ts.map

package/dist/schema/nodes/stair-construction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-construction.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-construction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,gFAAgF;AAChF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;iBAU5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/schema/nodes/stair-construction.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+/** Explicit construction details; absence preserves the original stair body. */
+export const StairConstruction = z.object({
+    mode: z.enum(['solid', 'waist', 'open', 'side-stringers', 'center-stringer']).default('open'),
+    waistThickness: z.number().positive().default(0.25),
+    treadThickness: z.number().positive().default(0.05),
+    riserThickness: z.number().positive().default(0.02),
+    nosing: z.number().nonnegative().default(0.025),
+    finishThickness: z.number().nonnegative().default(0),
+    closedRisers: z.boolean().default(false),
+    stringerWidth: z.number().positive().default(0.08),
+    stringerDepth: z.number().positive().default(0.25),
+});

package/dist/schema/nodes/stair-design-targets.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const StairDesignTargets: z.ZodObject<{
+    maxRiserHeight: z.ZodDefault<z.ZodNumber>;
+    minimumGoing: z.ZodDefault<z.ZodNumber>;
+    targetGoing: z.ZodDefault<z.ZodNumber>;
+    minimumHeadroom: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type StairDesignTargets = z.infer<typeof StairDesignTargets>;
+//# sourceMappingURL=stair-design-targets.d.ts.map

package/dist/schema/nodes/stair-design-targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-design-targets.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-design-targets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,kBAAkB;;;;;iBAK7B,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/schema/nodes/stair-design-targets.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export const StairDesignTargets = z.object({
+    maxRiserHeight: z.number().positive().default(0.18),
+    minimumGoing: z.number().positive().default(0.25),
+    targetGoing: z.number().positive().default(0.28),
+    minimumHeadroom: z.number().positive().default(2),
+});