@pascal-app/core 0.8.0 → 0.9.2

package/dist/schema/nodes/item.js

@@ -76,7 +76,16 @@ const assetSchema = z.object({
     src: AssetUrl,
     dimensions: z.tuple([z.number(), z.number(), z.number()]).default([1, 1, 1]), // [w, h, d]
     attachTo: z.enum(['wall', 'wall-side', 'ceiling']).optional(),
+    // Ceiling fixtures (e.g. recessed downlights) that embed *into* the ceiling
+    // rather than hang below it: the item seats flush with the ceiling plane
+    // (its body rising into the void above) and the ceiling is cut out around
+    // the item's footprint. Ignored unless `attachTo === 'ceiling'`.
+    recessed: z.boolean().optional(),
     tags: z.array(z.string()).optional(),
+    // Function-axis tag slugs from the taxonomy. Drives the hierarchical
+    // Items-tab browse: a tree node matches when any of its descendant slugs
+    // appears here. Absent for the seeded built-in catalog.
+    functionTags: z.array(z.string()).optional(),
     // These are "Corrective" transforms to normalize the GLB
     offset: 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]),
@@ -99,8 +108,19 @@ export const ItemNode = BaseNode.extend({
     // 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
+    // Alternative wall host: a roof-segment's generated wall face. When
+    // set, `position` is FACE-LOCAL — [u along the face, v = bottom edge,
+    // z from the wall mid-plane] — exactly the wall-child convention
+    // (ItemSystem's wall-side push applies the same way); the renderer
+    // mounts the node inside the face frame (`getRoofWallFaceFrame`).
+    roofSegmentId: z.string().optional(),
+    roofFace: z.enum(['front', 'back', 'right', 'left']).optional(),
     // Denormalized references to collections this node belongs to
     collectionIds: z.array(z.custom()).optional(),
+    // Per-slot material overrides. Key = slot id (see deriveSlotId), value = a
+    // MaterialRef string ('library:<id>' or 'scene:<id>'). Absent = authored /
+    // registry default. A dangling ref renders the default (never blocks).
+    slots: z.record(z.string(), z.string()).optional(),
     asset: assetSchema,
 }).describe(dedent `Item node - used to represent a item in the building
   - position: position in level coordinate system (or parent coordinate system if attached)

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

@@ -17,7 +17,7 @@ export declare const LevelNode: z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`spawn_${string}`>>]>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`measurement_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`spawn_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`shelf_${string}`>>]>>>;
     level: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type LevelNode = z.infer<typeof LevelNode>;

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;AAevB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;iBA6BrB,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;AAiBvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;iBA+BrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/level.js

@@ -6,8 +6,10 @@ import { ColumnNode } from './column';
 import { FenceNode } from './fence';
 import { GuideNode } from './guide';
 import { ItemNode } from './item';
+import { MeasurementNode } from './measurement';
 import { RoofNode } from './roof';
 import { ScanNode } from './scan';
+import { ShelfNode } from './shelf';
 import { SlabNode } from './slab';
 import { SpawnNode } from './spawn';
 import { StairNode } from './stair';
@@ -29,7 +31,9 @@ export const LevelNode = BaseNode.extend({
         StairNode.shape.id,
         ScanNode.shape.id,
         GuideNode.shape.id,
+        MeasurementNode.shape.id,
         SpawnNode.shape.id,
+        ShelfNode.shape.id,
     ]))
         .default([]),
     // Specific props

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+/**
+ * Refrigerant lineset — the copper pipe pair that links the outdoor
+ * condenser to the indoor coil (furnace / air handler) of a split system.
+ * It is the refrigerant-side analogue of a duct run: a polyline of points,
+ * but carrying two lines instead of one airway.
+ *
+ * Real linesets run a fat insulated SUCTION line (cool vapour back to the
+ * compressor) beside a thin bare LIQUID line (warm liquid out to the coil).
+ * The geometry builder draws a single copper line on the path centerline
+ * (sized to `suctionDiameter`, wrapped in a foam jacket when `insulated`);
+ * draw the liquid line as a second lineset rather than both off one path.
+ *
+ * Path coordinates are level-local meters: [x, y, z] tuples, same space as
+ * duct paths and grid events. Diameters are nominal copper OD in inches.
+ */
+export declare const LinesetNode: 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.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`lineset_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"lineset">>;
+    path: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    suctionDiameter: z.ZodDefault<z.ZodNumber>;
+    liquidDiameter: z.ZodDefault<z.ZodNumber>;
+    insulated: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type LinesetNode = z.infer<typeof LinesetNode>;
+export type LinesetNodeId = LinesetNode['id'];
+//# sourceMappingURL=lineset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lineset.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/lineset.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;iBAqBvB,CAAA;AACD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACrD,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/nodes/lineset.js

@@ -0,0 +1,38 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+/**
+ * Refrigerant lineset — the copper pipe pair that links the outdoor
+ * condenser to the indoor coil (furnace / air handler) of a split system.
+ * It is the refrigerant-side analogue of a duct run: a polyline of points,
+ * but carrying two lines instead of one airway.
+ *
+ * Real linesets run a fat insulated SUCTION line (cool vapour back to the
+ * compressor) beside a thin bare LIQUID line (warm liquid out to the coil).
+ * The geometry builder draws a single copper line on the path centerline
+ * (sized to `suctionDiameter`, wrapped in a foam jacket when `insulated`);
+ * draw the liquid line as a second lineset rather than both off one path.
+ *
+ * Path coordinates are level-local meters: [x, y, z] tuples, same space as
+ * duct paths and grid events. Diameters are nominal copper OD in inches.
+ */
+export const LinesetNode = BaseNode.extend({
+    id: objectId('lineset'),
+    type: nodeType('lineset'),
+    // Polyline path in level-local meters. Minimum two points (start, end).
+    path: z.array(z.tuple([z.number(), z.number(), z.number()])).min(2),
+    // Nominal suction-line copper OD in inches (the large insulated line).
+    // Common residential sizes are 3/4"–1-1/8".
+    suctionDiameter: z.number().min(0.25).max(2).default(0.875),
+    // Nominal liquid-line copper OD in inches (the small bare line).
+    // Common residential sizes are 1/4"–3/8".
+    liquidDiameter: z.number().min(0.125).max(1).default(0.375),
+    // Whether the suction line carries its foam insulation jacket. Bare = false.
+    insulated: z.boolean().default(true),
+}).describe(dedent `
+  Refrigerant lineset - copper suction + liquid pair linking a condenser to an indoor coil.
+  - path: list of [x, y, z] points in level-local meters (min 2)
+  - suctionDiameter: nominal copper OD in inches of the large insulated line (typ. 3/4"-1-1/8")
+  - liquidDiameter: nominal copper OD in inches of the small bare line (typ. 1/4"-3/8")
+  - insulated: whether the suction line wears its foam jacket
+  `);

package/dist/schema/nodes/liquid-line.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+/**
+ * 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
+ * the lineset's second rail; broken out here as its own polyline run so it can
+ * be drawn on its own, including traced alongside an existing lineset.
+ *
+ * Path coordinates are level-local meters: [x, y, z] tuples, the same space as
+ * lineset and duct paths. Diameter is nominal copper OD in inches.
+ */
+export declare const LiquidLineNode: 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.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`liquid-line_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"liquid-line">>;
+    path: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    diameter: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type LiquidLineNode = z.infer<typeof LiquidLineNode>;
+export type LiquidLineNodeId = LiquidLineNode['id'];
+//# sourceMappingURL=liquid-line.d.ts.map

package/dist/schema/nodes/liquid-line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liquid-line.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/liquid-line.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;iBAa1B,CAAA;AACD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAC3D,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC,IAAI,CAAC,CAAA"}

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

@@ -0,0 +1,24 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+/**
+ * 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
+ * the lineset's second rail; broken out here as its own polyline run so it can
+ * be drawn on its own, including traced alongside an existing lineset.
+ *
+ * Path coordinates are level-local meters: [x, y, z] tuples, the same space as
+ * lineset and duct paths. Diameter is nominal copper OD in inches.
+ */
+export const LiquidLineNode = BaseNode.extend({
+    id: objectId('liquid-line'),
+    type: nodeType('liquid-line'),
+    // Polyline path in level-local meters. Minimum two points (start, end).
+    path: z.array(z.tuple([z.number(), z.number(), z.number()])).min(2),
+    // Nominal copper OD in inches. Common residential sizes are 1/4"–3/8".
+    diameter: z.number().min(0.125).max(1).default(0.375),
+}).describe(dedent `
+  Standalone refrigerant liquid line - a thin bare-copper polyline run.
+  - path: list of [x, y, z] points in level-local meters (min 2)
+  - diameter: nominal copper OD in inches (typ. 1/4"-3/8")
+  `);

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

@@ -0,0 +1,306 @@
+import { z } from 'zod';
+export declare const MeasurementPoint: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+export declare const MeasurementFeatureParameter: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>;
+export declare const MeasurementFeatureReference: z.ZodObject<{
+    nodeId: z.ZodString;
+    featureId: z.ZodString;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+}, z.core.$strip>;
+export declare const MeasurementFeatureAnchor: z.ZodObject<{
+    kind: z.ZodLiteral<"feature">;
+    reference: z.ZodObject<{
+        nodeId: z.ZodString;
+        featureId: z.ZodString;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+    }, z.core.$strip>;
+    fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+}, z.core.$strip>;
+/** A tuple is a free anchor and remains the compact legacy representation. */
+export declare const MeasurementAnchor: z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+    kind: z.ZodLiteral<"feature">;
+    reference: z.ZodObject<{
+        nodeId: z.ZodString;
+        featureId: z.ZodString;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+    }, z.core.$strip>;
+    fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+}, z.core.$strip>]>;
+export declare const DistanceMeasurement: z.ZodObject<{
+    kind: z.ZodLiteral<"distance">;
+    points: z.ZodTuple<[z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>], null>;
+}, z.core.$strip>;
+export declare const AngleMeasurement: z.ZodObject<{
+    kind: z.ZodLiteral<"angle">;
+    points: z.ZodTuple<[z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>], null>;
+}, z.core.$strip>;
+export declare const AreaMeasurement: z.ZodObject<{
+    kind: z.ZodLiteral<"area">;
+    base: z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+export declare const PerimeterMeasurement: z.ZodObject<{
+    kind: z.ZodLiteral<"perimeter">;
+    base: z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+export declare const VolumeMeasurement: z.ZodObject<{
+    kind: z.ZodLiteral<"volume">;
+    base: z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>>;
+    extrusion: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+}, z.core.$strip>;
+export declare const MeasurementPayload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"distance">;
+    points: z.ZodTuple<[z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"angle">;
+    points: z.ZodTuple<[z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"area">;
+    base: z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"perimeter">;
+    base: z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"volume">;
+    base: z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>>;
+    extrusion: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+}, z.core.$strip>], "kind">;
+export declare const MeasurementNode: 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.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`measurement_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"measurement">>;
+    measurement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"distance">;
+        points: z.ZodTuple<[z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            kind: z.ZodLiteral<"feature">;
+            reference: z.ZodObject<{
+                nodeId: z.ZodString;
+                featureId: z.ZodString;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+            }, z.core.$strip>;
+            fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            kind: z.ZodLiteral<"feature">;
+            reference: z.ZodObject<{
+                nodeId: z.ZodString;
+                featureId: z.ZodString;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+            }, z.core.$strip>;
+            fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>]>], null>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"angle">;
+        points: z.ZodTuple<[z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            kind: z.ZodLiteral<"feature">;
+            reference: z.ZodObject<{
+                nodeId: z.ZodString;
+                featureId: z.ZodString;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+            }, z.core.$strip>;
+            fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            kind: z.ZodLiteral<"feature">;
+            reference: z.ZodObject<{
+                nodeId: z.ZodString;
+                featureId: z.ZodString;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+            }, z.core.$strip>;
+            fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            kind: z.ZodLiteral<"feature">;
+            reference: z.ZodObject<{
+                nodeId: z.ZodString;
+                featureId: z.ZodString;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+            }, z.core.$strip>;
+            fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>]>], null>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"area">;
+        base: z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            kind: z.ZodLiteral<"feature">;
+            reference: z.ZodObject<{
+                nodeId: z.ZodString;
+                featureId: z.ZodString;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+            }, z.core.$strip>;
+            fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"perimeter">;
+        base: z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            kind: z.ZodLiteral<"feature">;
+            reference: z.ZodObject<{
+                nodeId: z.ZodString;
+                featureId: z.ZodString;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+            }, z.core.$strip>;
+            fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"volume">;
+        base: z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            kind: z.ZodLiteral<"feature">;
+            reference: z.ZodObject<{
+                nodeId: z.ZodString;
+                featureId: z.ZodString;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+            }, z.core.$strip>;
+            fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>]>>;
+        extrusion: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export type MeasurementPoint = z.infer<typeof MeasurementPoint>;
+export type MeasurementFeatureParameter = z.infer<typeof MeasurementFeatureParameter>;
+export type MeasurementFeatureReference = z.infer<typeof MeasurementFeatureReference>;
+export type MeasurementFeatureAnchor = z.infer<typeof MeasurementFeatureAnchor>;
+export type MeasurementAnchor = z.infer<typeof MeasurementAnchor>;
+export type DistanceMeasurement = z.infer<typeof DistanceMeasurement>;
+export type AngleMeasurement = z.infer<typeof AngleMeasurement>;
+export type AreaMeasurement = z.infer<typeof AreaMeasurement>;
+export type PerimeterMeasurement = z.infer<typeof PerimeterMeasurement>;
+export type VolumeMeasurement = z.infer<typeof VolumeMeasurement>;
+export type MeasurementPayload = z.infer<typeof MeasurementPayload>;
+export type MeasurementNode = z.infer<typeof MeasurementNode>;
+//# sourceMappingURL=measurement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/measurement.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,gBAAgB,2DAAkE,CAAA;AAE/F,eAAO,MAAM,2BAA2B,+DAAuD,CAAA;AAE/F,eAAO,MAAM,2BAA2B;;;;iBAItC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;iBAInC,CAAA;AAEF,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB;;;;;;;;mBAAwD,CAAA;AAiBtF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;iBAG9B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG3B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;iBAG1B,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;iBAG/B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;iBAsB1B,CAAA;AAEJ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAM7B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa3B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AACrF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AACrF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAC/E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAC7D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACvE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACnE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/schema/nodes/measurement.js

