@pascal-app/core 1.0.3 → 1.0.5

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

@@ -1,25 +1,20 @@
 import { z } from 'zod';
 import type { MaterialSchema as MaterialSchemaType } from '../material.js';
-export declare const StairRailingMode: z.ZodEnum<{
-    right: "right";
-    left: "left";
-    none: "none";
-    both: "both";
-}>;
+export { StairDesignTargets } from './stair-design-targets.js';
+export { StairRailingMode, StairRailingStyle } from './stair-types.js';
 export declare const StairType: z.ZodEnum<{
-    straight: "straight";
-    spiral: "spiral";
     curved: "curved";
+    spiral: "spiral";
+    straight: "straight";
 }>;
 export declare const StairTopLandingMode: z.ZodEnum<{
-    none: "none";
     integrated: "integrated";
+    none: "none";
 }>;
 export declare const StairSlabOpeningMode: z.ZodEnum<{
-    none: "none";
     destination: "destination";
+    none: "none";
 }>;
-export type StairRailingMode = z.infer<typeof StairRailingMode>;
 export type StairType = z.infer<typeof StairType>;
 export type StairTopLandingMode = z.infer<typeof StairTopLandingMode>;
 export type StairSlabOpeningMode = z.infer<typeof StairSlabOpeningMode>;
