@pascal-app/core 0.9.1 → 1.0.0-beta.1

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

@@ -12,6 +12,18 @@ export declare const WindowType: z.ZodEnum<{
     louvered: "louvered";
 }>;
 export type WindowType = z.infer<typeof WindowType>;
+export declare const WindowConstructionType: z.ZodEnum<{
+    framed: "framed";
+    masonry: "masonry";
+}>;
+export declare const WindowDimensionReference: z.ZodEnum<{
+    nominal: "nominal";
+    "rough-opening": "rough-opening";
+    "masonry-opening": "masonry-opening";
+    "finish-opening": "finish-opening";
+}>;
+export type WindowConstructionType = z.infer<typeof WindowConstructionType>;
+export type WindowDimensionReference = z.infer<typeof WindowDimensionReference>;
 export declare const WindowNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -32,7 +44,7 @@ export declare const WindowNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"window">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -43,7 +55,7 @@ export declare const WindowNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -62,6 +74,7 @@ export declare const WindowNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    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.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     side: z.ZodOptional<z.ZodEnum<{
@@ -69,8 +82,32 @@ export declare const WindowNode: z.ZodObject<{
         back: "back";
     }>>;
     wallId: z.ZodOptional<z.ZodString>;
+    roofSegmentId: z.ZodOptional<z.ZodString>;
+    roofFace: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+        right: "right";
+        left: "left";
+    }>>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
+    mark: z.ZodOptional<z.ZodString>;
+    constructionType: z.ZodDefault<z.ZodEnum<{
+        framed: "framed";
+        masonry: "masonry";
+    }>>;
+    dimensionReference: z.ZodDefault<z.ZodEnum<{
+        nominal: "nominal";
+        "rough-opening": "rough-opening";
+        "masonry-opening": "masonry-opening";
+        "finish-opening": "finish-opening";
+    }>>;
+    roughOpeningWidth: z.ZodOptional<z.ZodNumber>;
+    roughOpeningHeight: z.ZodOptional<z.ZodNumber>;
+    masonryOpeningWidth: z.ZodOptional<z.ZodNumber>;
+    masonryOpeningHeight: z.ZodOptional<z.ZodNumber>;
+    finishOpeningWidth: z.ZodOptional<z.ZodNumber>;
+    finishOpeningHeight: z.ZodOptional<z.ZodNumber>;
     openingKind: z.ZodDefault<z.ZodEnum<{
         window: "window";
         opening: "opening";
@@ -97,8 +134,8 @@ export declare const WindowNode: z.ZodObject<{
         single: "single";
     }>>;
     hingesSide: z.ZodDefault<z.ZodEnum<{
-        left: "left";
         right: "right";
+        left: "left";
     }>>;
     openingShape: z.ZodDefault<z.ZodEnum<{
         rectangle: "rectangle";

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

@@ -1 +1 @@
-{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/window.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;;;;;;;;EAWrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}
+{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/window.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;;;;;;;;EAWrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD,eAAO,MAAM,sBAAsB;;;EAAgC,CAAA;AACnE,eAAO,MAAM,wBAAwB;;;;;EAKnC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schema/nodes/window.js

@@ -14,18 +14,48 @@ export const WindowType = z.enum([
     'bow',
     'louvered',
 ]);
+export const WindowConstructionType = z.enum(['framed', 'masonry']);
+export const WindowDimensionReference = z.enum([
+    'nominal',
+    'rough-opening',
+    'masonry-opening',
+    'finish-opening',
+]);
 export const WindowNode = BaseNode.extend({
     id: objectId('window'),
     type: nodeType('window'),
     material: MaterialSchema.optional(),
+    // Per-slot material overrides on the unified slot model. Keys: `frame`,
+    // `glass`. Value = a `MaterialRef` (`library:<id>` / `scene:<id>`). Absent =
+    // the frame/glass default. Mirrors `ShelfNode.slots`.
+    slots: z.record(z.string(), z.string()).optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     side: z.enum(['front', 'back']).optional(),
     // Wall reference
     wallId: z.string().optional(),
+    // Alternative host: a roof-segment's generated wall face (base wall
+    // under the roof or a coplanar gable end). When set, `position` is
+    // FACE-LOCAL — [u along the face, v height, z from the wall mid-plane]
+    // — exactly the wall-child convention; the renderer mounts the node
+    // inside the face frame (`getRoofWallFaceFrame`), which is what makes
+    // hosted children track segment resizes live.
+    roofSegmentId: z.string().optional(),
+    roofFace: z.enum(['front', 'back', 'right', 'left']).optional(),
     // Overall dimensions
     width: z.number().default(1.5),
     height: z.number().default(1.5),
+    // Construction-document identity and optional manufacturer rough opening.
+    // Legacy scenes omit these fields and continue to parse unchanged.
+    mark: z.string().trim().max(16).optional(),
+    constructionType: WindowConstructionType.default('framed'),
+    dimensionReference: WindowDimensionReference.default('nominal'),
+    roughOpeningWidth: z.number().positive().optional(),
+    roughOpeningHeight: z.number().positive().optional(),
+    masonryOpeningWidth: z.number().positive().optional(),
+    masonryOpeningHeight: z.number().positive().optional(),
+    finishOpeningWidth: z.number().positive().optional(),
+    finishOpeningHeight: z.number().positive().optional(),
     // Opening mode - when set to "opening", the window is only a shaped cutout
     openingKind: z.enum(['window', 'opening']).default('window'),
     // Window family

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

@@ -17,6 +17,28 @@ export declare const ZoneNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"zone">>;
     name: z.ZodString;
     polygon: 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}`>>>>;
+    spaceRole: z.ZodDefault<z.ZodEnum<{
+        generic: "generic";
+        room: "room";
+    }>>;
+    roomNumber: z.ZodDefault<z.ZodString>;
+    enclosureStatus: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        enclosed: "enclosed";
+        open: "open";
+    }>>;
+    floorFinish: z.ZodDefault<z.ZodString>;
+    wallFinish: z.ZodDefault<z.ZodString>;
+    ceilingFinish: z.ZodDefault<z.ZodString>;
+    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";
+    }>>;
     color: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
 }, z.core.$strip>;

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;;;;;;;;;;;;;;;;;;;;iBAoBpB,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;AAGvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/zone.js

@@ -7,6 +7,21 @@ export const ZoneNode = BaseNode.extend({
     name: z.string(),
     // Polygon boundary - array of [x, z] coordinates defining the zone
     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.
+    autoFromWalls: z.boolean().default(false),
+    boundaryWallIds: z.array(objectId('wall')).default([]),
+    // 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'),
+    roomNumber: z.string().trim().max(32).default(''),
+    enclosureStatus: z.enum(['auto', 'enclosed', 'open']).default('auto'),
+    floorFinish: z.string().trim().max(120).default(''),
+    wallFinish: z.string().trim().max(120).default(''),
+    ceilingFinish: z.string().trim().max(120).default(''),
+    ceilingHeight: z.number().min(0.1).default(2.7),
+    occupancy: z.string().trim().max(80).default(''),
+    clearDimensionPolicy: z.enum(['none', 'inside-faces', 'finish-faces']).default('none'),
     // Visual styling
     color: z.string().default('#3b82f6'), // Default blue
     metadata: z.json().optional().default({}),
@@ -17,6 +32,12 @@ export const ZoneNode = BaseNode.extend({
   - levelId: level this zone is attached to
   - name: zone name
   - polygon: array of [x, z] points defining the zone boundary
+  - autoFromWalls: whether the boundary follows an enclosed wall loop
+  - boundaryWallIds: wall ids that prove the procedural enclosure
+  - spaceRole: generic site/analysis zone or architectural room
+  - roomNumber/finishes/ceilingHeight/occupancy: construction-document room metadata
+  - enclosureStatus: auto-detected, explicitly enclosed, or open
+  - clearDimensionPolicy: optional room clear-dimension datum preference
   - color: hex color for visual styling
   - metadata: zone metadata (optional)
   `);

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export type SceneMaterialId = `mat_${string}`;
+export declare const generateSceneMaterialId: () => SceneMaterialId;
+export declare const SceneMaterial: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    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";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SceneMaterial = z.infer<typeof SceneMaterial>;
+//# sourceMappingURL=scene-material.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scene-material.d.ts","sourceRoot":"","sources":["../../src/schema/scene-material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,MAAM,MAAM,eAAe,GAAG,OAAO,MAAM,EAAE,CAAA;AAC7C,eAAO,MAAM,uBAAuB,QAAO,eAAoC,CAAA;AAE/E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}

package/dist/schema/scene-material.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { generateId } from './base';
+import { MaterialSchema } from './material';
+export const generateSceneMaterialId = () => generateId('mat');
+export const SceneMaterial = z.object({
+    id: z.string(),
+    name: z.string(),
+    material: MaterialSchema,
+});

package/dist/schema/terrain.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/** Current authoring and decoding ceiling. */
+export declare const MAX_TERRAIN_SIDE = 257;
+/**
+ * The persisted shape of a terrain heightfield.
+ *
+ * Kept in `schema/` rather than beside the codec because this is the contract
+ * the scene graph validates on load, and `lib/terrain-codec.ts` imports the type
+ * from here so there is exactly one definition of the wire format.
+ *
+ * `heights` is base64 of little-endian Int16 — see `lib/terrain-codec.ts` for why
+ * that beats a JSON number array, and why it is not compressed. The schema is
+ * intentionally loose about the *contents* of that string: validating base64
+ * here would duplicate the decoder, and `decodeTerrainField` already returns
+ * `null` for anything it cannot read, which is the behaviour a corrupt scene
+ * needs (load flat, don't fail the project).
+ */
+export declare const TerrainData: z.ZodObject<{
+    type: z.ZodLiteral<"heightfield">;
+    origin: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    spacing: z.ZodNumber;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+    step: z.ZodNumber;
+    heights: z.ZodString;
+}, z.core.$strip>;
+export type TerrainData = z.infer<typeof TerrainData>;
+//# sourceMappingURL=terrain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"terrain.d.ts","sourceRoot":"","sources":["../../src/schema/terrain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,8CAA8C;AAC9C,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAEnC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW;;;;;;;;iBAYtB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/dist/schema/terrain.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+/** Current authoring and decoding ceiling. */
+export const MAX_TERRAIN_SIDE = 257;
+/**
+ * The persisted shape of a terrain heightfield.
+ *
+ * Kept in `schema/` rather than beside the codec because this is the contract
+ * the scene graph validates on load, and `lib/terrain-codec.ts` imports the type
+ * from here so there is exactly one definition of the wire format.
+ *
+ * `heights` is base64 of little-endian Int16 — see `lib/terrain-codec.ts` for why
+ * that beats a JSON number array, and why it is not compressed. The schema is
+ * intentionally loose about the *contents* of that string: validating base64
+ * here would duplicate the decoder, and `decodeTerrainField` already returns
+ * `null` for anything it cannot read, which is the behaviour a corrupt scene
+ * needs (load flat, don't fail the project).
+ */
+export const TerrainData = z.object({
+    type: z.literal('heightfield'),
+    /** World XZ of sample [0,0]. */
+    origin: z.tuple([z.number().finite(), z.number().finite()]),
+    /** Metres between adjacent samples. */
+    spacing: z.number().finite().positive(),
+    cols: z.number().int().positive().max(MAX_TERRAIN_SIDE),
+    rows: z.number().int().positive().max(MAX_TERRAIN_SIDE),
+    /** Metres per height unit — the quantization ladder. */
+    step: z.number().finite().positive(),
+    /** Base64 of `cols * rows` little-endian Int16 samples, row-major. */
+    heights: z.string(),
+});