@@ -0,0 +1,87 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { areMeasurementPointsCoplanar, MEASUREMENT_PLANAR_TOLERANCE, measurementNormal, } from '../../lib/measurement-geometry';
+import { BaseNode, nodeType, objectId } from '../base';
+const FiniteCoordinate = z.number().finite();
+export const MeasurementPoint = z.tuple([FiniteCoordinate, FiniteCoordinate, FiniteCoordinate]);
+export const MeasurementFeatureParameter = z.union([z.string(), z.boolean(), FiniteCoordinate]);
+export const MeasurementFeatureReference = z.object({
+    nodeId: z.string().min(1),
+    featureId: z.string().min(1),
+    parameters: z.record(z.string(), MeasurementFeatureParameter).optional(),
+});
+export const MeasurementFeatureAnchor = z.object({
+    kind: z.literal('feature'),
+    reference: MeasurementFeatureReference,
+    fallback: MeasurementPoint,
+});
+/** A tuple is a free anchor and remains the compact legacy representation. */
+export const MeasurementAnchor = z.union([MeasurementPoint, MeasurementFeatureAnchor]);
+const fallbackPoint = (anchor) => Array.isArray(anchor) ? anchor : anchor.fallback;
+const PlanarMeasurementBase = z
+    .array(MeasurementAnchor)
+    .min(3)
+    .superRefine((anchors, ctx) => {
+    if (!areMeasurementPointsCoplanar(anchors.map(fallbackPoint), MEASUREMENT_PLANAR_TOLERANCE)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Measurement base must be planar and enclose an area',
+        });
+    }
+});
+export const DistanceMeasurement = z.object({
+    kind: z.literal('distance'),
+    points: z.tuple([MeasurementAnchor, MeasurementAnchor]),
+});
+export const AngleMeasurement = z.object({
+    kind: z.literal('angle'),
+    points: z.tuple([MeasurementAnchor, MeasurementAnchor, MeasurementAnchor]),
+});
+export const AreaMeasurement = z.object({
+    kind: z.literal('area'),
+    base: PlanarMeasurementBase,
+});
+export const PerimeterMeasurement = z.object({
+    kind: z.literal('perimeter'),
+    base: PlanarMeasurementBase,
+});
+export const VolumeMeasurement = z
+    .object({
+    kind: z.literal('volume'),
+    base: PlanarMeasurementBase,
+    extrusion: MeasurementPoint,
+})
+    .superRefine((measurement, ctx) => {
+    const normal = measurementNormal(measurement.base.map(fallbackPoint));
+    const normalComponent = normal
+        ? Math.abs(normal[0] * measurement.extrusion[0] +
+            normal[1] * measurement.extrusion[1] +
+            normal[2] * measurement.extrusion[2])
+        : 0;
+    if (normalComponent <= 1e-9) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['extrusion'],
+            message: 'Measurement extrusion must have a non-zero normal component',
+        });
+    }
+});
+export const MeasurementPayload = z.discriminatedUnion('kind', [
+    DistanceMeasurement,
+    AngleMeasurement,
+    AreaMeasurement,
+    PerimeterMeasurement,
+    VolumeMeasurement,
+]);
+export const MeasurementNode = BaseNode.extend({
+    id: objectId('measurement'),
+    type: nodeType('measurement'),
+    measurement: MeasurementPayload,
+}).describe(dedent `
+  Measurement node - a persistent level-local 3D measurement annotation
+  - distance: exactly two level-local anchors
+  - angle: exactly three anchors, with the middle anchor as the vertex
+  - area/perimeter: an ordered planar base with at least three anchors
+  - volume: an ordered planar base with an extrusion vector
+  - an anchor is either a free point tuple or a semantic feature reference with a fallback
+  `);

package/dist/schema/nodes/measurement.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=measurement.test.d.ts.map

package/dist/schema/nodes/measurement.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.test.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/measurement.test.ts"],"names":[],"mappings":""}