@pascal-app/core 1.0.3 → 1.0.5

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

@@ -1,4 +1,117 @@
 import { z } from 'zod';
+/**
+ * A room's floor finish built by a three.js module for the room's floor (`lib/floor-script`): the
+ * module gets the floor's polygon and elevation and lays the planks, tiles or boards on exactly that
+ * outline. `inputs` is the key of the floor it was built for; once the room's floor differs (a wall
+ * moved, an edge pushed) the script is stale and runs again for the new one.
+ */
+export declare const ZoneFloorScript: z.ZodObject<{
+    kind: z.ZodLiteral<"script">;
+    meta: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        parent: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    language: z.ZodDefault<z.ZodEnum<{
+        bpy: "bpy";
+        three: "three";
+    }>>;
+    script: z.ZodString;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
+    artifact: z.ZodString;
+    manifest: z.ZodObject<{
+        bounds: z.ZodObject<{
+            min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>;
+        params: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                boolean: "boolean";
+                number: "number";
+                string: "string";
+            }>;
+            default: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            step: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        parts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            bounds: z.ZodOptional<z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        surfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            part: z.ZodOptional<z.ZodString>;
+            y: z.ZodNumber;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strip>>>;
+        slots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            roughness: z.ZodOptional<z.ZodNumber>;
+            metalness: z.ZodOptional<z.ZodNumber>;
+            transparent: z.ZodOptional<z.ZodBoolean>;
+            emissive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        anchors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            normal: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strip>>>;
+        lights: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            color: z.ZodString;
+            intensity: z.ZodNumber;
+            distance: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            part: z.ZodOptional<z.ZodString>;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            plane: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>>>;
+        animations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            duration: z.ZodNumber;
+        }, z.core.$strip>>>;
+        cutters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            host: z.ZodEnum<{
+                ceiling: "ceiling";
+                mounted: "mounted";
+                slab: "slab";
+                wall: "wall";
+            }>;
+            polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+            minY: z.ZodNumber;
+            maxY: z.ZodNumber;
+        }, z.core.$strip>>>;
+        cutout: z.ZodDefault<z.ZodBoolean>;
+        collider: z.ZodDefault<z.ZodBoolean>;
+        triangles: z.ZodNumber;
+        coverage: z.ZodOptional<z.ZodNumber>;
+        uncovered: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            min: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            max: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    images: z.ZodOptional<z.ZodObject<{
+        artifact: z.ZodString;
+        thumbnail: z.ZodString;
+        floorPlan: z.ZodString;
+    }, z.core.$strip>>;
+    inputs: z.ZodString;
+}, z.core.$strip>;
+export type ZoneFloorScript = z.infer<typeof ZoneFloorScript>;
 export declare const ZoneNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -7,18 +120,192 @@ export declare const ZoneNode: 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<`zone_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"zone">>;
     name: z.ZodString;
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    holes: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     autoFromWalls: z.ZodDefault<z.ZodBoolean>;
     boundaryWallIds: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>>>;
+    boundarySeparatorIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    hostZoneId: z.ZodOptional<z.ZodString>;
+    seed: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    floor: z.ZodOptional<z.ZodObject<{
+        elevation: z.ZodOptional<z.ZodNumber>;
+        support: z.ZodOptional<z.ZodLiteral<"open">>;
+        footprint: z.ZodOptional<z.ZodString>;
+        thickness: z.ZodOptional<z.ZodNumber>;
+        sourceSlabId: z.ZodOptional<z.ZodTemplateLiteral<`slab_${string}`>>;
+        finish: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        regions: z.ZodOptional<z.ZodArray<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>>>;
+        script: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"script">;
+            meta: z.ZodOptional<z.ZodObject<{
+                description: z.ZodOptional<z.ZodString>;
+                category: z.ZodOptional<z.ZodString>;
+                tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                parent: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            language: z.ZodDefault<z.ZodEnum<{
+                bpy: "bpy";
+                three: "three";
+            }>>;
+            script: z.ZodString;
+            params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
+            artifact: z.ZodString;
+            manifest: z.ZodObject<{
+                bounds: z.ZodObject<{
+                    min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                }, z.core.$strip>;
+                params: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                    kind: z.ZodEnum<{
+                        boolean: "boolean";
+                        number: "number";
+                        string: "string";
+                    }>;
+                    default: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+                    min: z.ZodOptional<z.ZodNumber>;
+                    max: z.ZodOptional<z.ZodNumber>;
+                    step: z.ZodOptional<z.ZodNumber>;
+                    unit: z.ZodOptional<z.ZodString>;
+                    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                parts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                    type: z.ZodOptional<z.ZodString>;
+                    bounds: z.ZodOptional<z.ZodObject<{
+                        min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                        max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>>;
+                surfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    part: z.ZodOptional<z.ZodString>;
+                    y: z.ZodNumber;
+                    polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                }, z.core.$strip>>>;
+                slots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                    color: z.ZodOptional<z.ZodString>;
+                    roughness: z.ZodOptional<z.ZodNumber>;
+                    metalness: z.ZodOptional<z.ZodNumber>;
+                    transparent: z.ZodOptional<z.ZodBoolean>;
+                    emissive: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>>;
+                anchors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    normal: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+                }, z.core.$strip>>>;
+                lights: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    color: z.ZodString;
+                    intensity: z.ZodNumber;
+                    distance: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+                undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    part: z.ZodOptional<z.ZodString>;
+                    polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                    plane: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                }, z.core.$strip>>>;
+                animations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    duration: z.ZodNumber;
+                }, z.core.$strip>>>;
+                cutters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    host: z.ZodEnum<{
+                        ceiling: "ceiling";
+                        mounted: "mounted";
+                        slab: "slab";
+                        wall: "wall";
+                    }>;
+                    polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+                    minY: z.ZodNumber;
+                    maxY: z.ZodNumber;
+                }, z.core.$strip>>>;
+                cutout: z.ZodDefault<z.ZodBoolean>;
+                collider: z.ZodDefault<z.ZodBoolean>;
+                triangles: z.ZodNumber;
+                coverage: z.ZodOptional<z.ZodNumber>;
+                uncovered: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    min: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+                    max: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+            images: z.ZodOptional<z.ZodObject<{
+                artifact: z.ZodString;
+                thumbnail: z.ZodString;
+                floorPlan: z.ZodString;
+            }, z.core.$strip>>;
+            inputs: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    ceiling: z.ZodOptional<z.ZodObject<{
+        regions: z.ZodOptional<z.ZodArray<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>>>;
+    }, z.core.$strip>>;
+    floorStepFinish: z.ZodOptional<z.ZodString>;
+    floorStepOverrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        step: z.ZodOptional<z.ZodNumber>;
+        finish: z.ZodString;
+    }, z.core.$strip>>>;
+    floorEdgeFinish: z.ZodOptional<z.ZodString>;
+    wallMaterial: z.ZodOptional<z.ZodString>;
+    wallOverrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        wallId: z.ZodString;
+        face: z.ZodEnum<{
+            a: "a";
+            b: "b";
+        }>;
+        finish: z.ZodString;
+    }, z.core.$strip>>>;
+    hasFloor: z.ZodOptional<z.ZodLiteral<false>>;
+    hasCeiling: z.ZodOptional<z.ZodLiteral<false>>;
     spaceRole: z.ZodDefault<z.ZodEnum<{
         generic: "generic";
         room: "room";
@@ -26,8 +313,8 @@ export declare const ZoneNode: z.ZodObject<{
     roomNumber: z.ZodDefault<z.ZodString>;
     enclosureStatus: z.ZodDefault<z.ZodEnum<{
         auto: "auto";
-        open: "open";
         enclosed: "enclosed";
+        open: "open";
     }>>;
     floorFinish: z.ZodDefault<z.ZodString>;
     wallFinish: z.ZodDefault<z.ZodString>;
@@ -35,9 +322,9 @@ export declare const ZoneNode: z.ZodObject<{
     ceilingHeight: z.ZodDefault<z.ZodNumber>;
     occupancy: z.ZodDefault<z.ZodString>;
     clearDimensionPolicy: z.ZodDefault<z.ZodEnum<{
-        none: "none";
-        "inside-faces": "inside-faces";
         "finish-faces": "finish-faces";
+        "inside-faces": "inside-faces";
+        none: "none";
     }>>;
     color: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;

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

@@ -1 +1 @@
-{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsD,CAAA;AAClF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4FpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/zone.js

@@ -1,6 +1,15 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
+import { GeometryScriptSource } from '../geometry-source.js';
+import { SurfacePaintRegion } from './surface-paint-region.js';
+/**
+ * A room's floor finish built by a three.js module for the room's floor (`lib/floor-script`): the
+ * module gets the floor's polygon and elevation and lays the planks, tiles or boards on exactly that
+ * outline. `inputs` is the key of the floor it was built for; once the room's floor differs (a wall
+ * moved, an edge pushed) the script is stale and runs again for the new one.
+ */
+export const ZoneFloorScript = GeometryScriptSource.extend({ inputs: z.string() });
 export const ZoneNode = BaseNode.extend({
     id: objectId('zone'),
     type: nodeType('zone'),
@@ -9,8 +18,52 @@ export const ZoneNode = BaseNode.extend({
     polygon: z.array(z.tuple([z.number(), z.number()])),
     // Procedural room zones retain the walls that prove their enclosure. The
     // stored polygon remains a fallback for missing or temporarily open walls.
+    holes: z.array(z.array(z.tuple([z.number(), z.number()]))).default([]),
     autoFromWalls: z.boolean().default(false),
     boundaryWallIds: z.array(objectId('wall')).default([]),
+    boundarySeparatorIds: z.array(z.string()).default([]),
+    hostZoneId: z.string().optional(),
+    seed: z.tuple([z.number(), z.number()]).optional(),
+    floor: z
+        .object({
+        elevation: z.number().optional(),
+        support: z.literal('open').optional(),
+        footprint: z.string().min(1).optional(),
+        thickness: z.number().min(0.02).optional(),
+        sourceSlabId: z.templateLiteral(['slab_', z.string()]).optional(),
+        finish: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+        regions: z.array(SurfacePaintRegion).optional(),
+        script: ZoneFloorScript.optional(),
+    })
+        .optional(),
+    // Painted parts of the room's ceiling. The automatic ceilings are rebuilt
+    // from the room, so what the user painted on them lives here.
+    ceiling: z
+        .object({
+        regions: z.array(SurfacePaintRegion).optional(),
+    })
+        .optional(),
+    floorStepFinish: z.string().optional(),
+    // Per-doorway step paint over `floorStepFinish`, keyed by the door the step
+    // sits under or the lower room it looks at (see `lib/floor-step-finish`).
+    floorStepOverrides: z
+        .array(z.object({
+        key: z.string(),
+        step: z.number().int().min(0).optional(),
+        finish: z.string(),
+    }))
+        .optional(),
+    floorEdgeFinish: z.string().optional(),
+    wallMaterial: z.string().optional(),
+    wallOverrides: z
+        .array(z.object({
+        wallId: z.string(),
+        face: z.enum(['a', 'b']),
+        finish: z.string(),
+    }))
+        .optional(),
+    hasFloor: z.literal(false).optional(),
+    hasCeiling: z.literal(false).optional(),
     // Generic zones remain available for sites and analysis. Architectural
     // room documentation is opt-in so legacy zone behavior is unchanged.
     spaceRole: z.enum(['generic', 'room']).default('generic'),
@@ -36,6 +89,9 @@ export const ZoneNode = BaseNode.extend({
   - boundaryWallIds: wall ids that prove the procedural enclosure
   - spaceRole: generic site/analysis zone or architectural room
   - roomNumber/finishes/ceilingHeight/occupancy: construction-document room metadata
+  - floor.regions / ceiling.regions: painted parts of the room's floor and ceiling ([x, z] polygons, later wins)
+  - floor.script: a three.js module that builds the room's floor finish (boards, tiles) for its floor polygon, drawn over the floor; it owns its colours
+  - floorStepFinish: finish of the room's steps; floorStepOverrides: per-doorway step finishes keyed by door id (or the lower room id), optional step index
   - enclosureStatus: auto-detected, explicitly enclosed, or open
   - clearDimensionPolicy: optional room clear-dimension datum preference
   - color: hex color for visual styling

package/dist/schema/provenance.d.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+/**
+ * Typed source identity of a node (owner decision D5): which source elements
+ * it reproduces, and which nodes it was derived from by an edit.
+ *
+ * The field is `provenance`, not `source`: a hosted third-party plugin already
+ * declares its own top-level `source` (`articraft:asset`), and `.extend()`
+ * would silently replace the base field for that kind.
+ *
+ * Caps are fixed and never enforced by truncation. A node over a cap fails
+ * its schema, so every validated writer (store, hosted save, collaboration,
+ * MCP) refuses it with an issue at the capped path, while load keeps a stored
+ * node verbatim. A writer with more ids than fit must refuse, or keep the
+ * extra ids off the node (sub-record `src`, the import artifact's alias table).
+ *
+ * Length caps are UTF-8 bytes (F8): every string is printable ASCII, one byte
+ * per character, and an importer percent-encodes anything else, which keeps
+ * the id exactly recoverable. A byte-counting refinement would not survive the
+ * JSON Schema snapshot hosted plugins are validated by. A maximal value,
+ * JSON escapes included, serialises to under 24 KiB, the F8 field cap. Bulk
+ * writers chunk their operations by encoded bytes.
+ */
+/** Refs per node. The /next house's largest node carries 18 source ids. */
+export declare const PROVENANCE_MAX_REFS = 32;
+/** Node ids in one lineage record (the pieces of a merge). */
+export declare const PROVENANCE_MAX_LINEAGE_IDS = 32;
+/** A namespace: `al` (a SketchUp source at a config hash), `ifc:<file>`, `cap:<capture>`. */
+export declare const PROVENANCE_MAX_NAMESPACE_BYTES = 48;
+/** A source id, stored verbatim (never slugged). The house's longest is 72. */
+export declare const PROVENANCE_MAX_ID_BYTES = 160;
+/** A node id, as the collaboration protocol bounds it. */
+export declare const PROVENANCE_MAX_NODE_ID_BYTES = 128;
+/**
+ * How a ref claims its source element:
+ * - `primary`: this node reproduces the element 1:1 (the default when absent);
+ * - `piece`: one of several declared pieces across sibling nodes, scored on their union;
+ * - `absorbed`: folded into this node without an address of its own (traceable, never exact);
+ * - `alias`: a retired id that resolves to this node;
+ * - `derived`: a copy or user variant; it never claims the element.
+ */
+export declare const ProvenanceRole: z.ZodEnum<{
+    absorbed: "absorbed";
+    alias: "alias";
+    derived: "derived";
+    piece: "piece";
+    primary: "primary";
+}>;
+export type ProvenanceRole = z.infer<typeof ProvenanceRole>;
+export declare const ProvenanceRef: 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>;
+export type ProvenanceRef = z.infer<typeof ProvenanceRef>;
+export declare const ProvenanceLineageOp: z.ZodEnum<{
+    attach: "attach";
+    convert: "convert";
+    duplicate: "duplicate";
+    import: "import";
+    "make-independent": "make-independent";
+    merge: "merge";
+    promote: "promote";
+    split: "split";
+}>;
+export type ProvenanceLineageOp = z.infer<typeof ProvenanceLineageOp>;
+/**
+ * The last edit that derived this node, and the node ids it came from. The ids
+ * are history: they are compared, never dereferenced, and may name nodes that
+ * no longer exist (the other walls of a merge).
+ */
+export declare const ProvenanceLineage: 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>;
+export type ProvenanceLineage = z.infer<typeof ProvenanceLineage>;
+export declare const Provenance: 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>;
+export type Provenance = z.infer<typeof Provenance>;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/schema/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../src/schema/provenance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,KAAK,CAAA;AACrC,8DAA8D;AAC9D,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAC5C,6FAA6F;AAC7F,eAAO,MAAM,8BAA8B,KAAK,CAAA;AAChD,+EAA+E;AAC/E,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAC1C,0DAA0D;AAC1D,eAAO,MAAM,4BAA4B,MAAM,CAAA;AAY/C;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;;;;EAA+D,CAAA;AAC1F,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,aAAa;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEzD,eAAO,MAAM,mBAAmB;;;;;;;;;EAS9B,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;iBAG5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEjE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schema/provenance.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+/**
+ * Typed source identity of a node (owner decision D5): which source elements
+ * it reproduces, and which nodes it was derived from by an edit.
+ *
+ * The field is `provenance`, not `source`: a hosted third-party plugin already
+ * declares its own top-level `source` (`articraft:asset`), and `.extend()`
+ * would silently replace the base field for that kind.
+ *
+ * Caps are fixed and never enforced by truncation. A node over a cap fails
+ * its schema, so every validated writer (store, hosted save, collaboration,
+ * MCP) refuses it with an issue at the capped path, while load keeps a stored
+ * node verbatim. A writer with more ids than fit must refuse, or keep the
+ * extra ids off the node (sub-record `src`, the import artifact's alias table).
+ *
+ * Length caps are UTF-8 bytes (F8): every string is printable ASCII, one byte
+ * per character, and an importer percent-encodes anything else, which keeps
+ * the id exactly recoverable. A byte-counting refinement would not survive the
+ * JSON Schema snapshot hosted plugins are validated by. A maximal value,
+ * JSON escapes included, serialises to under 24 KiB, the F8 field cap. Bulk
+ * writers chunk their operations by encoded bytes.
+ */
+/** Refs per node. The /next house's largest node carries 18 source ids. */
+export const PROVENANCE_MAX_REFS = 32;
+/** Node ids in one lineage record (the pieces of a merge). */
+export const PROVENANCE_MAX_LINEAGE_IDS = 32;
+/** A namespace: `al` (a SketchUp source at a config hash), `ifc:<file>`, `cap:<capture>`. */
+export const PROVENANCE_MAX_NAMESPACE_BYTES = 48;
+/** A source id, stored verbatim (never slugged). The house's longest is 72. */
+export const PROVENANCE_MAX_ID_BYTES = 160;
+/** A node id, as the collaboration protocol bounds it. */
+export const PROVENANCE_MAX_NODE_ID_BYTES = 128;
+const PRINTABLE_ASCII = /^[\x20-\x7E]*$/;
+/** A non-empty printable-ASCII string of at most `bytes` UTF-8 bytes. */
+const asciiString = (bytes) => z
+    .string()
+    .min(1)
+    .max(bytes)
+    .regex(PRINTABLE_ASCII, 'Printable ASCII only: percent-encode other characters.');
+/**
+ * How a ref claims its source element:
+ * - `primary`: this node reproduces the element 1:1 (the default when absent);
+ * - `piece`: one of several declared pieces across sibling nodes, scored on their union;
+ * - `absorbed`: folded into this node without an address of its own (traceable, never exact);
+ * - `alias`: a retired id that resolves to this node;
+ * - `derived`: a copy or user variant; it never claims the element.
+ */
+export const ProvenanceRole = z.enum(['primary', 'piece', 'absorbed', 'alias', 'derived']);
+export const ProvenanceRef = z.object({
+    ns: asciiString(PROVENANCE_MAX_NAMESPACE_BYTES).optional(),
+    id: asciiString(PROVENANCE_MAX_ID_BYTES),
+    role: ProvenanceRole.optional(),
+});
+export const ProvenanceLineageOp = z.enum([
+    'import',
+    'split',
+    'merge',
+    'duplicate',
+    'convert',
+    'promote',
+    'make-independent',
+    'attach',
+]);
+/**
+ * The last edit that derived this node, and the node ids it came from. The ids
+ * are history: they are compared, never dereferenced, and may name nodes that
+ * no longer exist (the other walls of a merge).
+ */
+export const ProvenanceLineage = z.object({
+    op: ProvenanceLineageOp,
+    fromIds: z.array(asciiString(PROVENANCE_MAX_NODE_ID_BYTES)).max(PROVENANCE_MAX_LINEAGE_IDS),
+});
+export const Provenance = z.object({
+    refs: z.array(ProvenanceRef).max(PROVENANCE_MAX_REFS),
+    lineage: ProvenanceLineage.optional(),
+});

package/dist/schema/scene-material.d.ts

@@ -7,16 +7,16 @@ export declare const SceneMaterial: z.ZodObject<{
     material: 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>;
@@ -25,9 +25,9 @@ export declare const SceneMaterial: 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<{