@pascal-app/core 1.0.3 → 1.0.5

package/dist/node-slots/stair.js

@@ -0,0 +1,21 @@
+export const STAIR_TREADS_SLOT_DEFAULT = 'library:wood-woodplank48';
+export const STAIR_BODY_SLOT_DEFAULT = 'library:preset-lightgrey';
+export const STAIR_RAILING_SLOT_DEFAULT = 'library:metal-steel';
+/** A flight's own treads and body, over the stair's. */
+export function stairSegmentSlots() {
+    return [
+        { slotId: 'treads', label: 'Treads', default: STAIR_TREADS_SLOT_DEFAULT },
+        { slotId: 'body', label: 'Body', default: STAIR_BODY_SLOT_DEFAULT },
+    ];
+}
+export function stairSlots(node) {
+    const slots = stairSegmentSlots();
+    if (node.railingMode && node.railingMode !== 'none') {
+        slots.push({ slotId: 'railing', label: 'Railing', default: STAIR_RAILING_SLOT_DEFAULT });
+    }
+    if (node.railingMode !== 'none' && node.railingStyle === 'glass')
+        slots.push({ slotId: 'infill', label: 'Glass infill', default: 'library:preset-glass' });
+    if (node.handrail && node.handrail.mode !== 'none' && node.railingMode === 'none')
+        slots.push({ slotId: 'railing', label: 'Handrail', default: STAIR_RAILING_SLOT_DEFAULT });
+    return slots;
+}

package/dist/node-slots/wall.d.ts

@@ -0,0 +1,12 @@
+import type { SlotDeclaration } from '../registry/types.js';
+import { type WallNode } from '../schema/nodes/wall.js';
+/**
+ * A wall exposes two paintable faces — `a` (left of start → end) and `b` —
+ * plus a skirting, crown and chair rail per face. Painting writes
+ * `node.slots[slotId]` via `wallPaint` like every other kind; this declaration
+ * surfaces the slot list + declared defaults for the picker and keeps walls on
+ * the same `{ slotId, label, default }` contract. Paint regions and room
+ * finishes are not slots: they live on `faceRegions` and on the zone.
+ */
+export declare function wallSlots(node?: WallNode): SlotDeclaration[];
+//# sourceMappingURL=wall.d.ts.map

package/dist/node-slots/wall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall.d.ts","sourceRoot":"","sources":["../../src/node-slots/wall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,OAAO,EAA8B,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAEhF;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,eAAe,EAAE,CA4C5D"}

package/dist/node-slots/wall.js

@@ -0,0 +1,55 @@
+import { getCurtainWallConfig } from '../schema/nodes/curtain-wall.js';
+import { WALL_SURFACE_SLOT_DEFAULTS } from '../schema/nodes/wall.js';
+/**
+ * A wall exposes two paintable faces — `a` (left of start → end) and `b` —
+ * plus a skirting, crown and chair rail per face. Painting writes
+ * `node.slots[slotId]` via `wallPaint` like every other kind; this declaration
+ * surfaces the slot list + declared defaults for the picker and keeps walls on
+ * the same `{ slotId, label, default }` contract. Paint regions and room
+ * finishes are not slots: they live on `faceRegions` and on the zone.
+ */
+export function wallSlots(node) {
+    if (node?.wallType === 'curtain') {
+        const config = getCurtainWallConfig(node);
+        return [
+            { slotId: 'curtain-frame', label: 'Frame', default: config.frameColor },
+            { slotId: 'curtain-glass', label: 'Glass', default: config.glassColor },
+            { slotId: 'curtain-solid', label: 'Solid panels', default: config.solidColor },
+        ];
+    }
+    return [
+        { slotId: 'a', label: 'Side A', default: WALL_SURFACE_SLOT_DEFAULTS.a },
+        { slotId: 'b', label: 'Side B', default: WALL_SURFACE_SLOT_DEFAULTS.b },
+        {
+            slotId: 'aSkirting',
+            label: 'Skirting (side A)',
+            default: WALL_SURFACE_SLOT_DEFAULTS.aSkirting,
+        },
+        {
+            slotId: 'bSkirting',
+            label: 'Skirting (side B)',
+            default: WALL_SURFACE_SLOT_DEFAULTS.bSkirting,
+        },
+        { slotId: 'aCrown', label: 'Crown (side A)', default: WALL_SURFACE_SLOT_DEFAULTS.aCrown },
+        { slotId: 'bCrown', label: 'Crown (side B)', default: WALL_SURFACE_SLOT_DEFAULTS.bCrown },
+        {
+            slotId: 'aChairRail',
+            label: 'Chair rail (side A)',
+            default: WALL_SURFACE_SLOT_DEFAULTS.aChairRail,
+        },
+        {
+            slotId: 'bChairRail',
+            label: 'Chair rail (side B)',
+            default: WALL_SURFACE_SLOT_DEFAULTS.bChairRail,
+        },
+        ...(node?.underpinning
+            ? [
+                {
+                    slotId: 'foundation',
+                    label: 'Foundation',
+                    default: WALL_SURFACE_SLOT_DEFAULTS.foundation,
+                },
+            ]
+            : []),
+    ];
+}

