@pascal-app/core 0.8.0 → 0.9.2

package/dist/schema/nodes/wall.test.js

@@ -0,0 +1,208 @@
+import { describe, expect, test } from 'bun:test';
+import { buildEnabledWallFaceBandPatch, buildWallFaceBandCountPatch, getWallFaceBandConfig, WALL_CHAIR_RAIL_DEFAULT, WALL_CHAIR_RAIL_SLOT_DEFAULT, WALL_CROWN_DEFAULT, WALL_CROWN_SLOT_DEFAULT, WALL_FACE_BAND_DEFAULT, WALL_FACE_BAND_SOLID_SLOT_DEFAULTS, WALL_SKIRTING_DEFAULT, WALL_SKIRTING_SLOT_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, WallFaceBandConfig, WallTrimConfig, } from './wall';
+describe('wall face bands', () => {
+    test('defaults to one band while preserving legacy enabled scenes as three bands', () => {
+        expect(WALL_FACE_BAND_DEFAULT.count).toBe(1);
+        expect(WALL_FACE_BAND_DEFAULT.lowerHeight).toBe(0.84);
+        expect(WALL_FACE_BAND_DEFAULT.middleHeight).toBe(0.61);
+        expect(WALL_FACE_BAND_DEFAULT.upperHeight).toBe(0.61);
+        expect(WallFaceBandConfig.parse({})).toEqual({
+            enabled: false,
+            count: 1,
+            lowerHeight: 0.84,
+            middleHeight: 0.61,
+            upperHeight: 0.61,
+        });
+        expect(WallFaceBandConfig.parse({ enabled: true })).toEqual({
+            enabled: true,
+            count: 3,
+            lowerHeight: 0.84,
+            middleHeight: 0.61,
+            upperHeight: 0.61,
+        });
+        expect(getWallFaceBandConfig({
+            height: 2.5,
+            faceBands: {
+                enabled: true,
+                count: 3,
+                lowerHeight: 0.84,
+                middleHeight: 0.61,
+                upperHeight: 0.61,
+            },
+        })).toMatchObject({
+            count: 3,
+            lowerTop: 0.84,
+            middleTop: 1.45,
+        });
+    });
+    test('four bands adds an upper split below the final top band', () => {
+        expect(getWallFaceBandConfig({
+            height: 2.5,
+            faceBands: {
+                enabled: true,
+                count: 4,
+                lowerHeight: 0.5,
+                middleHeight: 0.6,
+                upperHeight: 0.7,
+            },
+        })).toMatchObject({
+            count: 4,
+            lowerTop: 0.5,
+            middleTop: 1.1,
+            upperTop: 1.8,
+        });
+    });
+    test('enabling bands seeds visible solid-color band slots', () => {
+        const patch = buildEnabledWallFaceBandPatch({
+            faceBands: {
+                enabled: false,
+                count: 1,
+                lowerHeight: 0.2,
+                middleHeight: 0.3,
+                upperHeight: 0.61,
+            },
+            slots: {
+                interior: 'library:interior-finish',
+                exterior: 'scene:exterior-finish',
+                lowerInterior: 'library:stale-lower',
+                middleExterior: 'library:stale-middle',
+            },
+        });
+        expect(patch.faceBands).toEqual({
+            enabled: true,
+            count: 2,
+            lowerHeight: 0.2,
+            middleHeight: 0.3,
+            upperHeight: 0.61,
+        });
+        expect(patch.slots).toMatchObject({
+            interior: 'library:interior-finish',
+            exterior: 'scene:exterior-finish',
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            upperInterior: 'library:interior-finish',
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            upperExterior: 'scene:exterior-finish',
+        });
+        expect(patch.slots?.middleInterior).toBeUndefined();
+        expect(patch.slots?.middleExterior).toBeUndefined();
+    });
+    test('band count patch enables only the active slots', () => {
+        const patch = buildWallFaceBandCountPatch({
+            faceBands: {
+                enabled: true,
+                count: 4,
+                lowerHeight: 0.2,
+                middleHeight: 0.3,
+                upperHeight: 0.61,
+            },
+            slots: {
+                interior: 'library:interior-finish',
+                exterior: 'scene:exterior-finish',
+                topInterior: 'library:stale-top',
+            },
+        }, 3);
+        expect(patch.faceBands).toMatchObject({ enabled: true, count: 3 });
+        expect(patch.slots).toMatchObject({
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperInterior: 'library:stale-top',
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperExterior: 'scene:exterior-finish',
+        });
+        expect(patch.slots?.topInterior).toBeUndefined();
+        expect(patch.slots?.topExterior).toBeUndefined();
+    });
+    test('enabling bands replaces stale inactive band slots with solid-color defaults', () => {
+        const patch = buildEnabledWallFaceBandPatch({
+            slots: {
+                lowerInterior: 'library:stale-lower',
+                middleInterior: 'library:stale-middle',
+                upperExterior: 'library:stale-upper',
+            },
+        });
+        expect(patch.slots).toEqual({
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            upperInterior: WALL_SURFACE_SLOT_DEFAULTS.interior,
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            upperExterior: WALL_SURFACE_SLOT_DEFAULTS.exterior,
+        });
+        expect(patch.slots?.middleInterior).toBeUndefined();
+        expect(patch.slots?.middleExterior).toBeUndefined();
+    });
+    test('increasing band count paints newly active bands with the solid palette', () => {
+        const patch = buildWallFaceBandCountPatch({
+            faceBands: {
+                enabled: true,
+                count: 2,
+                lowerHeight: 0.2,
+                middleHeight: 0.3,
+                upperHeight: 0.61,
+            },
+            slots: {
+                lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+                upperInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+                lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+                upperExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+            },
+        }, 3);
+        expect(patch.slots).toMatchObject({
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+        });
+    });
+    test('increasing to four bands keeps the previous top material on the new top band', () => {
+        const patch = buildWallFaceBandCountPatch({
+            faceBands: {
+                enabled: true,
+                count: 3,
+                lowerHeight: 0.2,
+                middleHeight: 0.3,
+                upperHeight: 0.61,
+            },
+            slots: {
+                lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+                middleInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+                upperInterior: 'scene:painted-top-interior',
+                lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+                middleExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+                upperExterior: 'library:painted-top-exterior',
+            },
+        }, 4);
+        expect(patch.slots).toMatchObject({
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+            topInterior: 'scene:painted-top-interior',
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+            topExterior: 'library:painted-top-exterior',
+        });
+    });
+});
+describe('wall trim profiles', () => {
+    test('uses curated defaults while preserving legacy profile values', () => {
+        expect(WALL_SKIRTING_DEFAULT.profile).toBe('flat');
+        expect(WALL_CROWN_DEFAULT.profile).toBe('flat');
+        expect(WALL_CHAIR_RAIL_DEFAULT.profile).toBe('flat');
+        expect(WallTrimConfig.parse({ profile: 'flat' }).profile).toBe('flat');
+        expect(WallTrimConfig.parse({ profile: 'crown-layered' }).profile).toBe('crown-layered');
+        expect(WallTrimConfig.parse({ profile: 'triangle' }).profile).toBe('triangle');
+    });
+    test('declares separate default materials for each trim family', () => {
+        expect(WALL_SKIRTING_SLOT_DEFAULT).toBe('library:preset-softwhite');
+        expect(WALL_CROWN_SLOT_DEFAULT).toBe('library:preset-white');
+        expect(WALL_CHAIR_RAIL_SLOT_DEFAULT).toBe('library:preset-cream');
+        expect(WALL_SURFACE_SLOT_DEFAULTS.skirtingInterior).toBe(WALL_SKIRTING_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.skirtingExterior).toBe(WALL_SKIRTING_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.crownInterior).toBe(WALL_CROWN_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.crownExterior).toBe(WALL_CROWN_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.chairRailInterior).toBe(WALL_CHAIR_RAIL_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.chairRailExterior).toBe(WALL_CHAIR_RAIL_SLOT_DEFAULT);
+    });
+});

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

@@ -32,7 +32,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 +43,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 +62,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,6 +70,13 @@ 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>;
     openingKind: z.ZodDefault<z.ZodEnum<{
@@ -97,8 +105,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,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuErB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schema/nodes/window.js

@@ -18,11 +18,23 @@ 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),

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

@@ -17,6 +17,8 @@ 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}`>>>>;
     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;;;;;;;;;;;;;;;;;;;;;;iBA0BpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/zone.js

@@ -7,6 +7,10 @@ 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([]),
     // Visual styling
     color: z.string().default('#3b82f6'), // Default blue
     metadata: z.json().optional().default({}),
@@ -17,6 +21,8 @@ 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
   - 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,
+});