@pascal-app/core 1.0.0-beta.5 → 1.0.1

package/dist/schema/nodes/block.js

@@ -0,0 +1,206 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base.js';
+export const BlockVertex = z.object({
+    id: z.string().min(1),
+    position: z.tuple([z.number(), z.number(), z.number()]),
+});
+export const BlockEdge = z.object({
+    id: z.string().min(1),
+    vertexIds: z.tuple([z.string().min(1), z.string().min(1)]),
+});
+export const BlockFace = z.object({
+    id: z.string().min(1),
+    vertexIds: z.array(z.string().min(1)).min(3),
+    materialSlot: z.string().min(1).default('body'),
+});
+const BlockTopologyShape = z.object({
+    vertices: z.array(BlockVertex),
+    edges: z.array(BlockEdge),
+    faces: z.array(BlockFace),
+});
+function normalizeBlockVector(vector) {
+    const length = Math.hypot(vector[0], vector[1], vector[2]);
+    if (length < 1e-8)
+        return null;
+    return [vector[0] / length, vector[1] / length, vector[2] / length];
+}
+export function getBlockFaceNormal(topology, face) {
+    const vertices = new Map(topology.vertices.map((vertex) => [vertex.id, vertex.position]));
+    const positions = face.vertexIds
+        .map((id) => vertices.get(id))
+        .filter((value) => !!value);
+    if (positions.length < 3)
+        return null;
+    const normal = [0, 0, 0];
+    for (let index = 0; index < positions.length; index += 1) {
+        const current = positions[index];
+        const next = positions[(index + 1) % positions.length];
+        normal[0] += (current[1] - next[1]) * (current[2] + next[2]);
+        normal[1] += (current[2] - next[2]) * (current[0] + next[0]);
+        normal[2] += (current[0] - next[0]) * (current[1] + next[1]);
+    }
+    return normalizeBlockVector(normal);
+}
+export function getBlockFaceCentroid(topology, face) {
+    const vertices = new Map(topology.vertices.map((vertex) => [vertex.id, vertex.position]));
+    const positions = face.vertexIds
+        .map((id) => vertices.get(id))
+        .filter((value) => !!value);
+    if (positions.length !== face.vertexIds.length || positions.length === 0)
+        return null;
+    const sum = positions.reduce((total, position) => [total[0] + position[0], total[1] + position[1], total[2] + position[2]], [0, 0, 0]);
+    return [sum[0] / positions.length, sum[1] / positions.length, sum[2] / positions.length];
+}
+export function getBlockFaceFrame(topology, faceId) {
+    const face = topology.faces.find((candidate) => candidate.id === faceId);
+    if (!face)
+        return null;
+    const origin = getBlockFaceCentroid(topology, face);
+    const normal = getBlockFaceNormal(topology, face);
+    if (!(origin && normal))
+        return null;
+    const horizontal = [normal[2], 0, -normal[0]];
+    const xAxis = normalizeBlockVector(horizontal) ??
+        normalizeBlockVector([
+            1 - normal[0] * normal[0],
+            -normal[0] * normal[1],
+            -normal[0] * normal[2],
+        ]);
+    if (!xAxis)
+        return null;
+    const yAxis = normalizeBlockVector([
+        normal[1] * xAxis[2] - normal[2] * xAxis[1],
+        normal[2] * xAxis[0] - normal[0] * xAxis[2],
+        normal[0] * xAxis[1] - normal[1] * xAxis[0],
+    ]);
+    if (!yAxis)
+        return null;
+    return { origin, xAxis, yAxis, normal };
+}
+export function blockUndirectedEdgeKey(a, b) {
+    return a < b ? `${a}\u0000${b}` : `${b}\u0000${a}`;
+}
+export function inspectBlockTopology(topology) {
+    const issues = [];
+    const vertexIds = new Set();
+    const edgeIds = new Set();
+    const faceIds = new Set();
+    const edgeKeys = new Set();
+    topology.vertices.forEach((vertex, index) => {
+        if (vertexIds.has(vertex.id)) {
+            issues.push({ path: ['vertices', index, 'id'], message: `Duplicate vertex id: ${vertex.id}` });
+        }
+        vertexIds.add(vertex.id);
+    });
+    topology.edges.forEach((edge, index) => {
+        if (edgeIds.has(edge.id)) {
+            issues.push({ path: ['edges', index, 'id'], message: `Duplicate edge id: ${edge.id}` });
+        }
+        edgeIds.add(edge.id);
+        const [a, b] = edge.vertexIds;
+        if (a === b) {
+            issues.push({ path: ['edges', index, 'vertexIds'], message: 'An edge needs two vertices' });
+        }
+        edge.vertexIds.forEach((vertexId, vertexIndex) => {
+            if (!vertexIds.has(vertexId)) {
+                issues.push({
+                    path: ['edges', index, 'vertexIds', vertexIndex],
+                    message: `Unknown vertex id: ${vertexId}`,
+                });
+            }
+        });
+        const key = blockUndirectedEdgeKey(a, b);
+        if (edgeKeys.has(key)) {
+            issues.push({ path: ['edges', index], message: `Duplicate edge: ${a}–${b}` });
+        }
+        edgeKeys.add(key);
+    });
+    topology.faces.forEach((face, index) => {
+        if (faceIds.has(face.id)) {
+            issues.push({ path: ['faces', index, 'id'], message: `Duplicate face id: ${face.id}` });
+        }
+        faceIds.add(face.id);
+        if (new Set(face.vertexIds).size < 3) {
+            issues.push({ path: ['faces', index, 'vertexIds'], message: 'A face needs three vertices' });
+        }
+        face.vertexIds.forEach((vertexId, vertexIndex) => {
+            if (!vertexIds.has(vertexId)) {
+                issues.push({
+                    path: ['faces', index, 'vertexIds', vertexIndex],
+                    message: `Unknown vertex id: ${vertexId}`,
+                });
+            }
+            const nextVertexId = face.vertexIds[(vertexIndex + 1) % face.vertexIds.length];
+            if (nextVertexId && !edgeKeys.has(blockUndirectedEdgeKey(vertexId, nextVertexId))) {
+                issues.push({
+                    path: ['faces', index, 'vertexIds', vertexIndex],
+                    message: `Missing edge for face boundary: ${vertexId}–${nextVertexId}`,
+                });
+            }
+        });
+    });
+    return issues;
+}
+export const BlockTopology = BlockTopologyShape.superRefine((topology, context) => {
+    for (const issue of inspectBlockTopology(topology)) {
+        context.addIssue({ code: 'custom', path: issue.path, message: issue.message });
+    }
+});
+export function createBoxBlockTopology(width = 2, height = 2.4, depth = 2) {
+    const halfWidth = width / 2;
+    const halfDepth = depth / 2;
+    return {
+        vertices: [
+            { id: 'v0', position: [-halfWidth, 0, -halfDepth] },
+            { id: 'v1', position: [halfWidth, 0, -halfDepth] },
+            { id: 'v2', position: [halfWidth, 0, halfDepth] },
+            { id: 'v3', position: [-halfWidth, 0, halfDepth] },
+            { id: 'v4', position: [-halfWidth, height, -halfDepth] },
+            { id: 'v5', position: [halfWidth, height, -halfDepth] },
+            { id: 'v6', position: [halfWidth, height, halfDepth] },
+            { id: 'v7', position: [-halfWidth, height, halfDepth] },
+        ],
+        edges: [
+            { id: 'e0', vertexIds: ['v0', 'v1'] },
+            { id: 'e1', vertexIds: ['v1', 'v2'] },
+            { id: 'e2', vertexIds: ['v2', 'v3'] },
+            { id: 'e3', vertexIds: ['v3', 'v0'] },
+            { id: 'e4', vertexIds: ['v4', 'v5'] },
+            { id: 'e5', vertexIds: ['v5', 'v6'] },
+            { id: 'e6', vertexIds: ['v6', 'v7'] },
+            { id: 'e7', vertexIds: ['v7', 'v4'] },
+            { id: 'e8', vertexIds: ['v0', 'v4'] },
+            { id: 'e9', vertexIds: ['v1', 'v5'] },
+            { id: 'e10', vertexIds: ['v2', 'v6'] },
+            { id: 'e11', vertexIds: ['v3', 'v7'] },
+        ],
+        faces: [
+            { id: 'f-bottom', vertexIds: ['v0', 'v1', 'v2', 'v3'], materialSlot: 'body' },
+            { id: 'f-top', vertexIds: ['v4', 'v7', 'v6', 'v5'], materialSlot: 'body' },
+            { id: 'f-front', vertexIds: ['v0', 'v4', 'v5', 'v1'], materialSlot: 'body' },
+            { id: 'f-right', vertexIds: ['v1', 'v5', 'v6', 'v2'], materialSlot: 'body' },
+            { id: 'f-back', vertexIds: ['v2', 'v6', 'v7', 'v3'], materialSlot: 'body' },
+            { id: 'f-left', vertexIds: ['v3', 'v7', 'v4', 'v0'], materialSlot: 'body' },
+        ],
+    };
+}
+export const BlockNode = BaseNode.extend({
+    id: objectId('block'),
+    type: nodeType('block'),
+    children: z.array(z.string()).default([]),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.number().default(0),
+    supportSlabId: z.string().optional(),
+    topology: BlockTopology.default(createBoxBlockTopology),
+    slots: z.record(z.string(), z.string()).default({}),
+    slotNames: z.record(z.string(), z.string().min(1)).default({ body: 'Body' }),
+}).describe(dedent `
+  block node - a topology-backed editable solid.
+  - children: hosted node ids
+  - topology: persistent vertices, edges, and ordered face loops with stable IDs
+  - position/rotation: level-local placement transform
+  - supportSlabId: persisted placement surface that prevents later slabs from lifting the mesh
+  - slots: material references keyed by face materialSlot; an unbound body uses the wall-role default
+  - slotNames: user-facing names for stable material slots; body is the permanent default slot
+`);

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