@@ -37,28 +32,54 @@ export declare const StairNode: 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<`stair_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"stair">>;
     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>;
@@ -67,9 +88,9 @@ export declare const StairNode: 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<{
@@ -82,16 +103,16 @@ export declare const StairNode: z.ZodObject<{
     railingMaterial: 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>;
@@ -100,9 +121,9 @@ export declare const StairNode: 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<{
@@ -115,16 +136,16 @@ export declare const StairNode: z.ZodObject<{
     treadMaterial: 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>;
@@ -133,9 +154,9 @@ export declare const StairNode: 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<{
@@ -148,16 +169,16 @@ export declare const StairNode: z.ZodObject<{
     sideMaterial: 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>;
@@ -166,9 +187,9 @@ export declare const StairNode: 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<{
@@ -183,39 +204,111 @@ export declare const StairNode: z.ZodObject<{
     rotation: z.ZodDefault<z.ZodNumber>;
     supportSlabId: z.ZodOptional<z.ZodString>;
     stairType: z.ZodDefault<z.ZodEnum<{
-        straight: "straight";
-        spiral: "spiral";
         curved: "curved";
+        spiral: "spiral";
+        straight: "straight";
     }>>;
     fromLevelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     toLevelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     deckSlabId: z.ZodOptional<z.ZodString>;
     slabOpeningMode: z.ZodDefault<z.ZodEnum<{
-        none: "none";
         destination: "destination";
+        none: "none";
     }>>;
     openingOffset: z.ZodDefault<z.ZodNumber>;
     width: z.ZodDefault<z.ZodNumber>;
     totalRise: z.ZodOptional<z.ZodNumber>;
+    designTargets: z.ZodOptional<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>>;
+    uniformRisers: z.ZodOptional<z.ZodBoolean>;
     stepCount: z.ZodDefault<z.ZodNumber>;
+    autoSurfaceSnap: z.ZodOptional<z.ZodBoolean>;
+    destinationSurfaceId: z.ZodOptional<z.ZodString>;
     thickness: z.ZodDefault<z.ZodNumber>;
     fillToFloor: z.ZodDefault<z.ZodBoolean>;
+    construction: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            "center-stringer": "center-stringer";
+            open: "open";
+            "side-stringers": "side-stringers";
+            solid: "solid";
+            waist: "waist";
+        }>>;
+        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>>;
     innerRadius: z.ZodDefault<z.ZodNumber>;
     sweepAngle: z.ZodDefault<z.ZodNumber>;
     topLandingMode: z.ZodDefault<z.ZodEnum<{
-        none: "none";
         integrated: "integrated";
+        none: "none";
     }>>;
     topLandingDepth: z.ZodDefault<z.ZodNumber>;
     showCenterColumn: z.ZodDefault<z.ZodBoolean>;
     showStepSupports: z.ZodDefault<z.ZodBoolean>;
     railingMode: z.ZodDefault<z.ZodEnum<{
-        right: "right";
+        both: "both";
         left: "left";
         none: "none";
-        both: "both";
+        right: "right";
     }>>;
     railingHeight: z.ZodDefault<z.ZodNumber>;
+    railingStyle: z.ZodOptional<z.ZodEnum<{
+        balusters: "balusters";
+        boards: "boards";
+        cable: "cable";
+        glass: "glass";
+        metal: "metal";
+        "post-and-rail": "post-and-rail";
+    }>>;
+    railingPath: z.ZodOptional<z.ZodEnum<{
+        continuous: "continuous";
+        original: "original";
+    }>>;
+    handrail: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            both: "both";
+            left: "left";
+            none: "none";
+            right: "right";
+        }>>;
+        height: z.ZodDefault<z.ZodNumber>;
+        diameter: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodDefault<z.ZodNumber>;
+        bottom: z.ZodOptional<z.ZodObject<{
+            extension: z.ZodDefault<z.ZodNumber>;
+            return: z.ZodDefault<z.ZodEnum<{
+                floor: "floor";
+                none: "none";
+                post: "post";
+                wall: "wall";
+            }>>;
+            returnLength: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        top: z.ZodOptional<z.ZodObject<{
+            extension: z.ZodDefault<z.ZodNumber>;
+            return: z.ZodDefault<z.ZodEnum<{
+                floor: "floor";
+                none: "none";
+                post: "post";
+                wall: "wall";
+            }>>;
+            returnLength: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    railingTopPost: z.ZodOptional<z.ZodBoolean>;
+    railingTopReach: z.ZodOptional<z.ZodNumber>;
+    railingPostThrough: z.ZodOptional<z.ZodBoolean>;
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`sseg_${string}`>>>>;
 }, z.core.$strip>;
 export type StairNode = z.infer<typeof StairNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"stair.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIvE,eAAO,MAAM,gBAAgB;;;;;EAA4C,CAAA;AACzE,eAAO,MAAM,SAAS;;;;EAA2C,CAAA;AACjE,eAAO,MAAM,mBAAmB;;;EAAiC,CAAA;AACjE,eAAO,MAAM,oBAAoB;;;EAAkC,CAAA;AAEnE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AACjD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACvE,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAA;AACnE,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsErB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AASjD,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,wBAAwB,GAC7B,wBAAwB,CAmE1B"}
+{"version":3,"file":"stair.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAKvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAKnE,eAAO,MAAM,SAAS;;;;EAA2C,CAAA;AACjE,eAAO,MAAM,mBAAmB;;;EAAiC,CAAA;AACjE,eAAO,MAAM,oBAAoB;;;EAAkC,CAAA;AAEnE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AACjD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACvE,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAA;AACnE,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAQD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwGrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AASjD,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,wBAAwB,GAC7B,wBAAwB,CAmE1B"}

package/dist/schema/nodes/stair.js

@@ -2,11 +2,20 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
 import { MaterialSchema } from '../material.js';
+import { StairDesignTargets } from './stair-design-targets.js';
+import { StairRailingMode, StairRailingStyle } from './stair-types.js';
+export { StairDesignTargets } from './stair-design-targets.js';
+export { StairRailingMode, StairRailingStyle } from './stair-types.js';
+import { StairConstruction } from './stair-construction.js';
 import { StairSegmentNode } from './stair-segment.js';
-export const StairRailingMode = z.enum(['none', 'left', 'right', 'both']);
 export const StairType = z.enum(['straight', 'curved', 'spiral']);
 export const StairTopLandingMode = z.enum(['none', 'integrated']);
 export const StairSlabOpeningMode = z.enum(['none', 'destination']);
+const StairHandrailEnd = z.object({
+    extension: z.number().finite().nonnegative().default(0),
+    return: z.enum(['none', 'wall', 'post', 'floor']).default('none'),
+    returnLength: z.number().finite().nonnegative().default(0.1),
+});
 export const StairNode = BaseNode.extend({
     id: objectId('stair'),
     type: nodeType('stair'),
@@ -37,9 +46,15 @@ export const StairNode = BaseNode.extend({
     openingOffset: z.number().default(0),
     width: z.number().default(1.0),
     totalRise: z.number().optional(),
+    designTargets: StairDesignTargets.optional(),
+    uniformRisers: z.boolean().optional(),
     stepCount: z.number().default(10),
+    // Optional magnetic destination connection, independent of the source support.
+    autoSurfaceSnap: z.boolean().optional(),
+    destinationSurfaceId: z.string().optional(),
     thickness: z.number().default(0.25),
     fillToFloor: z.boolean().default(true),
+    construction: StairConstruction.optional(),
     innerRadius: z.number().default(0.9),
     sweepAngle: z.number().default(Math.PI / 2),
     topLandingMode: StairTopLandingMode.default('none'),
@@ -48,11 +63,30 @@ export const StairNode = BaseNode.extend({
     showStepSupports: z.boolean().default(true),
     railingMode: StairRailingMode.default('none'),
     railingHeight: z.number().default(0.92),
+    railingStyle: StairRailingStyle.optional(),
+    railingPath: z.enum(['original', 'continuous']).optional(),
+    handrail: z
+        .object({
+        mode: StairRailingMode.default('both'),
+        height: z.number().positive().default(0.9),
+        diameter: z.number().positive().default(0.045),
+        offset: z.number().nonnegative().default(0.06),
+        bottom: StairHandrailEnd.optional(),
+        top: StairHandrailEnd.optional(),
+    })
+        .optional(),
+    // 'post-and-rail' only: false leaves the TOP post out so the rail dies
+    // into a post that already stands there (a porch's 6x6 beside the flight).
+    railingTopPost: z.boolean().optional(),
+    // Guard styles: how far past the top nosing, along the slope, the rails run
+    // to die into the post standing there (a porch post set back from the edge).
+    railingTopReach: z.number().min(0).optional(),
+    railingPostThrough: z.boolean().optional(),
     // Child stair segment IDs
     children: z.array(StairSegmentNode.shape.id).default([]),
 }).describe(dedent `
   Stair node - a container for stair segments.
