@pascal-app/core 1.0.0 → 1.0.1

package/dist/schema/nodes/duct-terminal.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * Duct terminal — where the air loop meets the room: supply registers,
  * ceiling diffusers, return grilles.

package/dist/schema/nodes/elevator.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 ElevatorDoorStyle = z.enum(['center-opening', 'single-left', 'single-right']);
 export const ElevatorDoorPanelStyle = z.enum(['glass-frame', 'solid-panel', 'segmented-panel']);
 export const ElevatorShaftStyle = z.enum(['solid', 'glass']);

package/dist/schema/nodes/eyebrow-vent.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 EyebrowVentMaterialRole = z.enum(['hood', 'front']);
 export const EyebrowVentNode = BaseNode.extend({
     id: objectId('eyebrow-vent'),

package/dist/schema/nodes/fence.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 FenceStyle = z.enum(['slat', 'rail', 'privacy', 'horizontal']);
 export const FenceBaseStyle = z.enum(['floating', 'grounded']);
 export const FencePostCap = z.enum(['none', 'flat', 'pyramid']);

package/dist/schema/nodes/guide.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { AssetUrl } from '../asset-url';
-import { BaseNode, nodeType, objectId } from '../base';
+import { AssetUrl } from '../asset-url.js';
+import { BaseNode, nodeType, objectId } from '../base.js';
 export const GuideScaleReference = z.object({
     start: z.tuple([z.number(), z.number()]),
     end: z.tuple([z.number(), z.number()]),

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { type RoofSegmentNode } from './roof-segment';
+import { type RoofSegmentNode } from './roof-segment.js';
 export declare const GUTTER_EAVE_TUCK_INWARD = 0.04;
 export declare const GUTTER_EAVE_TUCK_UP = 0.04;
 export type GutterEaveSide = '+X' | '-X' | '+Z' | '-Z';

package/dist/schema/nodes/gutter.js

@@ -1,9 +1,9 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
-import { normalizeRoofSegmentTrim } from './roof-segment';
-import { getRoofShapeEaveSides } from './roof-segment-shape';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+import { normalizeRoofSegmentTrim } from './roof-segment.js';
+import { getRoofShapeEaveSides } from './roof-segment-shape.js';
 const MIN_DEFAULT_GUTTER_LENGTH_M = 0.2;
 const DEFAULT_GUTTER_GENERATOR = 'default-gutter';
 const AUTO_GUTTER_METADATA_KEY = 'autoGutter';

package/dist/schema/nodes/hvac-equipment.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * HVAC equipment — the boxes duct systems start and end at: furnace,
  * air handler, outdoor condenser.

package/dist/schema/nodes/imported-mesh.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const ImportedMeshPrimitive: z.ZodObject<{
+    positions: z.ZodArray<z.ZodNumber>;
+    normals: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    indices: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    color: z.ZodDefault<z.ZodString>;
+    opacity: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ImportedMeshPrimitive = z.infer<typeof ImportedMeshPrimitive>;
+/** Triangle geometry retained when an import has no native Pascal shape. */
+export declare const ImportedMeshNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<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";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`imesh_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"imported-mesh">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    primitives: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        positions: z.ZodArray<z.ZodNumber>;
+        normals: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        indices: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        color: z.ZodDefault<z.ZodString>;
+        opacity: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ImportedMeshNode = z.infer<typeof ImportedMeshNode>;
+//# sourceMappingURL=imported-mesh.d.ts.map

package/dist/schema/nodes/imported-mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imported-mesh.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/imported-mesh.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,qBAAqB;;;;;;iBAMhC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/schema/nodes/imported-mesh.js

@@ -0,0 +1,27 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base.js';
+const finiteNumber = z.number().finite();
+const vector3Array = z
+    .array(finiteNumber)
+    .refine((values) => values.length % 3 === 0, 'Expected XYZ triples');
+export const ImportedMeshPrimitive = z.object({
+    positions: vector3Array,
+    normals: vector3Array.optional(),
+    indices: z.array(z.number().int().nonnegative()).default([]),
+    color: z.string().default('#94a3b8'),
+    opacity: z.number().min(0).max(1).default(1),
+});
+/** Triangle geometry retained when an import has no native Pascal shape. */
+export const ImportedMeshNode = BaseNode.extend({
+    id: objectId('imesh'),
+    type: nodeType('imported-mesh'),
+    position: z.tuple([finiteNumber, finiteNumber, finiteNumber]).default([0, 0, 0]),
+    rotation: z.tuple([finiteNumber, finiteNumber, finiteNumber]).default([0, 0, 0]),
+    primitives: z.array(ImportedMeshPrimitive).default([]),
+}).describe(dedent `
+  Imported mesh node - triangle geometry preserved from an external model
+  - position / rotation: transform in the parent coordinate system
+  - primitives: indexed triangle buffers in meters with source display colors
+  - metadata: source-format identity and properties
+  `);

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

@@ -154,8 +154,8 @@ declare const assetSchema: z.ZodObject<{
     dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     attachTo: z.ZodOptional<z.ZodEnum<{
         wall: "wall";
-        "wall-side": "wall-side";
         ceiling: "ceiling";
+        "wall-side": "wall-side";
     }>>;
     recessed: z.ZodOptional<z.ZodBoolean>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -238,7 +238,7 @@ export declare const ItemNode: z.ZodObject<{
         front: "front";
         back: "back";
     }>>;
-    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodString>>;
     wallId: z.ZodOptional<z.ZodString>;
     wallT: z.ZodOptional<z.ZodNumber>;
     roofSegmentId: z.ZodOptional<z.ZodString>;
@@ -268,8 +268,8 @@ export declare const ItemNode: z.ZodObject<{
         dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         attachTo: z.ZodOptional<z.ZodEnum<{
             wall: "wall";
-            "wall-side": "wall-side";
             ceiling: "ceiling";
+            "wall-side": "wall-side";
         }>>;
         recessed: z.ZodOptional<z.ZodBoolean>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/schema/nodes/item.js

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { AssetUrl } from '../asset-url';
-import { BaseNode, nodeType, objectId } from '../base';
+import { AssetUrl } from '../asset-url.js';
+import { BaseNode, nodeType, objectId } from '../base.js';
 // --- Control descriptors ---
 const toggleControlSchema = z.object({
     kind: z.literal('toggle'),
@@ -104,7 +104,7 @@ export const ItemNode = BaseNode.extend({
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     scale: z.tuple([z.number(), z.number(), z.number()]).default([1, 1, 1]),
     side: z.enum(['front', 'back']).optional(),
-    children: z.array(objectId('item')).default([]),
+    children: z.array(z.string()).default([]),
     // Wall attachment properties (only used when asset.attachTo is "wall" or "wall-side")
     wallId: z.string().optional(),
     wallT: z.number().optional(), // 0-1 parametric position along wall

package/dist/schema/nodes/lean-to-extension.js

@@ -1,9 +1,9 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { ColumnNode } from './column';
-import { RoofNode } from './roof';
-import { SlabNode } from './slab';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { ColumnNode } from './column.js';
+import { RoofNode } from './roof.js';
+import { SlabNode } from './slab.js';
 export const LeanToConnectionMode = z.enum(['auto', 'manual']);
 export const LeanToCanopyForm = z.enum(['mono', 'gable', 'butterfly']);
 export const LeanToHostKind = z.enum(['wall', 'slab-edge', 'freestanding', 'conical-roof']);

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

@@ -19,7 +19,7 @@ export declare const LevelNode: z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`item_${string}` | `block_${string}` | `ceiling_${string}` | `column_${string}` | `wall_${string}` | `roof_${string}` | `slab_${string}` | `fence_${string}` | `construction-dimension_${string}` | `structural-grid_${string}` | `zone_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}`, string>>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`block_${string}` | `ceiling_${string}` | `item_${string}` | `procedural-item_${string}` | `column_${string}` | `construction-dimension_${string}` | `wall_${string}` | `roof_${string}` | `slab_${string}` | `fence_${string}` | `structural-grid_${string}` | `imesh_${string}` | `zone_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}`, string>>>>;
     level: z.ZodDefault<z.ZodNumber>;
     baseElevation: z.ZodDefault<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;

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

@@ -1 +1 @@
-{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA2DvB,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElE;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;iBA0BrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA+DvB,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElE;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;iBA0BrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/level.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 const LevelChildId = z.string().transform((id) => id);
 export const DEFAULT_LEVEL_BASE_ELEVATION = 0;
 export function normalizeLevelBaseElevation(value) {

package/dist/schema/nodes/lineset.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * Refrigerant lineset — the copper pipe pair that links the outdoor
  * condenser to the indoor coil (furnace / air handler) of a split system.

package/dist/schema/nodes/liquid-line.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * Standalone refrigerant liquid line — the thin bare-copper line that carries
  * warm liquid out to the indoor coil. It is the line that used to be drawn as

package/dist/schema/nodes/measurement.js

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { areMeasurementPointsCoplanar, MEASUREMENT_PLANAR_TOLERANCE, measurementNormal, } from '../../lib/measurement-geometry';
-import { BaseNode, nodeType, objectId } from '../base';
+import { areMeasurementPointsCoplanar, MEASUREMENT_PLANAR_TOLERANCE, measurementNormal, } from '../../lib/measurement-geometry.js';
+import { BaseNode, nodeType, objectId } from '../base.js';
 const FiniteCoordinate = z.number().finite();
 export const MeasurementPoint = z.tuple([FiniteCoordinate, FiniteCoordinate, FiniteCoordinate]);
 export const MeasurementFeatureParameter = z.union([z.string(), z.boolean(), FiniteCoordinate]);

package/dist/schema/nodes/pipe-fitting.d.ts

@@ -50,8 +50,8 @@ export declare const PipeFittingNode: z.ZodObject<{
         inline: "inline";
     }>>;
     pipeMaterial: z.ZodDefault<z.ZodEnum<{
-        pvc: "pvc";
         abs: "abs";
+        pvc: "pvc";
         "cast-iron": "cast-iron";
     }>>;
     system: z.ZodDefault<z.ZodEnum<{

package/dist/schema/nodes/pipe-fitting.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * DWV pipe fitting — the joints drain systems are actually built from:
  * elbows (bends), wyes (45° branch entries, the code-preferred way to

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

@@ -56,8 +56,8 @@ export declare const PipeSegmentNode: z.ZodObject<{
     }, z.core.$strip>>;
     diameter: z.ZodDefault<z.ZodNumber>;
     pipeMaterial: z.ZodDefault<z.ZodEnum<{
-        pvc: "pvc";
         abs: "abs";
+        pvc: "pvc";
         "cast-iron": "cast-iron";
     }>>;
     system: z.ZodDefault<z.ZodEnum<{

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

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { HangerOverrides } from './hanger-overrides';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { HangerOverrides } from './hanger-overrides.js';
 /**
  * DWV pipe segment — drain / waste / vent runs in US residential
  * plumbing. Phase 2 of the distribution-system effort: the plumbing

package/dist/schema/nodes/pipe-trap.d.ts

@@ -32,8 +32,8 @@ export declare const PipeTrapNode: z.ZodObject<{
     rotation: z.ZodDefault<z.ZodNumber>;
     diameter: z.ZodDefault<z.ZodNumber>;
     pipeMaterial: z.ZodDefault<z.ZodEnum<{
-        pvc: "pvc";
         abs: "abs";
+        pvc: "pvc";
         "cast-iron": "cast-iron";
     }>>;
     armLengthM: z.ZodDefault<z.ZodNumber>;

package/dist/schema/nodes/pipe-trap.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * DWV trap — the P-trap between a fixture and the waste system. Holds a
  * water seal that blocks sewer gas; every drained fixture has exactly

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { type RoofSegmentNode } from './roof-segment';
+import { type RoofSegmentNode } from './roof-segment.js';
 export type RidgeVentLine = {
     name: string;
     start: [number, number];

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

@@ -1,8 +1,8 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
-import { getDutchRoofMetrics, getRoofSegmentVisibleTopBounds, ROOF_SHAPE_DEFAULTS, } from './roof-segment';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+import { getDutchRoofMetrics, getRoofSegmentVisibleTopBounds, ROOF_SHAPE_DEFAULTS, } from './roof-segment.js';
 const MIN_DEFAULT_RIDGE_VENT_LENGTH_M = 0.4;
 const DEFAULT_RIDGE_VENT_GENERATOR = 'default-ridge-vent';
 const AUTO_RIDGE_VENT_METADATA_KEY = 'autoRidgeVent';

package/dist/schema/nodes/roof-segment-shape.d.ts

@@ -1,4 +1,4 @@
-import { type RoofType } from './roof-segment';
+import { type RoofType } from './roof-segment.js';
 export type RoofShapeFaceVertex = {
     x: number;
     y: number;

package/dist/schema/nodes/roof-segment-shape.js

@@ -1,4 +1,4 @@
-import { ROOF_SHAPE_DEFAULTS } from './roof-segment';
+import { ROOF_SHAPE_DEFAULTS } from './roof-segment.js';
 export function getRoofShapeEaveSides(type) {
     switch (type) {
         case 'conical':

package/dist/schema/nodes/roof-segment-walls.d.ts

@@ -1,4 +1,4 @@
-import type { RoofSegmentNode } from './roof-segment';
+import type { RoofSegmentNode } from './roof-segment.js';
 /**
  * Wall-face math for roof segments — the vertical surfaces a wall-mounted
  * opening (door / window) can attach to. A segment's generated volume has

package/dist/schema/nodes/roof-segment-walls.js

@@ -1,4 +1,4 @@
-import { getDutchRoofMetrics, getSegmentSlopeFrame } from './roof-segment';
+import { getDutchRoofMetrics, getSegmentSlopeFrame } from './roof-segment.js';
 function getWallVolumeFrame(node) {
     const { activeRh, tanTheta } = getSegmentSlopeFrame(node);
     const wallThickness = node.wallThickness ?? 0.1;

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { MaterialSchema as MaterialSchemaType } from '../material';
+import type { MaterialSchema as MaterialSchemaType } from '../material.js';
 export declare const RoofType: z.ZodEnum<{
     flat: "flat";
     hip: "hip";
@@ -269,9 +269,9 @@ export declare const RoofSegmentNode: z.ZodObject<{
     shedJointScopeId: z.ZodOptional<z.ZodString>;
     managedByParent: z.ZodDefault<z.ZodBoolean>;
     wallShell: z.ZodDefault<z.ZodEnum<{
+        omit: "omit";
         auto: "auto";
         include: "include";
-        omit: "omit";
     }>>;
     shedInsetEndPanels: z.ZodDefault<z.ZodBoolean>;
     gambrelLowerWidthRatio: z.ZodDefault<z.ZodNumber>;

package/dist/schema/nodes/roof-segment.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 RoofType = z.enum([
     'hip',
     'gable',

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { MaterialSchema as MaterialSchemaType } from '../material';
+import type { MaterialSchema as MaterialSchemaType } from '../material.js';
 export type RoofSurfaceMaterialRole = 'top' | 'edge' | 'wall';
 export type RoofSurfaceMaterialSpec = {
     material?: MaterialSchemaType;

package/dist/schema/nodes/roof.js

@@ -1,8 +1,8 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
-import { RoofSegmentNode } from './roof-segment';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+import { RoofSegmentNode } from './roof-segment.js';
 export const RoofSupport = z
     .discriminatedUnion('kind', [
     z.object({ kind: z.literal('level') }),

package/dist/schema/nodes/scan.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { CaptureSessionLocatorSchema } from '../../capture/schema';
-import { AssetUrl } from '../asset-url';
-import { BaseNode, nodeType, objectId } from '../base';
+import { CaptureSessionLocatorSchema } from '../../capture/schema.js';
+import { AssetUrl } from '../asset-url.js';
+import { BaseNode, nodeType, objectId } from '../base.js';
 export const CaptureSessionReference = CaptureSessionLocatorSchema.extend({
     manifestUrl: AssetUrl.optional(),
 });

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

@@ -44,7 +44,7 @@ export declare const ShelfNode: z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`shelf_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"shelf">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
+    children: z.ZodDefault<z.ZodArray<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>>;
     supportSlabId: z.ZodOptional<z.ZodString>;

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

@@ -1 +1 @@
-{"version":3,"file":"shelf.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/shelf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"shelf.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/shelf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/shelf.js

@@ -1,7 +1,6 @@
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
-import { ItemNode } from './item';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
 /**
  * Parametric shelf — a configurable furniture unit with one or more
  * horizontal boards that host other items.
@@ -39,7 +38,7 @@ export const ShelfNode = BaseNode.extend({
     // not be rendered, making the commit look like "the item went
     // somewhere else"). The action's parent-update branch needs the field
     // present at parse-time so the children array is always defined.
-    children: z.array(ItemNode.shape.id).default([]),
+    children: z.array(z.string()).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]),
     // Persisted slab-support host — see ItemNode.supportSlabId for the rules.

package/dist/schema/nodes/site.js

@@ -1,8 +1,8 @@
 // lib/scenegraph/schema/nodes/site.ts
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { TerrainData } from '../terrain';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { TerrainData } from '../terrain.js';
 // 2D Polygon
 const PropertyLineData = z.object({
     type: z.literal('polygon'),

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

@@ -14,15 +14,15 @@ export declare const SkylightType: z.ZodEnum<{
 }>;
 export type SkylightType = (typeof SKYLIGHT_TYPE_ORDER)[number];
 export declare const SkylightOpeningSide: z.ZodEnum<{
+    top: "top";
     right: "right";
     left: "left";
-    top: "top";
     bottom: "bottom";
 }>;
 export type SkylightOpeningSide = z.infer<typeof SkylightOpeningSide>;
 export declare const SkylightSlideDirection: z.ZodEnum<{
-    z: "z";
     x: "x";
+    z: "z";
 }>;
 export type SkylightSlideDirection = z.infer<typeof SkylightSlideDirection>;
 export type SkylightTypePreset = {
@@ -256,17 +256,17 @@ export declare const SkylightNode: z.ZodObject<{
     lanternTopScale: z.ZodDefault<z.ZodNumber>;
     openingAngle: z.ZodDefault<z.ZodNumber>;
     openingSide: z.ZodDefault<z.ZodEnum<{
+        top: "top";
         right: "right";
         left: "left";
-        top: "top";
         bottom: "bottom";
     }>>;
     operationState: z.ZodDefault<z.ZodNumber>;
     motorHousing: z.ZodDefault<z.ZodBoolean>;
     slideFraction: z.ZodDefault<z.ZodNumber>;
     slideDirection: z.ZodDefault<z.ZodEnum<{
-        z: "z";
         x: "x";
+        z: "z";
     }>>;
     trackWidth: z.ZodDefault<z.ZodNumber>;
     motorHousingSize: z.ZodDefault<z.ZodNumber>;

package/dist/schema/nodes/skylight.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 SkylightMaterialRole = z.enum(['frame', 'glass']);
 export const SKYLIGHT_TYPE_ORDER = ['flat', 'walk-on', 'lantern', 'opening', 'sliding'];
 export const SkylightType = z.enum(SKYLIGHT_TYPE_ORDER);

package/dist/schema/nodes/slab.js

@@ -1,8 +1,8 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
-import { SurfaceHoleMetadata } from './surface-hole-metadata';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+import { SurfaceHoleMetadata } from './surface-hole-metadata.js';
 // Edit-time floor for `thickness` — a thinner slab z-fights the ceiling's
 // −0.01 underside offset. Applies to edits only; migration writes legacy
 // intervals verbatim (including degenerate zero-thickness slabs).

package/dist/schema/nodes/solar-panel.js

@@ -1,8 +1,8 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { SolarPanelPresetKey } from '../../solar-panel-presets';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { SolarPanelPresetKey } from '../../solar-panel-presets.js';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
 export const SolarPanelMaterialRole = z.enum(['frame', 'panel']);
 export const SolarPanelNode = BaseNode.extend({
     id: objectId('solarpanel'),

package/dist/schema/nodes/spawn.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 export const SpawnNode = BaseNode.extend({
     id: objectId('spawn'),
     type: nodeType('spawn'),

package/dist/schema/nodes/stair-segment.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 StairSegmentType = z.enum(['stair', 'landing']);
 export const AttachmentSide = z.enum(['front', 'left', 'right']);
 export const StairSegmentNode = BaseNode.extend({

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { MaterialSchema as MaterialSchemaType } from '../material';
+import type { MaterialSchema as MaterialSchemaType } from '../material.js';
 export declare const StairRailingMode: z.ZodEnum<{
     right: "right";
     left: "left";