@pascal-app/core 1.0.5 → 1.0.7

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

@@ -1,9 +1,8 @@
 import type { SlotDeclaration } from '../registry/types.js';
-export type DoorSlotId = 'panel' | 'frame' | 'glass' | 'hardware';
+export type DoorSlotId = 'panel' | 'frame' | 'casing-a' | 'casing-b' | 'glass' | 'hardware';
 /**
- * A door exposes four paintable slots: `panel` (leaf faces), `frame`, `glass`,
- * and `hardware` (handle / hinges / closer / panic bar). The opening reveal
- * keeps its own material.
+ * A door exposes its panel, frame, glass, hardware and casing on each host-wall
+ * face. The opening reveal keeps its own material.
  */
 export declare function doorSlots(): SlotDeclaration[];
 //# sourceMappingURL=door.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"door.d.ts","sourceRoot":"","sources":["../../src/node-slots/door.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,CAAA;AAUjE;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,eAAe,EAAE,CAO7C"}
+{"version":3,"file":"door.d.ts","sourceRoot":"","sources":["../../src/node-slots/door.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,CAAA;AAU3F;;;GAGG;AACH,wBAAgB,SAAS,IAAI,eAAe,EAAE,CAS7C"}

package/dist/node-slots/door.js

@@ -6,14 +6,15 @@ const GLASS_DEFAULT = 'library:preset-glass';
 // Chrome — a flat (non-PBR) catalog metal finish.
 const HARDWARE_DEFAULT = 'library:metal-chrome';
 /**
- * A door exposes four paintable slots: `panel` (leaf faces), `frame`, `glass`,
- * and `hardware` (handle / hinges / closer / panic bar). The opening reveal
- * keeps its own material.
+ * A door exposes its panel, frame, glass, hardware and casing on each host-wall
+ * face. The opening reveal keeps its own material.
  */
 export function doorSlots() {
     return [
         { slotId: 'panel', label: 'Panel', default: PANEL_DEFAULT },
         { slotId: 'frame', label: 'Frame', default: FRAME_DEFAULT },
+        { slotId: 'casing-a', label: 'Casing A', default: FRAME_DEFAULT },
+        { slotId: 'casing-b', label: 'Casing B', default: FRAME_DEFAULT },
         { slotId: 'glass', label: 'Glass', default: GLASS_DEFAULT },
         { slotId: 'hardware', label: 'Hardware', default: HARDWARE_DEFAULT },
     ];

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

@@ -1 +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"}
+{"version":3,"file":"wall.d.ts","sourceRoot":"","sources":["../../src/node-slots/wall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAGxD,OAAO,EAAkD,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAEpG;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,eAAe,EAAE,CA6D5D"}

package/dist/node-slots/wall.js

@@ -1,5 +1,6 @@
 import { getCurtainWallConfig } from '../schema/nodes/curtain-wall.js';
-import { WALL_SURFACE_SLOT_DEFAULTS } from '../schema/nodes/wall.js';
+import { getRailingWallConfig, railingWallSlotDefault } from '../schema/nodes/railing-wall.js';
+import { getWallFaceDefault, 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
@@ -17,9 +18,26 @@ export function wallSlots(node) {
             { slotId: 'curtain-solid', label: 'Solid panels', default: config.solidColor },
         ];
     }
+    // A railing has no faces: it paints its posts and rails, and its infill.
+    if (node?.wallType === 'railing') {
+        const { style } = getRailingWallConfig(node);
+        return [
+            {
+                slotId: 'railing-frame',
+                label: 'Posts & rails',
+                default: railingWallSlotDefault(style, 'railing-frame'),
+            },
+            {
+                slotId: 'railing-infill',
+                label: style === 'glass' ? 'Glass' : 'Infill',
+                default: railingWallSlotDefault(style, 'railing-infill'),
+            },
+        ];
+    }
+    // A face's default follows its side: the interior paint, raw drywall outside.
     return [
-        { slotId: 'a', label: 'Side A', default: WALL_SURFACE_SLOT_DEFAULTS.a },
-        { slotId: 'b', label: 'Side B', default: WALL_SURFACE_SLOT_DEFAULTS.b },
+        { slotId: 'a', label: 'Side A', default: getWallFaceDefault(node ?? {}, 'a') },
+        { slotId: 'b', label: 'Side B', default: getWallFaceDefault(node ?? {}, 'b') },
         {
             slotId: 'aSkirting',
             label: 'Skirting (side A)',

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

@@ -1,5 +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 type WindowSlotId = 'frame' | 'casing-a' | 'casing-b' | 'glass' | 'hardware' | 'shutters' | 'sill';
+/** A window exposes its frame, glass and casing on each host-wall face. */
 export declare function windowSlots(): SlotDeclaration[];
 //# sourceMappingURL=window.d.ts.map

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

@@ -1 +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"}
+{"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,GACpB,OAAO,GACP,UAAU,GACV,UAAU,GACV,OAAO,GACP,UAAU,GACV,UAAU,GACV,MAAM,CAAA;AAOV,2EAA2E;AAC3E,wBAAgB,WAAW,IAAI,eAAe,EAAE,CAU/C"}

package/dist/node-slots/window.js

@@ -2,10 +2,15 @@
 // 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. */
+/** A window exposes its frame, glass and casing on each host-wall face. */
 export function windowSlots() {
     return [
         { slotId: 'frame', label: 'Frame', default: FRAME_DEFAULT },
+        { slotId: 'casing-a', label: 'Casing A', default: FRAME_DEFAULT },
+        { slotId: 'casing-b', label: 'Casing B', default: FRAME_DEFAULT },
         { slotId: 'glass', label: 'Glass', default: GLASS_DEFAULT },
+        { slotId: 'sill', label: 'Sill', default: FRAME_DEFAULT },
+        { slotId: 'hardware', label: 'Hardware', default: FRAME_DEFAULT },
+        { slotId: 'shutters', label: 'Shutters', default: 'library:preset-charcoal' },
     ];
 }

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

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { RECIPE_LIMITS, RECIPE_V2_LIMITS, type Recipe } from './recipe.js';
+/** The MCP resource serving `describeDesignSchema`. */
+export declare const DESIGN_SCHEMA_URI = "pascal://schema/design";
 export declare const DesignDiagnosticSchema: z.ZodObject<{
     severity: z.ZodEnum<{
         error: "error";
@@ -20,6 +22,8 @@ export declare const DesignDiagnosticSchema: z.ZodObject<{
     }>;
     path: z.ZodOptional<z.ZodString>;
     message: z.ZodString;
+    expected: z.ZodOptional<z.ZodString>;
+    received: z.ZodOptional<z.ZodString>;
     hint: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const DesignMeasurementsSchema: z.ZodObject<{
@@ -121,6 +125,8 @@ export declare const DesignValidationSchema: z.ZodObject<{
         }>;
         path: z.ZodOptional<z.ZodString>;
         message: z.ZodString;
+        expected: z.ZodOptional<z.ZodString>;
+        received: z.ZodOptional<z.ZodString>;
         hint: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     design: z.ZodNullable<z.ZodObject<{
@@ -225,6 +231,8 @@ export declare const DesignValidationSchema: z.ZodObject<{
         motions: z.ZodNumber;
         lights: z.ZodNumber;
     }, z.core.$strip>>;
+    schemaUri: z.ZodOptional<z.ZodLiteral<"pascal://schema/design">>;
+    example: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export type DesignDiagnostic = z.infer<typeof DesignDiagnosticSchema>;
 export type DesignMeasurements = z.infer<typeof DesignMeasurementsSchema>;

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

@@ -1 +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"}
+{"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;AAYjB,uDAAuD;AACvD,eAAO,MAAM,iBAAiB,2BAA2B,CAAA;AAMzD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;iBAuBjC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoEnC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BjC,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,CAS9D;AAshBD;;;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,CAiHlB"}

package/dist/procedural-items/design.js

@@ -8,6 +8,8 @@ import { boundsOf } from './spatial.js';
 const CONTACT_TOLERANCE = 0.002;
 const ISSUE_LIMIT = 20;
 const LIST_LIMIT = 16;
+/** The MCP resource serving `describeDesignSchema`. */
+export const DESIGN_SCHEMA_URI = 'pascal://schema/design';
 const vec2 = z.tuple([z.number(), z.number()]);
 const vec3 = z.tuple([z.number(), z.number(), z.number()]);
 const BoundsSchema = z.object({ min: vec3, max: vec3, dimensions: vec3 });
@@ -28,6 +30,10 @@ export const DesignDiagnosticSchema = z.object({
     ]),
     path: z.string().optional(),
     message: z.string(),
+    /** Schema errors: what the design schema takes at `path`. */
+    expected: z.string().optional(),
+    /** Schema errors: the JSON found at `path`, or "nothing". */
+    received: z.string().optional(),
     /** How to fix it, for rule errors whose message alone does not say. */
     hint: z.string().optional(),
 });
@@ -120,6 +126,9 @@ export const DesignValidationSchema = z.object({
     })
         .nullable(),
     measurements: DesignMeasurementsSchema.nullable(),
+    /** A design that does not parse: where its whole schema is, and a valid design to start from. */
+    schemaUri: z.literal(DESIGN_SCHEMA_URI).optional(),
+    example: z.record(z.string(), z.unknown()).optional(),
 });
 /**
  * The highest design version writers (placement, Studio, converters, agents) may emit. Readers
@@ -229,26 +238,32 @@ export const DESIGN_EXAMPLE = {
 let jsonSchema;
 /** The design contract for agents, generated from `RecipeSchema` (not from the node, whose recipe is opaque). */
 export function describeDesignSchema() {
+    return structuredClone({
+        version: 2,
+        schema: designJsonSchema(),
+        limits: RECIPE_LIMITS,
+        limitsV2: RECIPE_V2_LIMITS,
+        rules: DESIGN_RULES,
+        example: DESIGN_EXAMPLE,
+    });
+}
+function designJsonSchema() {
     if (!jsonSchema) {
         const registry = z.registry();
         registry.add(ExpressionSchema, {
             id: 'Expr',
             description: 'A number, a parameter id, "index" (the 0-based repeat inside part.count) or {op, args}.',
         });
+        registry.add(RecipeSchema.shape.mounting.unwrap(), {
+            description: 'A floor design leaves mounting out: it stands on the floor at y = 0. Wall-side and ceiling designs name their reference, a surface without part (see the mounting rules).',
+        });
         jsonSchema = {
             title: 'Pascal design',
             description: 'A procedural design: parameters, material slots and parts made of box, roundedBox, cylinder and ellipsoid shapes, and in version 2 extrude and revolve shapes, part trees and joints. Validation enforces rules this schema cannot express and is the authority.',
             ...z.toJSONSchema(RecipeSchema, { io: 'input', metadata: registry }),
         };
     }
-    return structuredClone({
-        version: 2,
-        schema: jsonSchema,
-        limits: RECIPE_LIMITS,
-        limitsV2: RECIPE_V2_LIMITS,
-        rules: DESIGN_RULES,
-        example: DESIGN_EXAMPLE,
-    });
+    return jsonSchema;
 }
 const EXPRESSION_KEYS = new Set([
     'count',
@@ -292,12 +307,135 @@ const EXPRESSION_KEYS = new Set([
 function formatPath(path) {
     return path.reduce((text, key) => typeof key === 'number' ? `${text}[${key}]` : `${text}${text ? '.' : ''}${String(key)}`, '');
 }
+const jsonNode = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+const refName = (node) => typeof node.$ref === 'string' ? node.$ref.replace('#/$defs/', '') : undefined;
+const deref = (node, root) => jsonNode(jsonNode(root.$defs)?.[refName(node) ?? '']) ?? node;
+/** Whether the value's discriminating keys (a `const` or an `enum` there) allow this branch. */
+function fitsBranch(branch, value) {
+    const properties = jsonNode(branch.properties);
+    const object = jsonNode(value);
+    if (!properties || !object)
+        return true;
+    return Object.entries(properties).every(([key, property]) => {
+        const node = jsonNode(property);
+        if (!node || !(key in object))
+            return true;
+        if ('const' in node)
+            return node.const === object[key];
+        return !Array.isArray(node.enum) || node.enum.includes(object[key]);
+    });
+}
+/** A node's alternatives, narrowed to those the value fits when it fits any. */
+function branchesOf(node, root, value) {
+    const resolved = deref(node, root);
+    const list = resolved.anyOf ?? resolved.oneOf;
+    if (!Array.isArray(list) || refName(node))
+        return [resolved];
+    const all = list.flatMap((branch) => {
+        const child = jsonNode(branch);
+        return child ? branchesOf(child, root, value) : [];
+    });
+    const fitting = all.filter((branch) => fitsBranch(branch, value));
+    return fitting.length ? fitting : all;
+}
+/** The schema nodes at a path, whether the last step is optional, and the nearest description on the way. */
+function schemaAt(root, path, raw) {
+    let nodes = [root];
+    let value = raw;
+    let optional = false;
+    let note;
+    for (const key of path) {
+        const next = [];
+        optional = false;
+        for (const node of nodes.flatMap((candidate) => branchesOf(candidate, root, value))) {
+            const child = typeof key === 'number'
+                ? jsonNode(Array.isArray(node.prefixItems) ? node.prefixItems[key] : node.items)
+                : jsonNode(jsonNode(node.properties)?.[String(key)]);
+            if (!child)
+                continue;
+            if (typeof key !== 'number')
+                optional = !(Array.isArray(node.required) && node.required.includes(key));
+            next.push(child);
+        }
+        if (!next.length)
+            return null;
+        nodes = next;
+        value = jsonNode(value) || Array.isArray(value) ? Reflect.get(value, key) : undefined;
+        const described = nodes.find((node) => typeof node.description === 'string' && !refName(node));
+        if (described)
+            note = described.description;
+    }
+    return { nodes: nodes.flatMap((node) => branchesOf(node, root, value)), optional, note };
+}
+const unique = (list) => [...new Set(list)];
+/** A schema node in a line: its keys (`?` optional), values, item shape or type. */
+function summarize(node, root, depth = 0) {
+    const ref = refName(node);
+    if (ref)
+        return depth ? ref : summarize(deref(node, root), root, depth);
+    if ('const' in node)
+        return JSON.stringify(node.const);
+    if (Array.isArray(node.enum))
+        return node.enum.map((value) => JSON.stringify(value)).join(' | ');
+    const list = node.anyOf ?? node.oneOf;
+    if (Array.isArray(list)) {
+        if (depth === 0 && typeof node.description === 'string')
+            return node.description;
+        return unique(list.flatMap((branch) => {
+            const child = jsonNode(branch);
+            return child ? [summarize(child, root, depth + 1)] : [];
+        })).join(' | ');
+    }
+    const required = Array.isArray(node.required) ? node.required : [];
+    switch (node.type) {
+        case 'object': {
+            const keys = Object.keys(jsonNode(node.properties) ?? {});
+            if (depth > 1 || !keys.length)
+                return 'an object';
+            return `an object with ${keys.map((key) => (required.includes(key) ? key : `${key}?`)).join(', ')}${node.additionalProperties === false ? ' and no other keys' : ''}`;
+        }
+        case 'array': {
+            if (Array.isArray(node.prefixItems))
+                return `[${node.prefixItems.map((item) => summarize(jsonNode(item) ?? {}, root, depth + 1)).join(', ')}]`;
+            const items = jsonNode(node.items);
+            const range = typeof node.minItems === 'number' || typeof node.maxItems === 'number'
+                ? ` (${node.minItems ?? 0} to ${node.maxItems ?? 'any'} items)`
+                : '';
+            const item = items ? summarize(items, root, depth + 1).replace(/^an object\b/, 'objects') : '';
+            return `a list${item ? ` of ${item}` : ''}${range}`;
+        }
+        case 'string':
+            return typeof node.pattern === 'string' ? `a string matching ${node.pattern}` : 'a string';
+        case 'number':
+        case 'integer':
+            return `${node.type === 'integer' ? 'an integer' : 'a number'}${typeof node.minimum === 'number' && typeof node.maximum === 'number' ? ` from ${node.minimum} to ${node.maximum}` : ''}`;
+        case 'boolean':
+            return 'true or false';
+        default:
+            return 'anything';
+    }
+}
+/** What the design schema takes at a path, in a line: enough to fix it without probing. */
+function expectedAt(path, raw) {
+    const root = designJsonSchema();
+    const found = schemaAt(root, path, raw);
+    if (!found)
+        return undefined;
+    let text = unique(found.nodes.map((node) => summarize(node, root))).join(' | ');
+    const expr = jsonNode(jsonNode(root.$defs)?.Expr);
+    if (/\bExpr\b/.test(text) && typeof expr?.description === 'string')
+        text += `; Expr is ${expr.description}`;
+    if (found.optional)
+        text += '; optional';
+    if (found.note && !text.includes(found.note))
+        text += `. ${found.note}`;
+    return text;
+}
 function schemaDiagnostics(error, raw) {
     const diagnostics = error.issues.slice(0, ISSUE_LIMIT).map((issue) => {
         let value = raw;
         for (const key of issue.path)
             value = value && typeof value === 'object' ? Reflect.get(value, key) : undefined;
-        const got = (JSON.stringify(value) ?? 'nothing').slice(0, 80);
         let message = issue.message;
         if (issue.code === 'invalid_format' && issue.format === 'regex')
             message =
@@ -306,11 +444,14 @@ function schemaDiagnostics(error, raw) {
                     : issue.path.some((key) => typeof key === 'string' && EXPRESSION_KEYS.has(key))
                         ? 'expressions are a number, a parameter id, "index" or {op, args}; arithmetic strings are not supported'
                         : 'IDs and references are lowercase snake_case matching ^[a-z][a-z0-9_]{0,47}$';
+        const expected = expectedAt(issue.path, raw);
         return {
             severity: 'error',
             code: 'schema',
             path: formatPath(issue.path) || undefined,
-            message: `${message} (got ${got})`,
+            message,
+            ...(expected && { expected }),
+            received: (JSON.stringify(value) ?? 'nothing').slice(0, 120),
             ...(/requires recipe version 2/.test(message) && {
                 hint: 'Set "version": 2 (and keep the design under 24 KiB), or leave out the v2 feature.',
             }),
@@ -604,13 +745,20 @@ export function validateDesign(input, options = {}) {
         sweep: null,
         measurements: null,
     });
+    // A design that does not parse may have been written blind: its answer points at the schema
+    // and hands a valid design to start from, so one answer is enough to rewrite it.
+    const unparsed = (diagnostics) => ({
+        ...failed(diagnostics),
+        schemaUri: DESIGN_SCHEMA_URI,
+        example: DESIGN_EXAMPLE,
+    });
     let raw = input;
     if (typeof input === 'string') {
         try {
             raw = JSON.parse(input);
         }
         catch (error) {
-            return failed([
+            return unparsed([
                 { severity: 'error', code: 'invalid_json', message: `Not valid JSON: ${message(error)}` },
             ]);
         }
@@ -635,16 +783,16 @@ export function validateDesign(input, options = {}) {
         recipe = parseRecipe(raw);
     }
     catch (error) {
-        return failed(error instanceof z.ZodError
-            ? schemaDiagnostics(error, raw)
-            : [
-                {
-                    severity: 'error',
-                    code: 'rule',
-                    message: message(error),
-                    ...(ruleHint(message(error), raw) && { hint: ruleHint(message(error), raw) }),
-                },
-            ]);
+        if (error instanceof z.ZodError)
+            return unparsed(schemaDiagnostics(error, raw));
+        return failed([
+            {
+                severity: 'error',
+                code: 'rule',
+                message: message(error),
+                ...(ruleHint(message(error), raw) && { hint: ruleHint(message(error), raw) }),
+            },
+        ]);
     }
     const diagnostics = [];
     const cases = sweepRecipe(recipe);

package/dist/procedural-items/motion-controller.d.ts

@@ -24,6 +24,8 @@ export declare class ProceduralMotionController {
             speed: number;
         }>;
         pending: boolean;
+        /** Every opening and sliding part has come to rest; spinning ones may still run. */
+        settled: boolean;
     };
 }
 //# sourceMappingURL=motion-controller.d.ts.map

package/dist/procedural-items/motion-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"motion-controller.d.ts","sourceRoot":"","sources":["../../src/procedural-items/motion-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAsB,cAAc,EAAE,MAAM,UAAU,CAAA;AAEnF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,KAAK,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IACjC,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAID,qBAAa,0BAA0B;IASnC,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE;IAR9C,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAA;IACpD,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,KAAK,CAAsD;IACnE,OAAO,CAAC,OAAO,CAA+C;IAC9D,OAAO,CAAC,QAAQ,CAAK;IAErB,YACW,OAAO,EAAE,SAAS,eAAe,EAAE,EAC5C,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EAQtC;IAED,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CA4DpC;IAED,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG;QAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;QACvD,OAAO,EAAE,OAAO,CAAA;KACjB,CAoDA;CACF"}
+{"version":3,"file":"motion-controller.d.ts","sourceRoot":"","sources":["../../src/procedural-items/motion-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAsB,cAAc,EAAE,MAAM,UAAU,CAAA;AAEnF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,KAAK,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IACjC,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAID,qBAAa,0BAA0B;IASnC,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE;IAR9C,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAA;IACpD,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,KAAK,CAAsD;IACnE,OAAO,CAAC,OAAO,CAA+C;IAC9D,OAAO,CAAC,QAAQ,CAAK;IAErB,YACW,OAAO,EAAE,SAAS,eAAe,EAAE,EAC5C,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EAQtC;IAED,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CA4DpC;IAED,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG;QAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;QACvD,OAAO,EAAE,OAAO,CAAA;QAChB,oFAAoF;QACpF,OAAO,EAAE,OAAO,CAAA;KACjB,CAsDA;CACF"}

package/dist/procedural-items/motion-controller.js

@@ -125,6 +125,7 @@ export class ProceduralMotionController {
             if (next !== target || next > 0)
                 pending = true;
         }
-        return { times, fractions, spins: Object.fromEntries(this.spins), pending };
+        const settled = !this.collective && [...this.parts.values()].every((cursor) => cursor.direction === 0);
+        return { times, fractions, spins: Object.fromEntries(this.spins), pending, settled };
     }
 }

package/dist/registry/index.d.ts

@@ -1,9 +1,9 @@
 export type { ArcResizeHandle, CornerRadiusHandle, Cursor, EditorApi, EndpointMoveHandle, HandleAnchor, HandleAxis, HandleDescriptor, HandleDragModifiers, HandleList, HandlePlacement, HandlePortal, HandlePreviewSession, LatchHandle, LinearResizeHandle, RadialResizeHandle, TapActionHandle, TranslateHandle, } from './handles.js';
-export { nodeMechanism, toggleMechanism, toggleNodeMechanism } from './mechanism.js';
+export { nodeMechanism, nodeMechanismParts, toggleMechanism, toggleMechanismPart, toggleNodeMechanism, } from './mechanism.js';
 export { bakePolicyOf, discoverPlugins, extendPluginDiscovery, floorPlacedCollides, getHostRefFields, getInspectorExtensions, getNodePluginId, getRegistryVersion, getSelectableKinds, hasRegistry3DMoveTool, isDrawnViaTool, isDrawnViaToolKind, isNodeKindEnabled, isPresettable, isPresettableKind, isRegistryMovable, isRegistrySelectable, isSelectionHighlightEnabled, kindsWithBakePolicy, kindsWithFloorplanScope, loadPlugin, nodeRegistry, onRegistryChange, type PluginDiscovery, registerNode, resolveFacingIndicator, setPluginDiscovery, } from './registry.js';
 export { type CascadeContext, type ChildQuery, cascadeDirty, collectDescendants, type SpatialQuery, } from './relations-resolver.js';
 export { createSceneApi, type SceneStoreLike, type SceneToolHost } from './scene-api.js';
 export { type CloneNodesIntoOptions, type CloneNodesIntoResult, cloneNodesInto, collectSubtree, type Subtree, withoutSourceIdentity, } from './subtree.js';
-export type { Affordance, AlignmentFootprint, AlignmentFootprintConfig, AnyNodeDefinition, AssemblyHostConfig, AssemblyReference, AssetRef, BakeGeometryAsyncBuilder, BakeGeometryBuilder, BakePolicy, BakeReplaceRenderer, BatchableConfig, Capabilities, CapabilityCtx, CutsContext, CuttableConfig, DimensionTerminator, DimensionTextPosition, DistributionRole, DragAction, DuplicableConfig, DuplicateSubtreeCloneArgs, DuplicateSubtreeCloneResult, EditorCtx, EvaluationContext, ExportAnimationContext, ExportProfile, FaceHostCapability, FaceHostPlacementArgs, FaceHostPlacementResult, FaceHostStoredPlacementArgs, FaceHostStoredValidityArgs, FloorPlacedConfig, FloorPlacedFootprint, FloorPlacedFootprintContext, FloorPlacedFootprintResolver, FloorPlacedFootprintsResolver, FloorplanAffordance, FloorplanAffordanceModifiers, FloorplanAffordancePoint, FloorplanAffordanceSession, FloorplanGeometry, FloorplanMoveTarget, FloorplanMoveTargetSession, FloorplanPalette, FloorplanPoint, FloorplanScope, FloorplanStyle, GeometryContext, GridSnapPositionArgs, GroupMoveSnapArgs, GroupMoveSnapResult, HostableConfig, IconRef, InspectorExtension, Issue, KeyboardAction, KeyboardActions, LazyComponent, LiveTransformLike, McpOverrides, MeasurementContribution, MeasurementFeature, MeasurementFeatureBinding, MeasurementFeatureGeometry, MeasurementSnapKind, MechanismCapability, Modifiers, MovableConfig, MovableParentFrame, NodeCategory, NodeDefinition, NodePort, NodeQuickAction, NodeQuickActionIcon, NodeQuickActionNodeScope, NodeQuickActionProvider, NodeQuickActionResult, NodeRegistry, PaintCapability, PaintEffectiveMaterialArgs, PaintPatchArgs, PaintPreviewArgs, PaintResolveArgs, ParamAction, ParametricDescriptor, ParamField, ParamGroup, ParentFrameSnapMatch, PascalBakeExtras, PascalPartTag, PlacementNotice, Plugin, PortRef, Presentation, QuickMeasurementMetric, QuickMeasurementQuantity, QuickMeasurementReport, ReferenceDeclaration, ReferenceDeletePolicy, ReferenceNamespace, ReferencePath, ReferencePresetPolicy, ReferenceRole, Relations, RendererSource, RevealClears, RevealConfig, RevealLayout, RevealPhase, RevealPlanPoint, RevealStyle, RoofAccessoryConfig, RotatableConfig, ScalableConfig, SceneActionCapability, SceneApi, SelectableConfig, SlotDeclaration, SnapPointKind, SnapProfile, SnappableConfig, SnapServicesLike, SurfacePoint, SurfaceQuery, SurfaceRole, SurfacesConfig, SystemContribution, ToolHint, ToolHintChip, ToolOption, ToolOptionChoice, Vec2, } from './types.js';
+export type { Affordance, AlignmentFootprint, AlignmentFootprintConfig, AnyNodeDefinition, AssemblyHostConfig, AssemblyReference, AssetRef, BakeGeometryAsyncBuilder, BakeGeometryBuilder, BakePolicy, BakeReplaceRenderer, BatchableConfig, Capabilities, CapabilityCtx, CutsContext, CuttableConfig, DimensionTerminator, DimensionTextPosition, DistributionRole, DragAction, DuplicableConfig, DuplicateSubtreeCloneArgs, DuplicateSubtreeCloneResult, EditorCtx, EvaluationContext, ExportAnimationContext, ExportProfile, FaceHostCapability, FaceHostPlacementArgs, FaceHostPlacementResult, FaceHostStoredPlacementArgs, FaceHostStoredValidityArgs, FloorPlacedConfig, FloorPlacedFootprint, FloorPlacedFootprintContext, FloorPlacedFootprintResolver, FloorPlacedFootprintsResolver, FloorplanAffordance, FloorplanAffordanceModifiers, FloorplanAffordancePoint, FloorplanAffordanceSession, FloorplanGeometry, FloorplanMoveTarget, FloorplanMoveTargetSession, FloorplanPalette, FloorplanPoint, FloorplanScope, FloorplanStyle, GeometryContext, GridSnapPositionArgs, GroupMoveSnapArgs, GroupMoveSnapResult, HostableConfig, IconRef, InspectorExtension, Issue, KeyboardAction, KeyboardActions, LazyComponent, LiveTransformLike, McpOverrides, MeasurementContribution, MeasurementFeature, MeasurementFeatureBinding, MeasurementFeatureGeometry, MeasurementSnapKind, MechanismCapability, MechanismPart, Modifiers, MovableConfig, MovableParentFrame, NodeCategory, NodeDefinition, NodePort, NodeQuickAction, NodeQuickActionIcon, NodeQuickActionNodeScope, NodeQuickActionProvider, NodeQuickActionResult, NodeRegistry, PaintCapability, PaintEffectiveMaterialArgs, PaintPatchArgs, PaintPreviewArgs, PaintResolveArgs, PaintScopeId, PaintSurfaceScopes, ParamAction, ParametricDescriptor, ParamField, ParamGroup, ParentFrameSnapMatch, PascalBakeExtras, PascalPartTag, PlacementNotice, Plugin, PortRef, Presentation, QuickMeasurementMetric, QuickMeasurementQuantity, QuickMeasurementReport, ReferenceDeclaration, ReferenceDeletePolicy, ReferenceNamespace, ReferencePath, ReferencePresetPolicy, ReferenceRole, Relations, RendererSource, RevealClears, RevealConfig, RevealLayout, RevealPhase, RevealPlanPoint, RevealStyle, RoofAccessoryConfig, RotatableConfig, ScalableConfig, SceneActionCapability, SceneApi, SelectableConfig, SlotDeclaration, SnapPointKind, SnapProfile, SnappableConfig, SnapServicesLike, SurfacePoint, SurfaceQuery, SurfaceRole, SurfacesConfig, SystemContribution, ToolHint, ToolHintChip, ToolOption, ToolOptionChoice, Vec2, } from './types.js';
 export { validateNodeRelations } from './validate-relations.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/registry/index.d.ts.map

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

package/dist/registry/index.js

@@ -1,4 +1,4 @@
-export { nodeMechanism, toggleMechanism, toggleNodeMechanism } from './mechanism.js';
+export { nodeMechanism, nodeMechanismParts, toggleMechanism, toggleMechanismPart, toggleNodeMechanism, } from './mechanism.js';
 export { bakePolicyOf, discoverPlugins, extendPluginDiscovery, floorPlacedCollides, getHostRefFields, getInspectorExtensions, getNodePluginId, getRegistryVersion, getSelectableKinds, hasRegistry3DMoveTool, isDrawnViaTool, isDrawnViaToolKind, isNodeKindEnabled, isPresettable, isPresettableKind, isRegistryMovable, isRegistrySelectable, isSelectionHighlightEnabled, kindsWithBakePolicy, kindsWithFloorplanScope, loadPlugin, nodeRegistry, onRegistryChange, registerNode, resolveFacingIndicator, setPluginDiscovery, } from './registry.js';
 export { cascadeDirty, collectDescendants, } from './relations-resolver.js';
 export { createSceneApi } from './scene-api.js';

package/dist/registry/mechanism.d.ts

@@ -1,9 +1,12 @@
 import type { AnyNode } from '../schema/types.js';
-import type { MechanismCapability } from './types.js';
+import type { MechanismCapability, MechanismPart } from './types.js';
 /** The node's mechanism, when its kind declares one and the node has something to run. */
 export declare function nodeMechanism(node: AnyNode | undefined): MechanismCapability | undefined;
 /** Any of its mechanisms running → stop them all, else start them all. */
 export declare function toggleMechanism(mechanism: MechanismCapability, node: AnyNode): void;
 /** Toggles the node's mechanism; false when it has none. */
 export declare function toggleNodeMechanism(node: AnyNode): boolean;
+/** Additional controls are independent of whether the main mechanism is available. */
+export declare function nodeMechanismParts(node: AnyNode | undefined): MechanismPart[];
+export declare function toggleMechanismPart(part: MechanismPart, node: AnyNode): void;
 //# sourceMappingURL=mechanism.d.ts.map

package/dist/registry/mechanism.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/registry/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAG9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElD,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,mBAAmB,GAAG,SAAS,CAIxF;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,SAAS,EAAE,mBAAmB,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAEnF;AAED,4DAA4D;AAC5D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAK1D"}
+{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/registry/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAG9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEjE,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,mBAAmB,GAAG,SAAS,CAIxF;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,SAAS,EAAE,mBAAmB,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAEnF;AAED,4DAA4D;AAC5D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAK1D;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,aAAa,EAAE,CAM7E;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAE5E"}

package/dist/registry/mechanism.js

@@ -19,3 +19,13 @@ export function toggleNodeMechanism(node) {
     toggleMechanism(mechanism, node);
     return true;
 }
+/** Additional controls are independent of whether the main mechanism is available. */
+export function nodeMechanismParts(node) {
+    if (!node)
+        return [];
+    return (nodeRegistry.get(node.type)?.capabilities.mechanism?.parts?.filter((part) => part.has(node)) ??
+        []);
+}
+export function toggleMechanismPart(part, node) {
+    part.set(node, !part.isOn(node, useInteractive.getState()));
+}