@pascal-app/core 1.0.1 → 1.0.4

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

@@ -5,11 +5,23 @@ export declare const StairSegmentType: z.ZodEnum<{
 }>;
 export type StairSegmentType = z.infer<typeof StairSegmentType>;
 export declare const AttachmentSide: z.ZodEnum<{
-    front: "front";
-    right: "right";
     left: "left";
+    right: "right";
+    front: "front";
 }>;
 export type AttachmentSide = z.infer<typeof AttachmentSide>;
+export declare const StairWinder: z.ZodObject<{
+    turn: z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>;
+    innerGap: z.ZodDefault<z.ZodNumber>;
+    walkingLineOffset: z.ZodDefault<z.ZodNumber>;
+    division: z.ZodDefault<z.ZodEnum<{
+        "equal-going": "equal-going";
+        "equal-angle": "equal-angle";
+    }>>;
+}, z.core.$strip>;
 export declare const StairSegmentNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -26,6 +38,32 @@ export declare const StairSegmentNode: 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<`sseg_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"stair-segment">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -61,6 +99,7 @@ export declare const StairSegmentNode: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     materialPreset: z.ZodOptional<z.ZodString>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     segmentType: z.ZodDefault<z.ZodEnum<{
@@ -72,11 +111,40 @@ export declare const StairSegmentNode: z.ZodObject<{
     height: z.ZodDefault<z.ZodNumber>;
     stepCount: z.ZodDefault<z.ZodNumber>;
     attachmentSide: z.ZodDefault<z.ZodEnum<{
-        front: "front";
-        right: "right";
         left: "left";
+        right: "right";
+        front: "front";
     }>>;
     fillToFloor: z.ZodDefault<z.ZodBoolean>;
+    construction: z.ZodOptional<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>>;
+    winder: z.ZodOptional<z.ZodObject<{
+        turn: z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>;
+        innerGap: z.ZodDefault<z.ZodNumber>;
+        walkingLineOffset: z.ZodDefault<z.ZodNumber>;
+        division: z.ZodDefault<z.ZodEnum<{
+            "equal-going": "equal-going";
+            "equal-angle": "equal-angle";
+        }>>;
+    }, z.core.$strip>>;
     thickness: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type StairSegmentNode = z.infer<typeof StairSegmentNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"stair-segment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-segment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;EAA+B,CAAA;AAE5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc;;;;EAAqC,CAAA;AAEhE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsC5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}
+{"version":3,"file":"stair-segment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-segment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,gBAAgB;;;EAA+B,CAAA;AAE5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc;;;;EAAqC,CAAA;AAEhE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,WAAW;;;;;;;;;;;iBAKtB,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4C5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

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

@@ -2,13 +2,21 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
 import { MaterialSchema } from '../material.js';
+import { StairConstruction } from './stair-construction.js';
 export const StairSegmentType = z.enum(['stair', 'landing']);
 export const AttachmentSide = z.enum(['front', 'left', 'right']);
+export const StairWinder = z.object({
+    turn: z.enum(['left', 'right']),
+    innerGap: z.number().finite().nonnegative().default(0),
+    walkingLineOffset: z.number().finite().positive().default(0.5),
+    division: z.enum(['equal-going', 'equal-angle']).default('equal-going'),
+});
 export const StairSegmentNode = BaseNode.extend({
     id: objectId('sseg'),
     type: nodeType('stair-segment'),
     material: MaterialSchema.optional(),
     materialPreset: z.string().optional(),
+    slots: z.record(z.string(), z.string()).optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Rotation around Y axis in radians
     rotation: z.number().default(0),
@@ -26,6 +34,8 @@ export const StairSegmentNode = BaseNode.extend({
     attachmentSide: AttachmentSide.default('front'),
     // Whether to fill the underside down to floor level
     fillToFloor: z.boolean().default(true),
+    construction: StairConstruction.optional(),
+    winder: StairWinder.optional(),
     // Thickness of the stair slab when not filled to floor
     thickness: z.number().default(0.25),
 }).describe(dedent `