package/dist/node-slots/window.d.ts

@@ -0,0 +1,5 @@
+import type { SlotDeclaration } from '../registry/types.js';
+export type WindowSlotId = 'frame' | 'glass';
+/** A window exposes two paintable slots: the joinery frame and the glass. */
+export declare function windowSlots(): SlotDeclaration[];
+//# sourceMappingURL=window.d.ts.map

package/dist/node-slots/window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../src/node-slots/window.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,OAAO,CAAA;AAO5C,6EAA6E;AAC7E,wBAAgB,WAAW,IAAI,eAAe,EAAE,CAK/C"}

package/dist/node-slots/window.js

@@ -0,0 +1,11 @@
+// Picker swatches. Rendering falls back to the live frame/glass defaults (which
+// already track shading + theme), so these are just the indicator colours.
+const FRAME_DEFAULT = 'library:preset-softwhite';
+const GLASS_DEFAULT = 'library:preset-glass';
+/** A window exposes two paintable slots: the joinery frame and the glass. */
+export function windowSlots() {
+    return [
+        { slotId: 'frame', label: 'Frame', default: FRAME_DEFAULT },
+        { slotId: 'glass', label: 'Glass', default: GLASS_DEFAULT },
+    ];
+}

package/dist/procedural-items/design-placement.d.ts

@@ -0,0 +1,49 @@
+import { type DesignDiagnostic } from './design.js';
+import { ProceduralItemNode } from './node.js';
+import { type QueryNodes } from './query.js';
+import { type Vec3 } from './recipe.js';
+/**
+ * Where and how to create one design instance, in today's hosting fields:
+ * - floor designs: `hostId` is a level, or a slab or zone of it (the level becomes the parent),
+ *   or a design whose named `surfaceId` it rests on; `position` is in that frame, y up;
+ * - wall-side designs: `hostId` is a straight wall, `position` is [along, height, offset] of
+ *   the mounting reference from the wall start on `side`;
+ * - ceiling designs: `hostId` is a ceiling, `position` is the plan [x, 0, z] of the reference.
+ * `rotation` is a yaw in radians (not for wall-side designs, which face away from the wall).
+ */
+export type DesignPlacementRequest = {
+    design: unknown;
+    hostId: string;
+    position: Vec3;
+    rotation?: number;
+    side?: 'front' | 'back';
+    surfaceId?: string;
+    parameters?: Record<string, number>;
+    slots?: Record<string, string>;
+    name?: string;
+    /** A new id; refused with node_exists when the scene already has it. */
+    id?: string;
+};
+export type DesignPlacementRefusal = 'invalid_design' | 'design_too_large' | 'design_version_not_enabled' | 'node_exists' | 'invalid_placement' | 'host_not_found' | 'wrong_host' | 'unknown_surface' | 'does_not_fit';
+/** A typed refusal; the message starts with the code because some clients only show messages. */
+export declare class DesignPlacementError extends Error {
+    readonly code: DesignPlacementRefusal;
+    readonly diagnostics: DesignDiagnostic[];
+    constructor(code: DesignPlacementRefusal, detail: string, diagnostics?: DesignDiagnostic[]);
+}
+export type DesignPlacement = {
+    node: ProceduralItemNode;
+    parentId: string;
+    /** The surface host's attachment map after placement, when the design rests on a design surface. */
+    hostUpdate?: {
+        id: string;
+        attachments: Record<string, string>;
+    };
+};
+/**
+ * Plan a create-only placement of a design: validate it (the same authority as
+ * `validateDesign`), resolve its host from its mounting, build the node and run the
+ * procedural relation checks without the node registry. Throws `DesignPlacementError`.
+ */
+export declare function planDesignPlacement(nodes: QueryNodes, request: DesignPlacementRequest): DesignPlacement;
+//# sourceMappingURL=design-placement.d.ts.map