@@ -1,4 +1,9 @@
 import { z } from 'zod';
+export declare const BoxVentMaterialRole: z.ZodEnum<{
+    base: "base";
+    top: "top";
+}>;
+export type BoxVentMaterialRole = z.infer<typeof BoxVentMaterialRole>;
 export declare const BoxVentNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -14,7 +19,7 @@ export declare const BoxVentNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`bvent_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"box-vent">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -49,6 +54,7 @@ export declare const BoxVentNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     materialPreset: z.ZodDefault<z.ZodString>;
     roofSegmentId: z.ZodOptional<z.ZodString>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
@@ -68,7 +74,7 @@ export declare const BoxVentNode: z.ZodObject<{
         box: "box";
         cap: "cap";
         dome: "dome";
-    }>>>;
+    }>>, unknown>;
 }, z.core.$strip>;
 export type BoxVentNode = z.infer<typeof BoxVentNode>;
 //# sourceMappingURL=box-vent.d.ts.map

package/dist/schema/nodes/box-vent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"box-vent.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/box-vent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEvB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA"}
+{"version":3,"file":"box-vent.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/box-vent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,mBAAmB;;;EAA0B,CAAA;AAC1D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkEvB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/dist/schema/nodes/box-vent.js

@@ -1,11 +1,13 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+export const BoxVentMaterialRole = z.enum(['base', 'top']);
 export const BoxVentNode = BaseNode.extend({
     id: objectId('bvent'),
     type: nodeType('box-vent'),
     material: MaterialSchema.optional(),
+    slots: z.record(z.string(), z.string()).optional(),
     // Default to the white preset so newly-placed vents read as clean
     // painted metal — and so the paint inspector shows "White" as the
     // current selection instead of an empty "no material" state, which

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

@@ -14,10 +14,10 @@ export declare const BuildingNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`building_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"building">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`elevator_${string}`>>]>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`elevator_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`unit_${string}`>>]>>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
 }, z.core.$strip>;

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

@@ -1 +1 @@
-{"version":3,"file":"building.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/building.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;iBAaxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"building.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/building.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;iBAexB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/schema/nodes/building.js

@@ -1,17 +1,20 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { ElevatorNode } from './elevator';
-import { LevelNode } from './level';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { ElevatorNode } from './elevator.js';
+import { LevelNode } from './level.js';
+import { UnitNode } from './unit.js';
 export const BuildingNode = BaseNode.extend({
     id: objectId('building'),
     type: nodeType('building'),
-    children: z.array(z.union([LevelNode.shape.id, ElevatorNode.shape.id])).default([]),
+    children: z
+        .array(z.union([LevelNode.shape.id, ElevatorNode.shape.id, UnitNode.shape.id]))
+        .default([]),
     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]),
 }).describe(dedent `
   Building node - used to represent a building
   - position: position in site coordinate system
   - rotation: rotation in site coordinate system