@@ -39,5 +49,8 @@ export const StairSegmentNode = BaseNode.extend({
   - stepCount: number of steps (stair type only)
   - attachmentSide: front, left, or right - which side of the previous segment to attach to
   - fillToFloor: whether to fill the underside down to the absolute floor level
+  - construction: optional explicit body, tread, riser, nosing, finish and stringer details; absent inherits the parent setting
+  - winder: optional quarter-turn flight with left/right turn, inner gap, walking-line offset and equal-going/equal-angle division
   - thickness: slab thickness when not filled to floor
+  Parent designTargets, uniformRisers and railingPath apply to the chain. Guards support balusters, post-and-rail, cable, boards, glass and metal.
   `);

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

@@ -1,11 +1,31 @@
 import { z } from 'zod';
 import type { MaterialSchema as MaterialSchemaType } from '../material.js';
+export { StairDesignTargets } from './stair-design-targets.js';
 export declare const StairRailingMode: z.ZodEnum<{
-    right: "right";
     left: "left";
+    right: "right";
     none: "none";
     both: "both";
 }>;
+/**
+ * How a straight flight's guard is built: 'balusters' — the round baluster
+ * at every nosing with two round rails (the original); 'post-and-rail' —
+ * the way a deck stair is built: 4x4 posts no more than 4 ft apart (two on a
+ * short flight), a top rail and a bottom rail following the flight, 1½ in
+ * pickets between them at a 4 in-sphere gap (IRC R312.1.3); 'cable' — slim 2 in
+ * posts spaced by run under a flat cap rail, with slender round cables 3 in
+ * apart pulled as straight spans from post to post and a swage sleeve at each
+ * terminal post (the modern cable rail; the cap follows a curve but the taut
+ * cables span straight between the posts).
+ */
+export declare const StairRailingStyle: z.ZodEnum<{
+    glass: "glass";
+    metal: "metal";
+    balusters: "balusters";
+    cable: "cable";
+    boards: "boards";
+    "post-and-rail": "post-and-rail";
+}>;
 export declare const StairType: z.ZodEnum<{
     straight: "straight";
     spiral: "spiral";
@@ -20,6 +40,7 @@ export declare const StairSlabOpeningMode: z.ZodEnum<{
     destination: "destination";
 }>;
 export type StairRailingMode = z.infer<typeof StairRailingMode>;
+export type StairRailingStyle = z.infer<typeof StairRailingStyle>;
 export type StairType = z.infer<typeof StairType>;
 export type StairTopLandingMode = z.infer<typeof StairTopLandingMode>;
 export type StairSlabOpeningMode = z.infer<typeof StairSlabOpeningMode>;
@@ -44,6 +65,32 @@ export declare const StairNode: 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<`stair_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"stair">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -197,9 +244,33 @@ export declare const StairNode: z.ZodObject<{
     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>;
     thickness: z.ZodDefault<z.ZodNumber>;
     fillToFloor: z.ZodDefault<z.ZodBoolean>;
+    construction: z.ZodOptional<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>>;
     innerRadius: z.ZodDefault<z.ZodNumber>;
     sweepAngle: z.ZodDefault<z.ZodNumber>;
     topLandingMode: z.ZodDefault<z.ZodEnum<{
@@ -210,12 +281,58 @@ export declare const StairNode: z.ZodObject<{
     showCenterColumn: z.ZodDefault<z.ZodBoolean>;
     showStepSupports: z.ZodDefault<z.ZodBoolean>;
     railingMode: z.ZodDefault<z.ZodEnum<{
-        right: "right";
         left: "left";
+        right: "right";
         none: "none";
         both: "both";
     }>>;
     railingHeight: z.ZodDefault<z.ZodNumber>;
+    railingStyle: z.ZodOptional<z.ZodEnum<{
+        glass: "glass";
+        metal: "metal";
+        balusters: "balusters";
+        cable: "cable";
+        boards: "boards";
+        "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<{
+            left: "left";
+            right: "right";
+            none: "none";
+            both: "both";
+        }>>;
+        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<{
+                wall: "wall";
+                floor: "floor";
+                none: "none";
+                post: "post";
+            }>>;
+            returnLength: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        top: z.ZodOptional<z.ZodObject<{
+            extension: z.ZodDefault<z.ZodNumber>;
+            return: z.ZodDefault<z.ZodEnum<{
+                wall: "wall";
+                floor: "floor";
+                none: "none";
+                post: "post";
+            }>>;
+            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;AAIvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAK3D,eAAO,MAAM,gBAAgB;;;;;EAA4C,CAAA;AACzE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;;;;;;;EAO5B,CAAA;AACF,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,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoGrB,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,38 @@ 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';
+export { StairDesignTargets } from './stair-design-targets.js';
+import { StairConstruction } from './stair-construction.js';
 import { StairSegmentNode } from './stair-segment.js';
 export const StairRailingMode = z.enum(['none', 'left', 'right', 'both']);
+/**
+ * How a straight flight's guard is built: 'balusters' — the round baluster
+ * at every nosing with two round rails (the original); 'post-and-rail' —
+ * the way a deck stair is built: 4x4 posts no more than 4 ft apart (two on a
+ * short flight), a top rail and a bottom rail following the flight, 1½ in
+ * pickets between them at a 4 in-sphere gap (IRC R312.1.3); 'cable' — slim 2 in
+ * posts spaced by run under a flat cap rail, with slender round cables 3 in
+ * apart pulled as straight spans from post to post and a swage sleeve at each
+ * terminal post (the modern cable rail; the cap follows a curve but the taut
+ * cables span straight between the posts).
+ */
+export const StairRailingStyle = z.enum([
+    'balusters',
+    'post-and-rail',
+    'cable',
+    'boards',
+    'glass',
+    'metal',
+]);
 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 +64,12 @@ 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),
     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 +78,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 +113,7 @@ 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
   - 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 +124,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

@@ -15,6 +15,32 @@ export declare const StructuralGridNode: 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<`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

@@ -4,7 +4,10 @@ export declare const SurfaceHoleMetadata: 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>;

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

@@ -20,6 +20,32 @@ export declare const TurbineVentNode: 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<`tvent_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"turbine-vent">>;
     material: 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

@@ -16,6 +16,32 @@ export declare const UnitNode: z.ZodObject<{
         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<{
+                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<`unit_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"unit">>;
     name: z.ZodDefault<z.ZodString>;

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

@@ -1 +1 @@
-{"version":3,"file":"unit.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/unit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,UAAU,8DAA+D,CAAA;AACtF,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAClD,eAAO,MAAM,kBAAkB,YAAY,CAAA;AAE3C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"unit.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/unit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,UAAU,8DAA+D,CAAA;AACtF,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAClD,eAAO,MAAM,kBAAkB,YAAY,CAAA;AAE3C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}