package/dist/procedural-items/design-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design-placement.d.ts","sourceRoot":"","sources":["../../src/procedural-items/design-placement.ts"],"names":[],"mappings":"AAEA,OAAO,EAAwB,KAAK,gBAAgB,EAAkB,MAAM,UAAU,CAAA;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAC3C,OAAO,EAGL,KAAK,UAAU,EAEhB,MAAM,SAAS,CAAA;AAChB,OAAO,EAA+B,KAAK,IAAI,EAAE,MAAM,UAAU,CAAA;AAGjE;;;;;;;;GAQG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IACvB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,wEAAwE;IACxE,EAAE,CAAC,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,sBAAsB,GAC9B,gBAAgB,GAChB,kBAAkB,GAClB,4BAA4B,GAC5B,aAAa,GACb,mBAAmB,GACnB,gBAAgB,GAChB,YAAY,GACZ,iBAAiB,GACjB,cAAc,CAAA;AAElB,iGAAiG;AACjG,qBAAa,oBAAqB,SAAQ,KAAK;IAE3C,QAAQ,CAAC,IAAI,EAAE,sBAAsB;IAErC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,EAAE;IAH1C,YACW,IAAI,EAAE,sBAAsB,EACrC,MAAM,EAAE,MAAM,EACL,WAAW,GAAE,gBAAgB,EAAO,EAI9C;CACF;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,kBAAkB,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,oGAAoG;IACpG,UAAU,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;CACjE,CAAA;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,sBAAsB,GAC9B,eAAe,CA+HjB"}