-  - children: array of level nodes and building-level systems such as elevators
+  - children: array of levels, units referencing zones, and building-level systems such as elevators
   `);

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

@@ -4,6 +4,18 @@ export declare const CabinetFrontStyleSchema: z.ZodEnum<{
     shaker: "shaker";
     "raised-arch": "raised-arch";
 }>;
+export declare const CabinetTopFinishSchema: z.ZodEnum<{
+    trim: "trim";
+    none: "none";
+    "top-cabinet": "top-cabinet";
+}>;
+/** Canonical metric cabinet family used when no regional profile is selected. */
+export declare const CABINET_METRIC_DEFAULTS: {
+    readonly depth: 0.6;
+    readonly carcassHeight: 0.8;
+    readonly plinthHeight: 0.1;
+    readonly countertopThickness: 0.02;
+};
 declare const CabinetCompartment: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"shelf">;
     shelfCount: z.ZodOptional<z.ZodNumber>;
@@ -123,7 +135,7 @@ export declare const CabinetNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     supportSlabId: z.ZodOptional<z.ZodString>;
@@ -145,6 +157,7 @@ export declare const CabinetNode: z.ZodObject<{
         shaker: "shaker";
         "raised-arch": "raised-arch";
     }>>;
+    panelReady: z.ZodDefault<z.ZodBoolean>;
     handleStyle: z.ZodDefault<z.ZodEnum<{
         none: "none";
         bar: "bar";
@@ -308,7 +321,7 @@ export declare const CabinetNode: z.ZodObject<{
         base: "base";
         tall: "tall";
     }>>;
-    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`cabinet-module_${string}`>>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodString>>;
     barLedge: z.ZodOptional<z.ZodObject<{
         edge: z.ZodDefault<z.ZodEnum<{
             back: "back";
@@ -319,6 +332,7 @@ export declare const CabinetNode: z.ZodObject<{
         depth: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     withWaterfall: z.ZodDefault<z.ZodBoolean>;
+    withFinishedEnds: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const CabinetModuleNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -335,7 +349,7 @@ export declare const CabinetModuleNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     supportSlabId: z.ZodOptional<z.ZodString>;
@@ -357,6 +371,7 @@ export declare const CabinetModuleNode: z.ZodObject<{
         shaker: "shaker";
         "raised-arch": "raised-arch";
     }>>;
+    panelReady: z.ZodDefault<z.ZodBoolean>;
     handleStyle: z.ZodDefault<z.ZodEnum<{
         none: "none";
         bar: "bar";
@@ -515,7 +530,7 @@ export declare const CabinetModuleNode: z.ZodObject<{
     }, z.core.$strip>], "type">>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`cabinet-module_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"cabinet-module">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`cabinet-module_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`cabinet_${string}`>>]>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodString>>;
     cabinetType: z.ZodDefault<z.ZodEnum<{
         base: "base";
         tall: "tall";
@@ -529,6 +544,13 @@ export declare const CabinetModuleNode: z.ZodObject<{
         left: "left";
     }>>;
     cornerShelf: z.ZodOptional<z.ZodBoolean>;
+    topFinish: z.ZodDefault<z.ZodEnum<{
+        trim: "trim";
+        none: "none";
+        "top-cabinet": "top-cabinet";
+    }>>;
+    topFinishHeight: z.ZodDefault<z.ZodNumber>;
+    topFinishDepth: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type CabinetNode = z.infer<typeof CabinetNode>;
 export type CabinetModuleNode = z.infer<typeof CabinetModuleNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"cabinet.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/cabinet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgBvB,eAAO,MAAM,uBAAuB;;;;EAA4C,CAAA;AAMhF,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAmDtB,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAqCzE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiB0B,CAAA;AAElD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB+B,CAAA;AAE7D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"cabinet.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/cabinet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgBvB,eAAO,MAAM,uBAAuB;;;;EAA4C,CAAA;AAChF,eAAO,MAAM,sBAAsB;;;;EAA0C,CAAA;AAE7E,iFAAiF;AACjF,eAAO,MAAM,uBAAuB;;;;;CAK1B,CAAA;AAMV,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAmDtB,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AA2CzE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB0B,CAAA;AAElD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB+B,CAAA;AAE7D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/schema/nodes/cabinet.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
 const compartmentBase = {
     id: z.string(),
     height: z.number().positive().max(2.5).optional(),
@@ -12,6 +12,14 @@ const cooktopFields = {
     cooktopShowGrate: z.boolean().optional(),
 };
 export const CabinetFrontStyleSchema = z.enum(['slab', 'shaker', 'raised-arch']);
+export const CabinetTopFinishSchema = z.enum(['none', 'top-cabinet', 'trim']);
+/** Canonical metric cabinet family used when no regional profile is selected. */
+export const CABINET_METRIC_DEFAULTS = {
+    depth: 0.6,
+    carcassHeight: 0.8,
+    plinthHeight: 0.1,
+    countertopThickness: 0.02,
+};
 // Discriminated on `type` so invalid field combinations (a drawer with a
 // pantry rack style, a fridge with burner state) are unrepresentable. New
 // compartment kinds add a variant here rather than widening a shared bag of
@@ -76,13 +84,17 @@ const cabinetBoxFields = {
     // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
     supportSlabId: z.string().optional(),
     width: z.number().min(0.05).max(3).default(0.5),
-    depth: z.number().min(0.3).max(1.2).default(0.5),
-    carcassHeight: z.number().min(0.4).max(2.4).default(0.72),
+    depth: z.number().min(0.3).max(1.2).default(CABINET_METRIC_DEFAULTS.depth),
+    carcassHeight: z.number().min(0.4).max(2.4).default(CABINET_METRIC_DEFAULTS.carcassHeight),
     operationState: z.number().min(0).max(1).default(0),
-    plinthHeight: z.number().min(0).max(0.3).default(0.1),
+    plinthHeight: z.number().min(0).max(0.3).default(CABINET_METRIC_DEFAULTS.plinthHeight),
     toeKickDepth: z.number().min(0).max(0.2).default(0.075),
     boardThickness: z.number().min(0.01).max(0.08).default(0.018),
-    countertopThickness: z.number().min(0).max(0.08).default(0.02),
+    countertopThickness: z
+        .number()
+        .min(0)
+        .max(0.08)
+        .default(CABINET_METRIC_DEFAULTS.countertopThickness),
     countertopOverhang: z.number().min(0).max(0.12).default(0.02),
     // Extra slab reach off the back edge (island seating side) — up to a
     // 45 cm knee-space overhang, unlike the small uniform front/side overhang.
@@ -91,6 +103,8 @@ const cabinetBoxFields = {
     frontThickness: z.number().min(0.01).max(0.05).default(0.018),
     frontGap: z.number().min(0.001).max(0.02).default(0.003),
     frontStyle: CabinetFrontStyleSchema.default('slab'),
+    // Fridge-only: replace the appliance door face with a cabinet-matched panel.
+    panelReady: z.boolean().default(false),
     handleStyle: z.enum(['none', 'bar', 'cutout', 'hole', 'knob']).default('bar'),
     handlePosition: z.enum(['auto', 'top', 'center']).default('auto'),
     frontOverlay: z.enum(['full', 'inset']).default('full'),
@@ -106,7 +120,7 @@ export const CabinetNode = BaseNode.extend({
     id: objectId('cabinet'),
     type: nodeType('cabinet'),
     runTier: z.enum(['base', 'wall', 'tall']).default('base'),
-    children: z.array(objectId('cabinet-module')).default([]),
+    children: z.array(z.string()).default([]),
     // Raised bar counter along one run edge: a knee wall topped by a slab at
     // bar height. Run-level because it spans modules like the countertop.
     barLedge: z
@@ -118,12 +132,14 @@ export const CabinetNode = BaseNode.extend({
         .optional(),
     // Countertop material dropping to the floor on exposed run ends.
     withWaterfall: z.boolean().default(false),
+    // Add matching decorative panels to ends that are not joined to another run.
+    withFinishedEnds: z.boolean().default(false),
     ...cabinetBoxFields,
 }).describe('Parametric modular cabinet run node');
 export const CabinetModuleNode = BaseNode.extend({
     id: objectId('cabinet-module'),
     type: nodeType('cabinet-module'),
-    children: z.array(z.union([objectId('cabinet-module'), objectId('cabinet')])).default([]),
+    children: z.array(z.string()).default([]),
     cabinetType: z.enum(['base', 'tall']).default('base'),
     // Discriminator for specialty units (corner L-shape, sink base, appliance
     // gap, open shelving). 'standard' modules use the compartment stack as-is;
@@ -135,5 +151,10 @@ export const CabinetModuleNode = BaseNode.extend({
     // Corner-pocket fillers carry a small internal shelf so the dead corner reads
     // as reachable storage instead of an empty boxed void.
     cornerShelf: z.boolean().optional(),
+    // Optional upper termination for wall/tall compositions. It is deliberately
+    // separate from carcassHeight so the main cabinet proportions stay stable.
+    topFinish: CabinetTopFinishSchema.default('none'),
+    topFinishHeight: z.number().min(0).max(1.2).default(0.33),
+    topFinishDepth: z.number().min(0.15).max(1.2).default(0.32),
     ...cabinetBoxFields,
 }).describe('Parametric module inside a modular cabinet run');

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

@@ -14,10 +14,10 @@ export declare const CeilingNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"ceiling">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`procedural-item_${string}`>>]>>>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{

package/dist/schema/nodes/ceiling.js

@@ -1,13 +1,13 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
-import { ItemNode } from './item';
-import { SurfaceHoleMetadata } from './surface-hole-metadata';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+import { ItemNode } from './item.js';
+import { SurfaceHoleMetadata } from './surface-hole-metadata.js';
 export const CeilingNode = BaseNode.extend({
     id: objectId('ceiling'),
     type: nodeType('ceiling'),
-    children: z.array(ItemNode.shape.id).default([]),
+    children: z.array(z.union([ItemNode.shape.id, objectId('procedural-item')])).default([]),
     material: MaterialSchema.optional(),
     materialPreset: z.string().optional(),
     // Per-slot material overrides on the unified slot model, mirroring

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const ChimneyMaterialRole: z.ZodEnum<{
-    top: "top";
     body: "body";
+    top: "top";
 }>;
 export type ChimneyMaterialRole = z.infer<typeof ChimneyMaterialRole>;
 export declare const ChimneyNode: z.ZodObject<{
@@ -19,7 +19,7 @@ export declare const ChimneyNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`chimney_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"chimney">>;
     material: z.ZodOptional<z.ZodObject<{

package/dist/schema/nodes/chimney.js

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
 export const ChimneyMaterialRole = z.enum(['body', 'top']);
 export const ChimneyNode = BaseNode.extend({
     id: objectId('chimney'),

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

@@ -58,14 +58,14 @@ export declare const ColumnCapitalStyle: z.ZodEnum<{
     "wood-bracket": "wood-bracket";
 }>;
 export declare const ColumnRingPlacement: z.ZodEnum<{
+    top: "top";
     ends: "ends";
     even: "even";
-    top: "top";
     bottom: "bottom";
 }>;
 export declare const ColumnCarvingPlacement: z.ZodEnum<{
-    shaft: "shaft";
     base: "base";
+    shaft: "shaft";
     capital: "capital";
     all: "all";
 }>;
@@ -107,9 +107,10 @@ export declare const ColumnNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"column">>;
+    children: z.ZodDefault<z.ZodArray<z.ZodString>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     supportSlabId: z.ZodOptional<z.ZodString>;
@@ -206,9 +207,9 @@ export declare const ColumnNode: z.ZodObject<{
     capitalCarvingLevel: z.ZodDefault<z.ZodNumber>;
     ringCount: z.ZodDefault<z.ZodNumber>;
     ringPlacement: z.ZodDefault<z.ZodEnum<{
+        top: "top";
         ends: "ends";
         even: "even";
-        top: "top";
         bottom: "bottom";
     }>>;
     ringThickness: z.ZodDefault<z.ZodNumber>;
@@ -227,15 +228,15 @@ export declare const ColumnNode: z.ZodObject<{
     }>>;
     latheRingCount: z.ZodDefault<z.ZodNumber>;
     latheRingSpacing: z.ZodDefault<z.ZodEnum<{
+        top: "top";
         ends: "ends";
         even: "even";
-        top: "top";
         bottom: "bottom";
     }>>;
     carvingLevel: z.ZodDefault<z.ZodNumber>;
     carvingPlacement: z.ZodDefault<z.ZodEnum<{
-        shaft: "shaft";
         base: "base";
+        shaft: "shaft";
         capital: "capital";
         all: "all";
     }>>;

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

@@ -1 +1 @@
-{"version":3,"file":"column.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/column.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"column.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/column.ts"],"names":[],"mappings":"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"}