-  Acts as a group that either holds one or more StairSegmentNodes (straight stairs)
+  Acts as a group that either holds one or more StairSegmentNodes (stairs)
   or stores stair-level geometry properties for curved stairs.
   - position: center position of the stair group
   - rotation: rotation around Y axis
@@ -64,6 +98,8 @@ export const StairNode = BaseNode.extend({
   - width: stair width
   - totalRise: total stair height
   - stepCount: number of visible steps
+  - construction: optional explicit construction and finish details, inherited by child segments; absence preserves legacy bodies
+  - autoSurfaceSnap: magnetically connect straight flights to nearby registered top surfaces
   - thickness: stair slab / tread thickness
   - fillToFloor: whether the stair mass fills down to the floor or uses tread thickness only
   - innerRadius: inner curve radius for curved stairs
@@ -74,7 +110,14 @@ export const StairNode = BaseNode.extend({
   - showStepSupports: whether spiral stairs render step support brackets
   - railingMode: whether to render railings and on which side(s)
   - railingHeight: top height of the railing above the stair surface
-  - children: array of StairSegmentNode IDs for straight stairs
+  - railingStyle: balusters, post-and-rail, cable, boards, glass (flat panels) or metal (steel posts and balusters); balusters when absent
+  - railingPath: original per-flight paths or continuous guards through turns and exposed landing edges
+  - designTargets: optional riser, going and headroom preferences in metres, not code certification
+  - uniformRisers: distribute the total flight rise by riser count when enabled
+  - railingTopPost: guard styles only — false leaves the top post out so the rails die into a post already standing there (a porch post); railingTopReach runs the rails that far past the top nosing along the slope to reach it (top post on, reach 0 when absent)
+  - railingPostThrough: guard styles — the posts run past the cap rail and get a cap of their own (off when absent)
+  - handrail: independent rail; optional bottom/top end extension (bottom sloped, top horizontal), return none/wall/post/floor, and returnLength in metres for outward wall-facing or downward post-facing geometry. Returns do not attach to hosts. Floor returns meet the source/arrival elevation. Closed paths have no end details.
+  - children: array of StairSegmentNode IDs for stairs
   `);
 function getLegacyStairSurfaceMaterial(node) {
     return {

package/dist/schema/nodes/structural-grid.d.ts

@@ -8,13 +8,39 @@ export declare const StructuralGridNode: 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<`structural-grid_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"structural-grid">>;
     start: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;

package/dist/schema/nodes/structural-grid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"structural-grid.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/structural-grid.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;iBAe9B,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}
+{"version":3,"file":"structural-grid.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/structural-grid.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAe9B,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/schema/nodes/surface-hole-metadata.d.ts

@@ -1,10 +1,13 @@
 import { z } from 'zod';
 export declare const SurfaceHoleMetadata: z.ZodObject<{
     source: z.ZodDefault<z.ZodEnum<{
-        stair: "stair";
         elevator: "elevator";
+        "floor-opening": "floor-opening";
         manual: "manual";
+        room: "room";
+        stair: "stair";
     }>>;
+    openingId: z.ZodOptional<z.ZodString>;
     stairId: z.ZodOptional<z.ZodString>;
     elevatorId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/schema/nodes/surface-hole-metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"surface-hole-metadata.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/surface-hole-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,mBAAmB;;;;;;;;iBAK9B,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}
+{"version":3,"file":"surface-hole-metadata.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/surface-hole-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,mBAAmB;;;;;;;;;;;iBAM9B,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/schema/nodes/surface-hole-metadata.js

@@ -1,7 +1,8 @@
 import { z } from 'zod';
 export const SurfaceHoleMetadata = z.object({
     // Stair/elevator auto-openings use stairId/elevatorId so sync can replace only its own holes.
-    source: z.enum(['manual', 'stair', 'elevator']).default('manual'),
+    source: z.enum(['manual', 'stair', 'elevator', 'room', 'floor-opening']).default('manual'),
+    openingId: z.string().optional(),
     stairId: z.string().optional(),
     elevatorId: z.string().optional(),
 });

package/dist/schema/nodes/surface-paint-region.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+/**
+ * A painted part of a flat surface, in level XZ: a room floor
+ * (`zone.floor.regions`), a room's ceiling (`zone.ceiling.regions`) or a manual
+ * ceiling (`ceiling.regions`). Later entries win; each surface clips its
+ * regions to what it covers.
+ */
+export declare const SurfacePaintRegion: z.ZodObject<{
+    id: z.ZodString;
+    polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+}, z.core.$strip>;
+export type SurfacePaintRegion = z.infer<typeof SurfacePaintRegion>;
+//# sourceMappingURL=surface-paint-region.d.ts.map

package/dist/schema/nodes/surface-paint-region.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-paint-region.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/surface-paint-region.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/schema/nodes/surface-paint-region.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/**
+ * A painted part of a flat surface, in level XZ: a room floor
+ * (`zone.floor.regions`), a room's ceiling (`zone.ceiling.regions`) or a manual
+ * ceiling (`ceiling.regions`). Later entries win; each surface clips its
+ * regions to what it covers.
+ */
+export const SurfacePaintRegion = z.object({
+    id: z.string(),
+    polygon: z.array(z.tuple([z.number(), z.number()])),
+    finish: z.union([z.string(), z.record(z.string(), z.unknown())]),
+});

package/dist/schema/nodes/turbine-vent.d.ts

@@ -13,28 +13,54 @@ export declare const TurbineVentNode: 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<`tvent_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"turbine-vent">>;
     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>;
@@ -43,9 +69,9 @@ export declare const TurbineVentNode: 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/turbine-vent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"turbine-vent.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/turbine-vent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,uBAAuB;;;EAA2B,CAAA;AAC/D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2C3B,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}
+{"version":3,"file":"turbine-vent.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/turbine-vent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,uBAAuB;;;EAA2B,CAAA;AAC/D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2C3B,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const UNIT_KINDS: readonly ["apartment", "hotel-room", "commercial", "common"];
+export declare const UNIT_KINDS: readonly ['apartment', 'hotel-room', 'commercial', 'common'];
 export type UnitKind = (typeof UNIT_KINDS)[number];
 export declare const DEFAULT_UNIT_COLOR = "#f59e0b";
 export declare const UnitNode: z.ZodObject<{
@@ -10,20 +10,46 @@ export declare const UnitNode: 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>>;
+    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<`unit_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"unit">>;
     name: z.ZodDefault<z.ZodString>;
     kind: z.ZodDefault<z.ZodEnum<{
         apartment: "apartment";
-        "hotel-room": "hotel-room";
         commercial: "commercial";
         common: "common";
+        "hotel-room": "hotel-room";
     }>>;
     members: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>>>;
     color: z.ZodDefault<z.ZodString>;