package/dist/procedural-items/design-placement.js

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { DESIGN_WRITE_VERSION, validateDesign } from './design.js';
+import { ProceduralItemNode } from './node.js';
+import { isProceduralItem, proceduralLocalPose, validateProceduralRelations, } from './query.js';
+import { evaluateRecipe, parseRecipe } from './recipe.js';
+import { boundsOf, boxCorners, frame, transformPoint } from './spatial.js';
+/** A typed refusal; the message starts with the code because some clients only show messages. */
+export class DesignPlacementError extends Error {
+    code;
+    diagnostics;
+    constructor(code, detail, diagnostics = []) {
+        super(`${code}: ${detail}`);
+        this.code = code;
+        this.diagnostics = diagnostics;
+        this.name = 'DesignPlacementError';
+    }
+}
+const round = (value) => Math.round(value * 1000) / 1000;
+function wallRange(node, wall, nodes) {
+    const pose = proceduralLocalPose({ ...node, position: [0, 0, 0] }, nodes);
+    const e = evaluateRecipe(node.recipe, node.parameters);
+    const b = boundsOf(boxCorners(e.min, e.max).map((p) => transformPoint(frame(pose.position, pose.rotation), p)));
+    const level = wall.parentId ? nodes[wall.parentId] : undefined;
+    const height = wall.height ?? (level?.type === 'level' ? level.height : 2.5) ?? 2.5;
+    const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    return `the reference fits along ${round(-b.min[0])}–${round(length - b.max[0])} m and at height ${round(-b.min[1])}–${round(height - b.max[1])} m on this wall`;
+}
+/**
+ * Plan a create-only placement of a design: validate it (the same authority as
+ * `validateDesign`), resolve its host from its mounting, build the node and run the
+ * procedural relation checks without the node registry. Throws `DesignPlacementError`.
+ */
+export function planDesignPlacement(nodes, request) {
+    const { hostId, position, rotation = 0, side, surfaceId, parameters = {} } = request;
+    const check = validateDesign(request.design, { parameters });
+    const tooLarge = check.diagnostics.find((d) => d.code === 'design_too_large');
+    if (tooLarge)
+        throw new DesignPlacementError('design_too_large', tooLarge.message);
+    if (!check.valid) {
+        const errors = check.diagnostics.filter((d) => d.severity === 'error');
+        throw new DesignPlacementError('invalid_design', `${errors[0]?.message ?? 'Invalid design'}${errors.length > 1 ? ` (+${errors.length - 1} more)` : ''}`, errors);
+    }
+    const recipe = parseRecipe(typeof request.design === 'string' ? JSON.parse(request.design) : request.design);
+    if (recipe.version > DESIGN_WRITE_VERSION)
+        throw new DesignPlacementError('design_version_not_enabled', `Placement accepts version ${DESIGN_WRITE_VERSION} designs only; writing version ${recipe.version} opens in the next release`);
+    if (request.id !== undefined && nodes[request.id])
+        throw new DesignPlacementError('node_exists', `create id "${request.id}" already exists; omit id to create a new node`);
+    let host = nodes[hostId];
+    if (!host)
+        throw new DesignPlacementError('host_not_found', `No node ${hostId}`);
+    const mounting = recipe.mounting?.attachTo ?? 'floor';
+    const expected = {
+        ceiling: 'a ceiling',
+        'wall-side': 'a straight wall',
+        floor: 'a level, slab, zone or design surface',
+    }[mounting];
+    if (mounting === 'floor' && (host.type === 'slab' || host.type === 'zone')) {
+        const level = host.parentId ? nodes[host.parentId] : undefined;
+        if (level?.type !== 'level')
+            throw new DesignPlacementError('wrong_host', `${hostId} is not on a level`);
+        host = level;
+    }
+    const hostKind = mounting === 'ceiling' ? 'ceiling' : mounting === 'wall-side' ? 'wall' : null;
+    const surfaceHost = mounting === 'floor' && isProceduralItem(host) ? host : undefined;
+    const onSurface = surfaceHost !== undefined;
+    if (hostKind ? host.type !== hostKind : !(host.type === 'level' || onSurface))
+        throw new DesignPlacementError('wrong_host', `This ${mounting} design needs ${expected}, not a ${host.type}`);
+    if (surfaceId !== undefined && !onSurface)
+        throw new DesignPlacementError('invalid_placement', 'surfaceId only applies to a design host');
+    if (side !== undefined && mounting !== 'wall-side')
+        throw new DesignPlacementError('invalid_placement', 'side only applies to wall-side designs');
+    if (mounting === 'wall-side' && rotation !== 0)
+        throw new DesignPlacementError('invalid_placement', 'Wall-side designs face away from the wall; use side instead of rotation');
+    if ((mounting === 'ceiling' || onSurface) && position[1] !== 0)
+        throw new DesignPlacementError('invalid_placement', `${onSurface ? 'Designs rest on a surface' : 'Ceiling designs hang flush'}: position[1] must be 0`);
+    if (surfaceHost) {
+        if (surfaceId === undefined)
+            throw new DesignPlacementError('invalid_placement', 'Pass the surfaceId of the design surface to rest on');
+        const surfaces = evaluateRecipe(surfaceHost.recipe, surfaceHost.parameters).surfaces.map((s) => s.id);
+        if (!surfaces.includes(surfaceId))
+            throw new DesignPlacementError('unknown_surface', `${hostId} has no surface ${surfaceId}; it has ${surfaces.join(', ') || 'none'}`);
+    }
+    let node;
+    try {
+        node = ProceduralItemNode.parse({
+            ...(request.id !== undefined ? { id: request.id } : {}),
+            recipe,
+            name: request.name ?? recipe.name,
+            parameters,
+            slots: request.slots ?? {},
+            parentId: host.id,
+            position,
+            rotation: [0, rotation, 0],
+            ...(mounting === 'wall-side' ? { wallId: host.id, side: side ?? 'front' } : {}),
+        });
+    }
+    catch (error) {
+        throw new DesignPlacementError('invalid_placement', error instanceof z.ZodError
+            ? error.issues.map((i) => `${i.path.join('.') || 'node'}: ${i.message}`).join('; ')
+            : String(error));
+    }
+    const hostNext = surfaceHost
+        ? {
+            ...surfaceHost,
+            children: [...surfaceHost.children, node.id],
+            attachments: { ...surfaceHost.attachments, [node.id]: surfaceId },
+        }
+        : undefined;
+    const next = {
+        ...nodes,
+        [node.id]: node,
+        ...(hostNext && { [hostNext.id]: hostNext }),
+    };
+    try {
+        validateProceduralRelations(node, next);
+        if (hostNext)
+            validateProceduralRelations(hostNext, next);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        const hint = host.type === 'wall' && !host.curveOffset ? `; ${wallRange(node, host, nodes)}` : '';
+        throw new DesignPlacementError('does_not_fit', `${detail}${hint}`);
+    }
+    return {
+        node,
+        parentId: host.id,
+        ...(hostNext && { hostUpdate: { id: hostNext.id, attachments: hostNext.attachments } }),
+    };
+}

