@pascal-app/core 1.0.0 → 1.0.3

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";

package/dist/schema/nodes/stair.js

@@ -1,8 +1,8 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
-import { StairSegmentNode } from './stair-segment';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+import { StairSegmentNode } from './stair-segment.js';
 export const StairRailingMode = z.enum(['none', 'left', 'right', 'both']);
 export const StairType = z.enum(['straight', 'curved', 'spiral']);
 export const StairTopLandingMode = z.enum(['none', 'integrated']);

package/dist/schema/nodes/structural-grid.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';
 export const StructuralGridNode = BaseNode.extend({
     id: objectId('structural-grid'),
     type: nodeType('structural-grid'),

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

@@ -66,8 +66,8 @@ export declare const TurbineVentNode: z.ZodObject<{
     vaneCount: z.ZodDefault<z.ZodNumber>;
     spinSpeed: z.ZodDefault<z.ZodNumber>;
     style: z.ZodDefault<z.ZodEnum<{
-        globe: "globe";
         cylinder: "cylinder";
+        globe: "globe";
     }>>;
 }, z.core.$strip>;
 export type TurbineVentNode = z.infer<typeof TurbineVentNode>;

package/dist/schema/nodes/turbine-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 TurbineVentMaterialRole = z.enum(['base', 'head']);
 export const TurbineVentNode = BaseNode.extend({
     id: objectId('tvent'),

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const UNIT_KINDS: readonly ["apartment", "hotel-room", "commercial", "common"];
+export type UnitKind = (typeof UNIT_KINDS)[number];
+export declare const DEFAULT_UNIT_COLOR = "#f59e0b";
+export declare const UnitNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    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>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`unit_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"unit">>;
+    name: z.ZodDefault<z.ZodString>;
+    kind: z.ZodDefault<z.ZodEnum<{
+        apartment: "apartment";
+        "hotel-room": "hotel-room";
+        commercial: "commercial";
+        common: "common";
+    }>>;
+    members: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>>>;
+    color: z.ZodDefault<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export type UnitNode = z.infer<typeof UnitNode>;
+//# sourceMappingURL=unit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unit.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/unit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,UAAU,8DAA+D,CAAA;AACtF,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAClD,eAAO,MAAM,kBAAkB,YAAY,CAAA;AAE3C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/unit.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base.js';
+export const UNIT_KINDS = ['apartment', 'hotel-room', 'commercial', 'common'];
+export const DEFAULT_UNIT_COLOR = '#f59e0b';
+export const UnitNode = BaseNode.extend({
+    id: objectId('unit'),
+    type: nodeType('unit'),
+    name: z.string().default('Unit'),
+    kind: z.enum(UNIT_KINDS).default('apartment'),
+    members: z.array(objectId('zone')).default([]),
+    color: z.string().default(DEFAULT_UNIT_COLOR),
+    metadata: z.record(z.string(), z.unknown()).optional().default({}),
+});