package/dist/procedural-items/design.d.ts

@@ -0,0 +1,261 @@
+import { z } from 'zod';
+import { RECIPE_LIMITS, RECIPE_V2_LIMITS, type Recipe } from './recipe.js';
+export declare const DesignDiagnosticSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+    code: z.ZodEnum<{
+        behind_wall: "behind_wall";
+        design_too_large: "design_too_large";
+        design_version_not_enabled: "design_version_not_enabled";
+        draw_budget: "draw_budget";
+        floating_component: "floating_component";
+        invalid_json: "invalid_json";
+        parameters: "parameters";
+        rule: "rule";
+        schema: "schema";
+        sweep: "sweep";
+        unbalanced: "unbalanced";
+    }>;
+    path: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const DesignMeasurementsSchema: z.ZodObject<{
+    parameters: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    bounds: z.ZodObject<{
+        min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        dimensions: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>;
+    shapes: z.ZodNumber;
+    triangles: z.ZodObject<{
+        actual: z.ZodNumber;
+        budget: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+    drawBudget: z.ZodNumber;
+    drawGroups: z.ZodArray<z.ZodObject<{
+        slot: z.ZodString;
+        motionGroup: z.ZodNullable<z.ZodString>;
+        shapes: z.ZodNumber;
+        triangles: z.ZodNumber;
+    }, z.core.$strip>>;
+    parts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        instances: z.ZodNumber;
+        shapes: z.ZodNumber;
+        triangles: z.ZodNumber;
+        slots: z.ZodArray<z.ZodString>;
+        motion: z.ZodNullable<z.ZodEnum<{
+            hinge: "hinge";
+            slide: "slide";
+            spin: "spin";
+        }>>;
+        lights: z.ZodNumber;
+        bounds: z.ZodNullable<z.ZodObject<{
+            min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            dimensions: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    datum: z.ZodObject<{
+        kind: z.ZodEnum<{
+            ceiling: "ceiling";
+            floor: "floor";
+            wall: "wall";
+        }>;
+        axis: z.ZodEnum<{
+            y: "y";
+            z: "z";
+        }>;
+        value: z.ZodNumber;
+        gap: z.ZodNumber;
+        contact: z.ZodNullable<z.ZodObject<{
+            parts: z.ZodArray<z.ZodString>;
+            shapes: z.ZodNumber;
+            min: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            max: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>>;
+        balanced: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strip>;
+    components: z.ZodObject<{
+        count: z.ZodNumber;
+        list: z.ZodArray<z.ZodObject<{
+            parts: z.ZodArray<z.ZodString>;
+            shapes: z.ZodNumber;
+            bounds: z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                dimensions: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>;
+            touchesDatum: z.ZodBoolean;
+            datumGap: z.ZodNumber;
+            nearestGap: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    surfaces: z.ZodArray<z.ZodString>;
+    motions: z.ZodNumber;
+    lights: z.ZodNumber;
+}, z.core.$strip>;
+export declare const DesignValidationSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+        }>;
+        code: z.ZodEnum<{
+            behind_wall: "behind_wall";
+            design_too_large: "design_too_large";
+            design_version_not_enabled: "design_version_not_enabled";
+            draw_budget: "draw_budget";
+            floating_component: "floating_component";
+            invalid_json: "invalid_json";
+            parameters: "parameters";
+            rule: "rule";
+            schema: "schema";
+            sweep: "sweep";
+            unbalanced: "unbalanced";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    design: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        mounting: z.ZodEnum<{
+            ceiling: "ceiling";
+            floor: "floor";
+            "wall-side": "wall-side";
+        }>;
+        parameters: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            default: z.ZodNumber;
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+            step: z.ZodNumber;
+            unit: z.ZodString;
+        }, z.core.$strip>>;
+        slots: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    sweep: z.ZodNullable<z.ZodObject<{
+        cases: z.ZodNumber;
+        failed: z.ZodNumber;
+        failures: z.ZodArray<z.ZodObject<{
+            values: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            error: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    measurements: z.ZodNullable<z.ZodObject<{
+        parameters: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        bounds: z.ZodObject<{
+            min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            dimensions: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>;
+        shapes: z.ZodNumber;
+        triangles: z.ZodObject<{
+            actual: z.ZodNumber;
+            budget: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strip>;
+        drawBudget: z.ZodNumber;
+        drawGroups: z.ZodArray<z.ZodObject<{
+            slot: z.ZodString;
+            motionGroup: z.ZodNullable<z.ZodString>;
+            shapes: z.ZodNumber;
+            triangles: z.ZodNumber;
+        }, z.core.$strip>>;
+        parts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            instances: z.ZodNumber;
+            shapes: z.ZodNumber;
+            triangles: z.ZodNumber;
+            slots: z.ZodArray<z.ZodString>;
+            motion: z.ZodNullable<z.ZodEnum<{
+                hinge: "hinge";
+                slide: "slide";
+                spin: "spin";
+            }>>;
+            lights: z.ZodNumber;
+            bounds: z.ZodNullable<z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                dimensions: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        datum: z.ZodObject<{
+            kind: z.ZodEnum<{
+                ceiling: "ceiling";
+                floor: "floor";
+                wall: "wall";
+            }>;
+            axis: z.ZodEnum<{
+                y: "y";
+                z: "z";
+            }>;
+            value: z.ZodNumber;
+            gap: z.ZodNumber;
+            contact: z.ZodNullable<z.ZodObject<{
+                parts: z.ZodArray<z.ZodString>;
+                shapes: z.ZodNumber;
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>;
+            balanced: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strip>;
+        components: z.ZodObject<{
+            count: z.ZodNumber;
+            list: z.ZodArray<z.ZodObject<{
+                parts: z.ZodArray<z.ZodString>;
+                shapes: z.ZodNumber;
+                bounds: z.ZodObject<{
+                    min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    dimensions: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                }, z.core.$strip>;
+                touchesDatum: z.ZodBoolean;
+                datumGap: z.ZodNumber;
+                nearestGap: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        surfaces: z.ZodArray<z.ZodString>;
+        motions: z.ZodNumber;
+        lights: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DesignDiagnostic = z.infer<typeof DesignDiagnosticSchema>;
+export type DesignMeasurements = z.infer<typeof DesignMeasurementsSchema>;
+export type DesignValidation = z.infer<typeof DesignValidationSchema>;
+/**
+ * The highest design version writers (placement, Studio, converters, agents) may emit. Readers
+ * ship one release before writers, so version 2 designs validate and render now and become
+ * placeable in the next release.
+ */
+export declare const DESIGN_WRITE_VERSION = 1;
+/** A small valid design: a square side table with four legs. */
+export declare const DESIGN_EXAMPLE: Recipe;
+export type DesignSchemaDescription = {
+    /** The newest design version the schema covers; version 1 designs stay valid. */
+    version: 2;
+    /** JSON Schema (2020-12) of a design; `$defs.Expr` is the recursive expression type. */
+    schema: Record<string, unknown>;
+    limits: typeof RECIPE_LIMITS;
+    /** Version 2 caps that replace or add to `limits`. */
+    limitsV2: typeof RECIPE_V2_LIMITS;
+    /** Rules JSON Schema cannot express; `validateDesign` enforces them. */
+    rules: string[];
+    example: Recipe;
+};
+/** The design contract for agents, generated from `RecipeSchema` (not from the node, whose recipe is opaque). */
+export declare function describeDesignSchema(): DesignSchemaDescription;
+/**
+ * Validate a design (an object or its JSON string) and measure it at `parameters`
+ * (defaults otherwise). Never throws: problems come back as coded diagnostics.
+ */
+export declare function validateDesign(input: unknown, options?: {
+    parameters?: Record<string, number>;
+}): DesignValidation;
+//# sourceMappingURL=design.d.ts.map

package/dist/procedural-items/design.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design.d.ts","sourceRoot":"","sources":["../../src/procedural-items/design.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAOL,aAAa,EACb,gBAAgB,EAChB,KAAK,MAAM,EAQZ,MAAM,UAAU,CAAA;AAgBjB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;iBAmBjC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoEnC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAuCrC,gEAAgE;AAChE,eAAO,MAAM,cAAc,EAAE,MAgE5B,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,iFAAiF;IACjF,OAAO,EAAE,CAAC,CAAA;IACV,wFAAwF;IACxF,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,MAAM,EAAE,OAAO,aAAa,CAAA;IAC5B,sDAAsD;IACtD,QAAQ,EAAE,OAAO,gBAAgB,CAAA;IACjC,wEAAwE;IACxE,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAID,iHAAiH;AACjH,wBAAgB,oBAAoB,IAAI,uBAAuB,CA0B9D;AA4XD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAO,GACpD,gBAAgB,CA6GlB"}