@pascal-app/core 1.0.3 → 1.0.5

package/dist/procedural-items/recipe.js

@@ -1,5 +1,7 @@
 import { z } from 'zod';
-import { rotateVector } from './spatial.js';
+import { jointReach, partMoves, placeParts, usesPartTree, validatePartTree } from './joints.js';
+import { extrusionTriangles, sectionRings, sectionThickness } from './section.js';
+import { boundsOf, boxCorners, composePoses, eulerPose, frame, hingePose, IDENTITY_POSE, matrixEuler, posePoint, rotateVector, transformPoint, } from './spatial.js';
 const id = z.string().regex(/^[a-z][a-z0-9_]{0,47}$/);
 const finite = z.number().finite().min(-1000).max(1000);
 const expression = z.lazy(() => z.union([
@@ -10,17 +12,168 @@ const expression = z.lazy(() => z.union([
         args: z.array(expression).min(2).max(8),
     }),
     z.strictObject({
-        op: z.enum(['floor', 'ceil', 'round', 'abs']),
+        op: z.enum(['floor', 'ceil', 'round', 'abs', 'sin', 'cos']),
         args: z.tuple([expression]),
     }),
     z.strictObject({
         op: z.literal('mod'),
         args: z.tuple([expression, expression]),
     }),
+    z.strictObject({
+        op: z.literal('select'),
+        args: z.array(expression).min(2).max(65),
+    }),
 ]));
+export const ExpressionSchema = expression;
 const vector = z.tuple([expression, expression, expression]);
-export const RecipeSchema = z.strictObject({
-    version: z.literal(1),
+const sectionRing = z
+    .array(z.tuple([expression, expression]))
+    .min(3)
+    .max(64);
+// An F1 section whose numbers may be expressions; it evaluates to a ResolvedSectionProfile.
+const section = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('rectangle'),
+        width: expression,
+        depth: expression,
+        corner: expression.optional(),
+    }),
+    z.strictObject({ kind: z.literal('round'), radius: expression, wall: expression.optional() }),
+    z.strictObject({ kind: z.literal('oval'), width: expression, depth: expression }),
+    z.strictObject({
+        kind: z.literal('section'),
+        family: z.enum(['I', 'C', 'L', 'T', 'Z', 'rect-tube']),
+        width: expression,
+        depth: expression,
+        web: expression,
+        flange: expression,
+    }),
+    z.strictObject({
+        kind: z.literal('polygon'),
+        outer: sectionRing,
+        holes: z.array(sectionRing).max(16).optional(),
+    }),
+]);
+const timing = {
+    delay: expression.optional(),
+    duration: expression.optional(),
+    easing: z.enum(['linear', 'smooth', 'soft']).optional(),
+};
+const cutCenter = z.tuple([expression, expression]).optional();
+const cut = z.discriminatedUnion('shape', [
+    z.strictObject({
+        shape: z.literal('rect'),
+        size: z.tuple([expression, expression]),
+        center: cutCenter,
+    }),
+    z.strictObject({ shape: z.literal('circle'), diameter: expression, center: cutCenter }),
+]);
+const motion = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('hinge'),
+        pivot: vector,
+        axis: z.enum(['x', 'y', 'z']),
+        angle: expression,
+        ...timing,
+    }),
+    z.strictObject({
+        kind: z.literal('slide'),
+        axis: z.enum(['x', 'y', 'z']),
+        distance: expression,
+        ...timing,
+    }),
+    z.strictObject({
+        kind: z.literal('spin'),
+        pivot: vector,
+        axis: z.enum(['x', 'y', 'z']),
+        radiansPerSecond: expression,
+    }),
+]);
+// Version 2 lifts the part caps; triangles (counted as three.js builds them), bytes, repeat
+// counts, expressions and the structural budget bound the rest.
+// Inline v2 designs stay under R7's 24 KiB until pinned definitions (P-05) store larger ones.
+export const RECIPE_V2_LIMITS = {
+    parts: 64,
+    partShapes: 512,
+    shapes: 512,
+    bytes: 24 * 1024,
+};
+export const RECIPE_LIMITS = {
+    bytes: 131072,
+    depth: 24,
+    expressions: 50000,
+    shapes: 256,
+    triangles: 100000,
+    dimension: 30,
+    motionParts: 8,
+    motionGroups: 32,
+    lights: 12,
+};
+// Shape keys keep v1's order (id, primitive, slot, size, position, …), so parsed v1 recipes
+// serialize byte for byte as before.
+const shapeTail = {
+    support: z.boolean().optional(),
+    // v2: the shape is built only where this evaluates to nonzero.
+    when: expression.optional(),
+};
+// Sized primitives keep a required size (R1: v1 consumers narrow on primitive and read it).
+const solidShape = z.strictObject({
+    id,
+    primitive: z.enum(['box', 'roundedBox', 'cylinder', 'ellipsoid']),
+    slot: id,
+    size: vector,
+    position: vector,
+    rotation: vector.optional(),
+    radius: expression.optional(),
+    topScale: expression.optional(),
+    // v2 cylinders: side count (absent = 24), no end caps, hollow wall (inner radius as a
+    // fraction of the outer), and a partial sweep in radians from local +Z toward +X, closed
+    // by flat wedge sides unless open.
+    segments: z.number().int().min(3).max(64).optional(),
+    open: z.boolean().optional(),
+    inner: expression.optional(),
+    arc: expression.optional(),
+    ...shapeTail,
+});
+// v2 extrude: a section in local x/y, extruded along local z by length, centred.
+const extrudeShape = z.strictObject({
+    id,
+    primitive: z.literal('extrude'),
+    slot: id,
+    section,
+    length: expression,
+    bevel: expression.optional(),
+    position: vector,
+    rotation: vector.optional(),
+    ...shapeTail,
+});
+// v2 revolve: [radius, height] points turned about local Y (segments and arc as on
+// cylinders); the shape is closed where the profile meets the axis at both ends.
+const revolveShape = z.strictObject({
+    id,
+    primitive: z.literal('revolve'),
+    slot: id,
+    profile: z
+        .array(z.tuple([expression, expression]))
+        .min(2)
+        .max(64),
+    segments: z.number().int().min(3).max(64).optional(),
+    arc: expression.optional(),
+    position: vector,
+    rotation: vector.optional(),
+    ...shapeTail,
+});
+/** The sized-primitive fields of a shape (none for an extrude). */
+function solidFields(shape) {
+    if (shape.primitive === 'extrude')
+        return {};
+    if (shape.primitive === 'revolve')
+        return { segments: shape.segments, arc: shape.arc };
+    return shape;
+}
+const RecipeObject = z.strictObject({
+    // Version 2 marks content that older readers cannot evaluate; v2-only fields require it.
+    version: z.union([z.literal(1), z.literal(2)]),
     name: z.string().min(1).max(100),
     description: z.string().max(600),
     classification: z
@@ -33,6 +186,11 @@ export const RecipeSchema = z.strictObject({
     mounting: z
         .strictObject({ attachTo: z.enum(['wall-side', 'ceiling']), reference: id })
         .optional(),
+    // v2, floor designs: the design-space height that rests on the host floor.
+    base: expression.optional(),
+    // v2, ceiling designs: an opening in the host ceiling, drawn in the mounting reference's x/z
+    // plane around it. The design may rise above the reference only inside its cut.
+    cuts: z.array(cut).min(1).max(1).optional(),
     surfaces: z
         .array(z.strictObject({
         id,
@@ -52,7 +210,9 @@ export const RecipeSchema = z.strictObject({
         min: finite,
         max: finite,
         step: z.number().positive().max(100),
-        unit: z.enum(['m', 'count', 'rad']),
+        // v2: 'bool' is 0 | 1; 'choice' is an index into `options`.
+        unit: z.enum(['m', 'count', 'rad', 's', 'bool', 'choice']),
+        options: z.array(z.string().min(1).max(60)).min(2).max(16).optional(),
         part: id.optional(),
         axis: z.enum(['x', 'y', 'z']).optional(),
     }))
@@ -72,22 +232,45 @@ export const RecipeSchema = z.strictObject({
         id,
         label: z.string().min(1).max(60),
         count: expression,
-        shapes: z
-            .array(z.strictObject({
-            id,
-            primitive: z.enum(['box', 'roundedBox', 'cylinder']),
-            slot: id,
-            size: vector,
+        // v2 part tree: the part moves with `parent` (repeating once, or exactly as often,
+        // bound by index) and its shapes, light and joint are authored in `frame`.
+        parent: id.optional(),
+        frame: z.strictObject({ position: vector, rotation: vector.optional() }).optional(),
+        // v2: a repeat is built only where this evaluates to nonzero.
+        when: expression.optional(),
+        motion: motion.optional(),
+        light: z
+            .strictObject({
             position: vector,
-            rotation: vector.optional(),
-            radius: expression.optional(),
-            support: z.boolean().optional(),
-        }))
+            color: z.string().regex(/^#[0-9a-fA-F]{6}$/),
+            intensity: z.number().finite().gt(0).max(10).optional(),
+            distance: z.number().finite().min(0.1).max(10).optional(),
+            emissiveSlot: id.optional(),
+        })
+            .optional(),
+        shapes: z
+            .array(z.discriminatedUnion('primitive', [solidShape, extrudeShape, revolveShape]))
             .min(1)
-            .max(24),
+            .max(RECIPE_V2_LIMITS.partShapes),
     }))
         .min(1)
-        .max(16),
+        .max(RECIPE_V2_LIMITS.parts),
+    // v2: at most one joint per part, keyed by the child part; origin and axis are in the part's
+    // frame. Values are radians (revolute, continuous speed per second) or metres (prismatic).
+    joints: z
+        .array(z.strictObject({
+        child: id,
+        kind: z.enum(['fixed', 'revolute', 'continuous', 'prismatic']),
+        origin: vector,
+        axis: vector,
+        open: expression.optional(),
+        rest: expression.optional(),
+        range: z.tuple([expression, expression]).optional(),
+        speed: expression.optional(),
+        ...timing,
+    }))
+        .max(64)
+        .optional(),
     constraints: z
         .array(z.strictObject({
         left: expression,
@@ -97,14 +280,11 @@ export const RecipeSchema = z.strictObject({
     }))
         .max(24),
 });
-export const RECIPE_LIMITS = {
-    bytes: 131072,
-    depth: 24,
-    expressions: 50000,
-    shapes: 256,
-    triangles: 100000,
-    dimension: 30,
-};
+export const RecipeSchema = RecipeObject.superRefine((recipe, ctx) => {
+    const issue = versionIssue(recipe);
+    if (issue)
+        ctx.addIssue({ code: 'custom', message: issue });
+});
 function guardTree(value, depth = 0, budget = { count: 0 }) {
     if (++budget.count > 12000 || depth > RECIPE_LIMITS.depth)
         throw new Error('Recipe exceeds structural budget');
@@ -116,11 +296,75 @@ function guardTree(value, depth = 0, budget = { count: 0 }) {
         }
     }
 }
+function movingParts(recipe) {
+    return (recipe.parts.filter((part) => part.motion).length +
+        (recipe.joints ?? []).filter((joint) => joint.kind !== 'fixed').length);
+}
+function findV2Feature(recipe) {
+    for (const primitive of ['extrude', 'revolve'])
+        if (recipe.parts.some((part) => part.shapes.some((shape) => shape.primitive === primitive)))
+            return primitive;
+    if (recipe.parts.some((part) => part.shapes.some((shape) => [
+        solidFields(shape).segments,
+        solidFields(shape).open,
+        solidFields(shape).inner,
+        solidFields(shape).arc,
+    ].some((v) => v !== undefined))))
+        return 'Cylinder segments, open, inner and arc';
+    if (usesPartTree(recipe))
+        return 'Part trees and joints';
+    if (recipe.parameters.some((p) => p.unit === 'bool' || p.unit === 'choice' || p.options))
+        return 'Bool and choice parameters';
+    if (recipe.parts.some((part) => part.when !== undefined || part.shapes.some((s) => s.when !== undefined)))
+        return 'when';
+    const selects = (value) => Array.isArray(value)
+        ? value.some(selects)
+        : Boolean(value && typeof value === 'object') &&
+            (value.op === 'select' ||
+                Object.values(value).some(selects));
+    return selects(recipe) ? 'select' : null;
+}
+/**
+ * Version rules the exported schema, parseRecipe and evaluateRecipe all enforce: content
+ * only a v2 reader understands must say `version: 2`.
+ */
+function versionIssue(recipe) {
+    if (recipe.base !== undefined) {
+        if (recipe.version !== 2)
+            return 'A declared base requires recipe version 2';
+        if (recipe.mounting)
+            return 'A declared base applies to floor designs; mounted designs use their reference';
+    }
+    if (recipe.version === 1) {
+        const feature = findV2Feature(recipe);
+        if (feature)
+            return `${feature} requires recipe version 2`;
+    }
+    if (recipe.version === 1 && recipe.parts.length > 16)
+        return 'More than 16 parts requires recipe version 2';
+    if (recipe.version === 1 && recipe.parts.some((part) => part.shapes.length > 24))
+        return 'More than 24 shapes in a part requires recipe version 2';
+    if (recipe.version === 2 && recipeBytes(recipe) > RECIPE_V2_LIMITS.bytes)
+        return 'A version 2 recipe above 24 KiB needs a pinned definition (P-05); keep it inline under 24 KiB';
+    if (recipe.cuts !== undefined) {
+        if (recipe.version !== 2)
+            return 'Cuts require recipe version 2';
+        if (recipe.mounting?.attachTo !== 'ceiling')
+            return 'Cuts need a ceiling-mounted design';
+    }
+    return null;
+}
+/** UTF-8 bytes of a recipe's compact JSON: what every inline size cap measures. */
+export function recipeBytes(recipe) {
+    return new TextEncoder().encode(JSON.stringify(recipe)).length;
+}
 export function parseRecipe(input) {
     guardTree(input);
     if (JSON.stringify(input).length > RECIPE_LIMITS.bytes)
         throw new Error('Recipe is too large');
     const recipe = RecipeSchema.parse(input);
+    if (usesPartTree(recipe))
+        validatePartTree(recipe);
     for (const list of [recipe.parameters, recipe.slots, recipe.parts]) {
         if (new Set(list.map((x) => x.id)).size !== list.length)
             throw new Error('IDs must be unique within each section');
@@ -130,22 +374,53 @@ export function parseRecipe(input) {
             throw new Error(`Invalid parameter ${p.id}`);
         if (p.unit === 'count' && ![p.min, p.max, p.default, p.step].every(Number.isInteger))
             throw new Error(`Count ${p.id} must be integral`);
+        if ((p.unit === 'bool' || p.unit === 'choice') &&
+            (p.min !== 0 ||
+                p.step !== 1 ||
+                p.axis ||
+                !Number.isInteger(p.default) ||
+                p.max !== (p.unit === 'bool' ? 1 : (p.options?.length ?? 0) - 1)))
+            throw new Error(`${p.unit === 'bool' ? 'Bool' : 'Choice'} ${p.id} must run 0..${p.unit === 'bool' ? 1 : 'options - 1'} in steps of 1 with no handle`);
+        if (p.options && p.unit !== 'choice')
+            throw new Error(`Only choice parameters have options (${p.id})`);
         if (p.part && !recipe.parts.some((part) => part.id === p.part))
             throw new Error(`Unknown part ${p.part}`);
     }
     for (const part of recipe.parts) {
         if (new Set(part.shapes.map((s) => s.id)).size !== part.shapes.length)
             throw new Error(`Duplicate shape in ${part.id}`);
-        for (const shape of part.shapes)
+        for (const shape of part.shapes) {
             if (!recipe.slots.some((s) => s.id === shape.slot))
                 throw new Error(`Unknown slot ${shape.slot}`);
+            const f = solidFields(shape);
+            if (f.topScale !== undefined && shape.primitive !== 'cylinder')
+                throw new Error(`topScale is only allowed on cylinders (${part.id}/${shape.id})`);
+            if ((shape.primitive === 'extrude' || shape.primitive === 'revolve') && shape.support)
+                throw new Error(`${shape.primitive} ${part.id}/${shape.id} cannot be a support surface`);
+            const cylinderOptions = [f.segments, f.open, f.inner, f.arc];
+            if (cylinderOptions.some((option) => option !== undefined)) {
+                if (shape.primitive !== 'cylinder' && shape.primitive !== 'revolve')
+                    throw new Error(`segments, open, inner and arc apply to cylinders (${part.id}/${shape.id})`);
+                if (shape.support && (f.inner !== undefined || f.arc !== undefined || f.open))
+                    throw new Error(`Support shape ${part.id}/${shape.id} cannot be hollow, open or partial`);
+            }
+            if (shape.support && partMoves(recipe, part.id))
+                throw new Error(`Moving part ${part.id} cannot contain support shapes`);
+            if (shape.primitive === 'ellipsoid' && shape.support)
+                throw new Error(`Ellipsoid ${part.id}/${shape.id} cannot be a support surface`);
+        }
     }
+    if (movingParts(recipe) > RECIPE_LIMITS.motionParts)
+        throw new Error(`Recipe exceeds ${RECIPE_LIMITS.motionParts} moving parts`);
     const surfaceIds = (recipe.surfaces ?? []).map((s) => s.id);
     if (new Set(surfaceIds).size !== surfaceIds.length)
         throw new Error('Duplicate surface ID');
-    for (const surface of recipe.surfaces ?? [])
+    for (const surface of recipe.surfaces ?? []) {
         if (surface.part && !recipe.parts.some((p) => p.id === surface.part))
             throw new Error('Unknown surface part');
+        if (surface.part && partMoves(recipe, surface.part))
+            throw new Error(`Named surface ${surface.id} cannot belong to moving part ${surface.part}`);
+    }
     if (recipe.mounting &&
         !(recipe.surfaces ?? []).some((s) => s.id === recipe.mounting.reference && !s.part))
         throw new Error('Mounting requires one named, non-repeated reference surface');
@@ -155,7 +430,197 @@ export function parseRecipe(input) {
     evaluateRecipe(recipe);
     return recipe;
 }
+function shapeCorners(size, position, rotation) {
+    const localMin = size.map((v) => -v / 2);
+    const localMax = size.map((v) => v / 2);
+    const shapeFrame = frame(position, rotation);
+    return boxCorners(localMin, localMax).map((point) => transformPoint(shapeFrame, point));
+}
+/** Axis-aligned bounds of one evaluated shape in the design frame. */
+export function shapeBounds(shape) {
+    if (shape.primitive !== 'ellipsoid')
+        return boundsOf(shapeCorners(shape.size, shape.position, shape.rotation));
+    const axes = [0, 1, 2].map((axis) => rotateVector([0, 1, 2].map((j) => (j === axis ? 1 : 0)), shape.rotation));
+    const extent = [0, 1, 2].map((k) => Math.hypot(...axes.map((axis, j) => (axis[k] * shape.size[j]) / 2)));
+    return boundsOf([
+        shape.position.map((v, k) => v - extent[k]),
+        shape.position.map((v, k) => v + extent[k]),
+    ]);
+}
+// Points whose hull contains the shape: a cylinder's rim vertices (as rendered), otherwise the
+// corners of its oriented box (exact for boxes, conservative for the rest).
+function shapeFootprint(shape) {
+    if (shape.primitive === 'revolve') {
+        // Each profile point's ring as rendered, along the arc.
+        const f = frame(shape.position, shape.rotation);
+        const n = shape.segments ?? 24, arc = shape.arc ?? 2 * Math.PI;
+        const steps = arc < 2 * Math.PI - 1e-9 ? n + 1 : n;
+        return shape.profile.flatMap(([r, y]) => Array.from({ length: steps }, (_, k) => {
+            const theta = (arc * k) / n;
+            return transformPoint(f, [r * Math.sin(theta), y, r * Math.cos(theta)]);
+        }));
+    }
+    if (shape.primitive !== 'cylinder')
+        return shapeCorners(shape.size, shape.position, shape.rotation);
+    const f = frame(shape.position, shape.rotation);
+    const n = shape.segments ?? 24, arc = shape.arc ?? 2 * Math.PI;
+    const partial = arc < 2 * Math.PI - 1e-9;
+    // Rim vertices as rendered, along the arc; a hollow arc adds its inner rim; a closed
+    // partial solid (wedge sides through the axis) adds the axis.
+    const rims = shape.inner === undefined ? [1] : [1, shape.inner];
+    return [-0.5, 0.5].flatMap((y) => {
+        const r = y > 0 ? 0.5 * shape.topScale : 0.5;
+        const points = rims.flatMap((scale) => Array.from({ length: partial ? n + 1 : n }, (_, k) => {
+            const theta = (arc * k) / n;
+            return transformPoint(f, [
+                scale * r * Math.sin(theta) * shape.size[0],
+                y * shape.size[1],
+                scale * r * Math.cos(theta) * shape.size[2],
+            ]);
+        }));
+        return partial && shape.inner === undefined && !shape.open
+            ? [...points, transformPoint(f, [0, y * shape.size[1], 0])]
+            : points;
+    });
+}
+/** Where a flat motion has carried its group at `fraction` of its travel. */
+function motionPose(motion, fraction) {
+    const axis = [0, 1, 2].map((k) => (['x', 'y', 'z'][k] === motion.axis ? 1 : 0));
+    if (motion.kind === 'slide')
+        return { r: IDENTITY_POSE.r, t: axis.map((v) => v * motion.amount * fraction) };
+    const angle = motion.kind === 'spin' ? 2 * Math.PI * fraction : motion.amount * fraction;
+    return hingePose(motion.pivot, axis, angle);
+}
+const LEGACY_TRIANGLE_CHARGE = { box: 12, roundedBox: 588, cylinder: 96, ellipsoid: 720 };
+/** A revolve that meets the axis at both ends over a full turn encloses a solid. */
+export function revolveIsClosed(shape) {
+    const profile = shape.profile;
+    return (profile[0][0] <= 1e-9 &&
+        profile.at(-1)[0] <= 1e-9 &&
+        (shape.arc === undefined || shape.arc >= 2 * Math.PI - 1e-9));
+}
+/** Triangles of the geometry the renderer builds for an evaluated shape (non-indexed). */
+export function shapeTriangles(shape) {
+    switch (shape.primitive) {
+        case 'box':
+            return 12;
+        case 'roundedBox':
+            return 300; // RoundedBoxGeometry(…, 2): a 5 × 5 grid on each face
+        case 'cylinder': {
+            // Per side: one torso triangle per nonzero radius, one cap triangle per nonzero radius
+            // (two for a tube's ring), plus two triangles per wedge side of a closed partial sweep.
+            const n = shape.segments ?? 24, ends = shape.topScale > 0 ? 2 : 1;
+            const wedges = shape.arc !== undefined && shape.arc < 2 * Math.PI - 1e-9 && !shape.open;
+            // A hollow wall draws its inner face; an open solid draws its back face instead, since
+            // materials are front-sided.
+            const walls = shape.inner !== undefined || shape.open ? 2 : 1;
+            const caps = shape.open ? 0 : (shape.inner === undefined ? 1 : 2) * n * ends;
+            return walls * n * ends + caps + (wedges ? 4 : 0);
+        }
+        case 'ellipsoid':
+            return 720; // SphereGeometry(…, 24, 16) without the degenerate pole triangles
+        case 'extrude':
+            return extrusionTriangles(sectionRings(shape.section), shape.bevel ? 2 : 0);
+        case 'revolve': {
+            // LatheGeometry: two per segment per profile edge; an open surface also draws its back.
+            const n = shape.segments ?? 24, profile = shape.profile;
+            return 2 * n * (profile.length - 1) * (revolveIsClosed(shape) ? 1 : 2);
+        }
+    }
+}
+/**
+ * Triangles a shape charges against the recipe budget: v1 keeps its original, conservative
+ * charges so its acceptance never changes; v2 charges what the renderer builds.
+ */
+export function triangleCharge(recipe, shape, built = shapeTriangles(shape)) {
+    return recipe.version === 1
+        ? LEGACY_TRIANGLE_CHARGE[shape.primitive]
+        : built;
+}
+function resolveSection(section, value) {
+    const length = (e, what) => {
+        const v = value(e);
+        if (!(v >= 0.001 && v <= RECIPE_LIMITS.dimension))
+            throw new Error(`Invalid section ${what}`);
+        return v;
+    };
+    switch (section.kind) {
+        case 'rectangle': {
+            const width = length(section.width, 'width'), depth = length(section.depth, 'depth');
+            const corner = section.corner === undefined ? 0 : value(section.corner);
+            if (!(corner >= 0 && corner <= Math.min(width, depth) / 2))
+                throw new Error('A section corner must be within 0..half its smaller side');
+            return corner
+                ? { kind: 'rectangle', width, depth, corner }
+                : { kind: 'rectangle', width, depth };
+        }
+        case 'round': {
+            const radius = length(section.radius, 'radius');
+            const wall = section.wall === undefined ? undefined : value(section.wall);
+            if (wall !== undefined && !(wall > 0 && wall < radius))
+                throw new Error('A round section wall must be within (0, radius)');
+            return wall === undefined ? { kind: 'round', radius } : { kind: 'round', radius, wall };
+        }
+        case 'oval':
+            return {
+                kind: 'oval',
+                width: length(section.width, 'width'),
+                depth: length(section.depth, 'depth'),
+            };
+        case 'section':
+            return {
+                kind: 'section',
+                family: section.family,
+                width: length(section.width, 'width'),
+                depth: length(section.depth, 'depth'),
+                web: length(section.web, 'web'),
+                flange: length(section.flange, 'flange'),
+            };
+        case 'polygon': {
+            const point = ([x, y]) => {
+                const p = [value(x), value(y)];
+                if (p.some((v) => Math.abs(v) > RECIPE_LIMITS.dimension))
+                    throw new Error('Invalid section point');
+                return p;
+            };
+            return {
+                kind: 'polygon',
+                outer: section.outer.map(point),
+                ...(section.holes && { holes: section.holes.map((hole) => hole.map(point)) }),
+            };
+        }
+    }
+}
 export function evaluateRecipe(recipe, values = {}) {
+    const issue = versionIssue(recipe);
+    if (issue)
+        throw new Error(issue);
+    const slotColors = new Map();
+    for (const part of recipe.parts) {
+        const light = part.light;
+        if (!light)
+            continue;
+        if (!/^#[0-9a-fA-F]{6}$/.test(light.color) ||
+            (light.intensity !== undefined &&
+                (!Number.isFinite(light.intensity) || light.intensity <= 0 || light.intensity > 10)) ||
+            (light.distance !== undefined &&
+                (!Number.isFinite(light.distance) || light.distance < 0.1 || light.distance > 10)))
+            throw new Error(`Invalid light for ${part.id}`);
+        if (!light.emissiveSlot)
+            continue;
+        if (!recipe.slots.some((slot) => slot.id === light.emissiveSlot))
+            throw new Error(`Unknown emissive slot ${light.emissiveSlot}`);
+        const previous = slotColors.get(light.emissiveSlot);
+        // v2 checks the lights it actually builds (below), so exclusive variants may differ.
+        if (recipe.version === 1 && previous && previous !== light.color.toLowerCase())
+            throw new Error(`Conflicting light colors on ${light.emissiveSlot}`);
+        slotColors.set(light.emissiveSlot, light.color.toLowerCase());
+    }
+    if (movingParts(recipe) > RECIPE_LIMITS.motionParts)
+        throw new Error(`Recipe exceeds ${RECIPE_LIMITS.motionParts} moving parts`);
+    for (const surface of recipe.surfaces ?? [])
+        if (surface.part && partMoves(recipe, surface.part))
+            throw new Error(`Named surface ${surface.id} cannot belong to moving part ${surface.part}`);
     const parameters = Object.create(null);
     for (const key of Object.keys(values))
         if (!recipe.parameters.some((p) => p.id === key))
@@ -165,7 +630,7 @@ export function evaluateRecipe(recipe, values = {}) {
         if (!Number.isFinite(v) ||
             v < p.min ||
             v > p.max ||
-            (p.unit === 'count' && !Number.isInteger(v)))
+            ((p.unit === 'count' || p.unit === 'bool' || p.unit === 'choice') && !Number.isInteger(v)))
             throw new Error(`${p.label} must be between ${p.min} and ${p.max}`);
         parameters[p.id] = v;
     }
@@ -182,6 +647,12 @@ export function evaluateRecipe(recipe, values = {}) {
                 throw new Error(`Unknown expression reference ${e}`);
             return parameters[e];
         }
+        if (e.op === 'select') {
+            const i = expr(e.args[0], index, depth + 1);
+            if (!Number.isInteger(i) || i < 0 || i >= e.args.length - 1)
+                throw new Error(`select index ${i} is outside 0..${e.args.length - 2}`);
+            return expr(e.args[i + 1], index, depth + 1);
+        }
         const a = e.args.map((x) => expr(x, index, depth + 1));
         let result;
         switch (e.op) {
@@ -209,6 +680,12 @@ export function evaluateRecipe(recipe, values = {}) {
             case 'abs':
                 result = Math.abs(a[0]);
                 break;
+            case 'sin':
+                result = Math.sin(a[0]);
+                break;
+            case 'cos':
+                result = Math.cos(a[0]);
+                break;
             case 'mod': {
                 const divisor = a[1];
                 if (divisor <= 0)
@@ -235,24 +712,200 @@ export function evaluateRecipe(recipe, values = {}) {
         if (c.relation === 'lte' ? a > b + 1e-8 : a < b - 1e-8)
             throw new Error(c.message);
     }
-    const shapes = [], surfaces = [];
+    // The datum that rests on the host: design y = 0, or a v2 floor design's declared base.
+    // v2 ceiling designs hang from their top reference; their host bounds them against the floor.
+    const base = recipe.version === 2 && recipe.base !== undefined ? expr(recipe.base) : 0;
+    const hangsFromCeiling = recipe.version === 2 && recipe.mounting?.attachTo === 'ceiling';
+    const shapes = [], motions = [], lights = [], surfaces = [];
+    const motionGroupByInstance = Object.create(null);
+    const motionSignatures = new Map();
     const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
-    let triangles = 0;
+    let triangles = 0, charged = 0;
+    const shapeLimit = recipe.version === 2 ? RECIPE_V2_LIMITS.shapes : RECIPE_LIMITS.shapes;
+    // Counts are settled before anything is expanded, so a huge count costs one expression.
+    const counts = new Map();
     for (const part of recipe.parts) {
         const count = expr(part.count);
         if (!Number.isInteger(count) || count < 0 || count > 64)
             throw new Error(`Invalid repeat count for ${part.label}`);
-        for (let i = 0; i < count; i++)
-            for (const s of part.shapes) {
-                if (shapes.length >= RECIPE_LIMITS.shapes)
+        counts.set(part.id, count);
+    }
+    const placements = recipe.version === 2 && usesPartTree(recipe) ? placeParts(recipe, expr, counts) : null;
+    const jointGroups = new Set();
+    // Part repeats that built geometry; only these carry the part's named surfaces.
+    const builtRepeats = new Set();
+    for (const part of recipe.parts) {
+        const count = counts.get(part.id);
+        for (let i = 0; i < count; i++) {
+            if (part.when !== undefined && expr(part.when, i) === 0)
+                continue;
+            const placement = placements?.get(`${part.id}:${i}`);
+            if (placements && !placement)
+                continue;
+            // A joint is kept even where `when` skips all its part's shapes, since its children
+            // still ride it; joints that end up carrying nothing are dropped after the loop.
+            if (placement?.motion) {
+                if (motions.length >= RECIPE_LIMITS.motionGroups)
+                    throw new Error(`Recipe exceeds ${RECIPE_LIMITS.motionGroups} evaluated motion groups`);
+                motions.push(placement.motion);
+                jointGroups.add(placement.motion.id);
+                motionGroupByInstance[`${part.id}:${i}`] = placement.motion.id;
+            }
+            const kept = part.shapes.filter((s) => s.when === undefined || expr(s.when, i) !== 0);
+            if (!kept.length)
+                continue;
+            builtRepeats.add(`${part.id}:${i}`);
+            // A part-tree pose re-expresses the part's frame in design space.
+            const pose = placement?.pose ?? IDENTITY_POSE;
+            const place = (position, rotation) => {
+                if (pose === IDENTITY_POSE)
+                    return { position, rotation };
+                const placed = composePoses(pose, eulerPose(position, rotation));
+                return { position: placed.t, rotation: matrixEuler(placed.r) };
+            };
+            const vec = (v) => v.map((x) => expr(x, i));
+            const instanceMin = [Infinity, Infinity, Infinity];
+            const instanceMax = [-Infinity, -Infinity, -Infinity];
+            let motionGroup = placement?.group;
+            if (part.motion) {
+                const motion = part.motion;
+                const pivot = motion.kind === 'slide' ? [0, 0, 0] : vec(motion.pivot);
+                const amount = expr(motion.kind === 'hinge'
+                    ? motion.angle
+                    : motion.kind === 'slide'
+                        ? motion.distance
+                        : motion.radiansPerSecond, i);
+                const limit = motion.kind === 'hinge' ? Math.PI : motion.kind === 'slide' ? 5 : 20;
+                if (Math.abs(amount) <= 0 || Math.abs(amount) > limit)
+                    throw new Error(`Invalid ${motion.kind} amount for ${part.id}: expected 0 < absolute value <= ${limit}`);
+                const rounded = (n) => Math.round(n * 1e6) / 1e6;
+                const delay = motion.kind === 'spin' ? 0 : expr(motion.delay ?? 0, i);
+                const duration = motion.kind === 'spin' ? 0 : expr(motion.duration ?? 0.45, i);
+                const easing = motion.kind === 'spin' ? 'linear' : (motion.easing ?? 'smooth');
+                if (!Number.isFinite(delay) ||
+                    !Number.isFinite(duration) ||
+                    delay < 0 ||
+                    delay > 1 ||
+                    !['linear', 'smooth', 'soft'].includes(easing) ||
+                    (motion.kind !== 'spin' && (duration < 0.1 || duration > 2)))
+                    throw new Error(`Invalid timing for ${part.id}`);
+                const signature = JSON.stringify([
+                    part.id,
+                    motion.kind,
+                    motion.axis,
+                    ...pivot.map(rounded),
+                    rounded(amount),
+                    delay,
+                    duration,
+                    easing,
+                ]);
+                // A part gated by `when` names groups by repeat index, so skipped repeats never
+                // renumber the survivors.
+                const gated = part.when !== undefined || part.shapes.some((shape) => shape.when !== undefined);
+                motionGroup = gated ? undefined : motionSignatures.get(signature);
+                if (!motionGroup) {
+                    if (motions.length >= RECIPE_LIMITS.motionGroups)
+                        throw new Error(`Recipe exceeds ${RECIPE_LIMITS.motionGroups} evaluated motion groups`);
+                    const ordinal = gated ? i : motions.filter((m) => m.partId === part.id).length;
+                    motionGroup = ordinal ? `${part.id}~${ordinal}` : part.id;
+                    motionSignatures.set(signature, motionGroup);
+                    motions.push({
+                        id: motionGroup,
+                        partId: part.id,
+                        kind: motion.kind,
+                        axis: motion.axis,
+                        pivot,
+                        amount,
+                        delay,
+                        duration,
+                        easing,
+                    });
+                }
+                motionGroupByInstance[`${part.id}:${i}`] = motionGroup;
+            }
+            for (const s of kept) {
+                if (shapes.length >= shapeLimit)
                     throw new Error('Expanded shape budget exceeded');
-                const vec = (v) => v.map((x) => expr(x, i));
-                const size = vec(s.size), position = vec(s.position), rotation = vec(s.rotation ?? [0, 0, 0]);
+                let position = vec(s.position);
+                let rotation = vec(s.rotation ?? [0, 0, 0]);
+                let size;
+                let extrusion = {};
+                if (s.primitive === 'revolve') {
+                    // Points that coincide with the previous one (a feature collapsed to zero) are dropped.
+                    const points = [];
+                    for (const [re, ye] of s.profile) {
+                        const [r, y] = [expr(re, i), expr(ye, i)];
+                        if (!(r >= 0 &&
+                            r <= RECIPE_LIMITS.dimension / 2 &&
+                            Math.abs(y) <= RECIPE_LIMITS.dimension))
+                            throw new Error(`Invalid revolve profile for ${part.id}/${s.id}`);
+                        const last = points.at(-1);
+                        if (!last || Math.hypot(r - last[0], y - last[1]) > 1e-6)
+                            points.push([r, y]);
+                    }
+                    if (points.length < 2)
+                        throw new Error(`Invalid revolve profile for ${part.id}/${s.id}`);
+                    const radius = Math.max(...points.map(([r]) => r));
+                    const low = Math.min(...points.map(([, y]) => y)), high = Math.max(...points.map(([, y]) => y));
+                    size = [2 * radius, high - low, 2 * radius];
+                    const middle = (low + high) / 2;
+                    position = position.map((v, k) => v + rotateVector([0, middle, 0], rotation)[k]);
+                    extrusion = { profile: points.map(([r, y]) => [r, y - middle]) };
+                    if (!(size[0] >= 0.001))
+                        throw new Error(`Revolve profile for ${part.id}/${s.id} needs a radius`);
+                }
+                else if (s.primitive === 'extrude') {
+                    const resolved = resolveSection(s.section, (e) => expr(e, i));
+                    const rings = sectionRings(resolved);
+                    const b = boundsOf(rings.outer.map(([x, y]) => [x, y, 0]));
+                    const center = b.min.map((v, k) => (v + b.max[k]) / 2);
+                    const length = expr(s.length, i);
+                    const bevel = s.bevel === undefined ? 0 : expr(s.bevel, i);
+                    // The bevel insets every contour, so it must stay under the section's thinnest wall.
+                    if (!(bevel >= 0 &&
+                        bevel <= Math.min(length / 4, 0.05) &&
+                        (bevel === 0 || bevel <= sectionThickness(rings) / 2.5 + 1e-9)))
+                        throw new Error(`bevel for ${part.id}/${s.id} must be within 0..min(length / 4, 5 cm, thinnest wall / 2.5)`);
+                    size = [b.dimensions[0], b.dimensions[1], length];
+                    // Evaluated shapes are centred in their box, so bounds and handles read them as boxes.
+                    position = position.map((v, k) => v + rotateVector(center, rotation)[k]);
+                    extrusion = {
+                        section: resolved.kind === 'polygon'
+                            ? {
+                                kind: 'polygon',
+                                outer: resolved.outer.map(([x, y]) => [x - center[0], y - center[1]]),
+                                ...(resolved.holes && {
+                                    holes: resolved.holes.map((hole) => hole.map(([x, y]) => [x - center[0], y - center[1]])),
+                                }),
+                            }
+                            : resolved,
+                        ...(bevel > 0 && { bevel }),
+                    };
+                }
+                else
+                    size = vec(s.size);
+                const f = solidFields(s);
                 if (size.some((x) => x < 0.001 || x > RECIPE_LIMITS.dimension))
                     throw new Error(`Invalid dimensions for ${part.id}/${s.id}`);
-                const radius = s.primitive === 'roundedBox' ? expr(s.radius ?? 0.02, i) : 0;
+                const radius = s.primitive === 'roundedBox' ? expr(f.radius ?? 0.02, i) : 0;
                 if (radius < 0 || radius > Math.min(...size) / 2)
                     throw new Error(`Invalid rounding for ${s.id}`);
+                if (f.topScale !== undefined && s.primitive !== 'cylinder')
+                    throw new Error(`topScale is only allowed on cylinders (${part.id}/${s.id})`);
+                const topScale = f.topScale === undefined ? 1 : expr(f.topScale, i);
+                if (topScale < 0 || topScale > 1)
+                    throw new Error(`topScale for ${part.id}/${s.id} must be within [0, 1]`);
+                if (s.support && (s.primitive === 'ellipsoid' || topScale < 1))
+                    throw new Error(`Support surface ${part.id}/${s.id} cannot be ellipsoid or tapered cylinder`);
+                if (s.support && motionGroup)
+                    throw new Error(`Moving part ${part.id} cannot contain support shapes`);
+                const inner = f.inner === undefined ? undefined : expr(f.inner, i);
+                if (inner !== undefined && !(inner > 0 && inner < 1))
+                    throw new Error(`inner for ${part.id}/${s.id} must be within (0, 1)`);
+                const arc = f.arc === undefined ? undefined : expr(f.arc, i);
+                if (arc !== undefined && !(arc > 0 && arc <= 2 * Math.PI + 1e-9))
+                    throw new Error(`arc for ${part.id}/${s.id} must be within (0, 2π]`);
+                ({ position, rotation } = place(position, rotation));
                 const shapeId = `${part.id}:${i}:${s.id}`;
                 shapes.push({
                     id: shapeId,
@@ -263,28 +916,29 @@ export function evaluateRecipe(recipe, values = {}) {
                     position,
                     rotation,
                     radius,
+                    topScale,
+                    ...(f.segments === undefined ? {} : { segments: f.segments }),
+                    ...(f.open ? { open: true } : {}),
+                    ...(inner === undefined ? {} : { inner }),
+                    ...(arc === undefined ? {} : { arc }),
+                    ...extrusion,
+                    motionGroup,
                 });
-                triangles += s.primitive === 'roundedBox' ? 588 : s.primitive === 'cylinder' ? 96 : 12;
-                if (triangles > RECIPE_LIMITS.triangles)
+                const built = shapeTriangles(shapes.at(-1));
+                triangles += built;
+                charged += triangleCharge(recipe, shapes.at(-1), built);
+                if (charged > RECIPE_LIMITS.triangles)
                     throw new Error('Triangle budget exceeded');
-                // XYZ Euler rotations match Three.js; bounding corners remain pure domain math.
-                for (const x of [-size[0] / 2, size[0] / 2])
-                    for (const y of [-size[1] / 2, size[1] / 2])
-                        for (const z of [-size[2] / 2, size[2] / 2]) {
-                            const [rx, ry, rz] = rotation;
-                            const x1 = x * Math.cos(rz) - y * Math.sin(rz), y1 = x * Math.sin(rz) + y * Math.cos(rz);
-                            const x2 = x1 * Math.cos(ry) + z * Math.sin(ry), z2 = -x1 * Math.sin(ry) + z * Math.cos(ry);
-                            const point = [
-                                x2 + position[0],
-                                y1 * Math.cos(rx) - z2 * Math.sin(rx) + position[1],
-                                y1 * Math.sin(rx) + z2 * Math.cos(rx) + position[2],
-                            ];
-                            for (let k = 0; k < 3; k++) {
-                                min[k] = Math.min(min[k], point[k]);
-                                max[k] = Math.max(max[k], point[k]);
-                            }
-                        }
+                const bounds = shapeBounds({ primitive: s.primitive, size, position, rotation });
+                for (let k = 0; k < 3; k++) {
+                    min[k] = Math.min(min[k], bounds.min[k]);
+                    max[k] = Math.max(max[k], bounds.max[k]);
+                    instanceMin[k] = Math.min(instanceMin[k], bounds.min[k]);
+                    instanceMax[k] = Math.max(instanceMax[k], bounds.max[k]);
+                }
                 if (s.support) {
+                    if (surfaces.length >= 256)
+                        throw new Error('Surface budget exceeded');
                     if (rotation.some((v) => v !== 0))
                         throw new Error('Support surfaces must be horizontal and unrotated in v1');
                     surfaces.push({
@@ -297,17 +951,63 @@ export function evaluateRecipe(recipe, values = {}) {
                     });
                 }
             }
+            // A repeat whose shapes `when` all skipped builds no light either.
+            if (part.light && instanceMin[0] !== Infinity) {
+                if (lights.length >= RECIPE_LIMITS.lights)
+                    throw new Error('Evaluated light budget exceeded');
+                const position = pose === IDENTITY_POSE
+                    ? vec(part.light.position)
+                    : posePoint(pose, vec(part.light.position));
+                if (position.some((value) => !Number.isFinite(value)))
+                    throw new Error(`Invalid light position for ${part.id}`);
+                if (position.some((value, axis) => value < instanceMin[axis] - 0.02 || value > instanceMax[axis] + 0.02))
+                    throw new Error(`Light for ${part.id}:${i} is outside its resting bounds`);
+                lights.push({
+                    id: `${part.id}:${i}`,
+                    partId: part.id,
+                    index: i,
+                    motionGroup,
+                    position,
+                    color: part.light.color,
+                    intensity: part.light.intensity ?? 2,
+                    distance: part.light.distance ?? 5,
+                    emissiveSlot: part.light.emissiveSlot,
+                });
+            }
+        }
+    }
+    if (jointGroups.size) {
+        const carrying = new Set();
+        for (let group of shapes.map((shape) => shape.motionGroup))
+            while (group && !carrying.has(group)) {
+                carrying.add(group);
+                group = motions.find((motion) => motion.id === group)?.parent;
+            }
+        for (let k = motions.length - 1; k >= 0; k--) {
+            const id = motions[k].id;
+            if (carrying.has(id))
+                continue;
+            motions.splice(k, 1);
+            jointGroups.delete(id);
+            for (const [instance, group] of Object.entries(motionGroupByInstance))
+                if (group === id)
+                    delete motionGroupByInstance[instance];
+        }
     }
     for (const surface of recipe.surfaces ?? []) {
         const part = recipe.parts.find((p) => p.id === surface.part);
-        const count = part ? expr(part.count) : 1;
+        const count = part ? counts.get(part.id) : 1;
         for (let i = 0; i < count; i++) {
+            if (part && !builtRepeats.has(`${part.id}:${i}`))
+                continue;
             if (surfaces.length >= 256)
                 throw new Error('Surface budget exceeded');
             const rotation = (surface.rotation ?? [0, 0, 0]).map((e) => expr(e, i));
             const size = surface.size.map((e) => expr(e, i));
             const position = surface.position.map((e) => expr(e, i));
-            if (size.some((v) => v < 0.001 || v > 30) || position.some((v) => Math.abs(v) > 30))
+            // Bounded where consumers read it: design space with the resting datum at y = 0.
+            if (size.some((v) => v < 0.001 || v > 30) ||
+                position.some((v, k) => Math.abs(k === 1 ? v - base : v) > 30))
                 throw new Error('Invalid surface region');
             surfaces.push({
                 id: part ? `${surface.id}:${i}` : surface.id,
@@ -319,6 +1019,9 @@ export function evaluateRecipe(recipe, values = {}) {
             });
         }
     }
+    const cuts = [];
+    // Recessed designs: whether a design-space [x, z] lies inside one of their cuts.
+    let insideCut = null;
     if (recipe.mounting) {
         const reference = surfaces.find((s) => s.id === recipe.mounting.reference);
         if (!reference || reference.id.includes(':'))
@@ -326,20 +1029,189 @@ export function evaluateRecipe(recipe, values = {}) {
         if (recipe.mounting.attachTo === 'ceiling') {
             if (Math.abs(reference.normal[1] - 1) > 1e-6)
                 throw new Error('Ceiling mounting reference must face local +Y');
-            if (Math.abs(reference.position[1] - max[1]) > 1e-6)
+            const recessed = recipe.version === 2 && recipe.cuts !== undefined;
+            if (recessed
+                ? reference.position[1] > max[1] + 1e-6
+                : Math.abs(reference.position[1] - max[1]) > 1e-6)
                 throw new Error('Ceiling mounting reference must lie at the top of the design');
+            if (recessed) {
+                const u = rotateVector([1, 0, 0], reference.rotation), v = rotateVector([0, 0, 1], reference.rotation);
+                const inside = [];
+                for (const c of recipe.cuts) {
+                    const [cu, cv] = (c.center ?? [0, 0]).map((e) => expr(e));
+                    const cx = reference.position[0] + u[0] * cu + v[0] * cv, cz = reference.position[2] + u[2] * cu + v[2] * cv;
+                    const half = c.shape === 'rect'
+                        ? c.size.map((e) => expr(e) / 2)
+                        : [expr(c.diameter) / 2, expr(c.diameter) / 2];
+                    if (half.some((h) => !(h >= 0.005 && h <= 15)))
+                        throw new Error('Invalid cut size');
+                    const local = c.shape === 'rect'
+                        ? [
+                            [-half[0], -half[1]],
+                            [half[0], -half[1]],
+                            [half[0], half[1]],
+                            [-half[0], half[1]],
+                        ]
+                        : Array.from({ length: 32 }, (_, k) => [
+                            half[0] * Math.cos((k * Math.PI) / 16),
+                            half[0] * Math.sin((k * Math.PI) / 16),
+                        ]);
+                    cuts.push({
+                        host: 'ceiling',
+                        ring: local.map(([a, b]) => [cx + u[0] * a + v[0] * b, cz + u[2] * a + v[2] * b]),
+                    });
+                    inside.push((x, z) => {
+                        const a = (x - cx) * u[0] + (z - cz) * u[2], b = (x - cx) * v[0] + (z - cz) * v[2];
+                        return c.shape === 'rect'
+                            ? Math.abs(a) <= half[0] + 1e-6 && Math.abs(b) <= half[1] + 1e-6
+                            : Math.hypot(a, b) <= half[0] + 1e-6;
+                    });
+                }
+                for (const shape of shapes) {
+                    if (shapeBounds(shape).max[1] <= reference.position[1] + 1e-6)
+                        continue;
+                    const footprint = shapeFootprint(shape);
+                    if (!inside.some((test) => footprint.every(([x, , z]) => test(x, z))))
+                        throw new Error(`${shape.partId} rises above the ceiling reference outside its cut`);
+                }
+                insideCut = (x, z) => inside.some((test) => test(x, z));
+            }
         }
         else if (Math.abs(reference.normal[2] + 1) > 1e-6)
             throw new Error('Wall-side mounting reference must face local -Z');
     }
+    const reference = recipe.mounting && surfaces.find((s) => s.id === recipe.mounting.reference);
+    const reach = insideCut ? { min: [...min], max: [...max] } : undefined;
+    for (const { motion, bounds } of jointReach(motions.filter((m) => jointGroups.has(m.id)), shapes, shapeBounds)) {
+        if (reach)
+            for (let k = 0; k < 3; k++) {
+                reach.min[k] = Math.min(reach.min[k], bounds.min[k]);
+                reach.max[k] = Math.max(reach.max[k], bounds.max[k]);
+            }
+        if (!recipe.mounting && bounds.min[1] < base - 0.001)
+            throw new Error(`Motion envelope for ${motion.partId} extends below the floor`);
+        if (recipe.mounting?.attachTo === 'wall-side' &&
+            reference &&
+            bounds.min[2] < reference.position[2] - 0.001)
+            throw new Error(`Motion envelope for ${motion.partId} crosses behind the wall reference`);
+        if (recipe.mounting?.attachTo === 'ceiling' &&
+            reference &&
+            bounds.max[1] > reference.position[1] + 0.001 &&
+            !boxCorners(bounds.min, bounds.max).every(([x, , z]) => insideCut?.(x, z)))
+            throw new Error(`Motion envelope for ${motion.partId} rises above the ceiling reference`);
+    }
+    for (const motion of motions) {
+        if (jointGroups.has(motion.id))
+            continue;
+        const steps = motion.kind === 'slide' ? 1 : motion.kind === 'hinge' ? 8 : 16;
+        const poses = Array.from({ length: steps + 1 }, (_, step) => motionPose(motion, step / steps));
+        for (const shape of shapes) {
+            if (shape.motionGroup !== motion.id)
+                continue;
+            // Inside a cut, sample the rendered footprint so round parts may turn in round cuts.
+            const points = insideCut
+                ? shapeFootprint(shape)
+                : shapeCorners(shape.size, shape.position, shape.rotation);
+            for (const corner of points)
+                for (const { r, t } of poses) {
+                    const [x, y, z] = corner;
+                    const point = [
+                        r[0] * x + r[1] * y + r[2] * z + t[0],
+                        r[3] * x + r[4] * y + r[5] * z + t[1],
+                        r[6] * x + r[7] * y + r[8] * z + t[2],
+                    ];
+                    if (reach)
+                        for (let k = 0; k < 3; k++) {
+                            reach.min[k] = Math.min(reach.min[k], point[k]);
+                            reach.max[k] = Math.max(reach.max[k], point[k]);
+                        }
+                    if (!recipe.mounting && point[1] < base - 0.001)
+                        throw new Error(`Motion envelope for ${shape.partId} extends below the floor`);
+                    if (recipe.mounting?.attachTo === 'wall-side' &&
+                        reference &&
+                        point[2] < reference.position[2] - 0.001)
+                        throw new Error(`Motion envelope for ${shape.partId} crosses behind the wall reference`);
+                    if (recipe.mounting?.attachTo === 'ceiling' &&
+                        reference &&
+                        point[1] > reference.position[1] + 0.001 &&
+                        !insideCut?.(point[0], point[2]))
+                        throw new Error(`Motion envelope for ${shape.partId} rises above the ceiling reference`);
+                }
+        }
+    }
     if (!shapes.length)
         throw new Error('The item must contain geometry');
+    const emitted = new Map();
+    for (const light of lights) {
+        if (!light.emissiveSlot)
+            continue;
+        const previous = emitted.get(light.emissiveSlot);
+        if (previous && previous !== light.color.toLowerCase())
+            throw new Error(`Conflicting light colors on ${light.emissiveSlot}`);
+        emitted.set(light.emissiveSlot, light.color.toLowerCase());
+    }
+    if (base !== 0) {
+        // Consumers keep reading design space with the resting datum at y = 0.
+        const lower = (point) => [point[0], point[1] - base, point[2]];
+        for (const shape of shapes)
+            shape.position = lower(shape.position);
+        for (const light of lights)
+            light.position = lower(light.position);
+        for (const surface of surfaces)
+            surface.position = lower(surface.position);
+        // A slide's pivot is the origin of its group, not a point of the design.
+        for (const motion of motions)
+            if (motion.kind !== 'slide')
+                motion.pivot = lower(motion.pivot);
+        min[1] -= base;
+        max[1] -= base;
+    }
     const dimensions = max.map((x, i) => x - min[i]);
     if (dimensions.some((x) => x > 30) || [...min, ...max].some((x) => Math.abs(x) > 30))
         throw new Error('Item exceeds 30 m bounds');
-    if (min[1] < -0.001)
-        throw new Error('Geometry extends below the ground; base must be at y=0');
-    return { shapes, surfaces, min, max, dimensions, parameters, triangles };
+    if (!hangsFromCeiling && min[1] < -0.001)
+        throw new Error(recipe.base === undefined
+            ? 'Geometry extends below the ground; base must be at y=0'
+            : 'Geometry extends below the declared base');
+    return {
+        shapes,
+        motions,
+        lights,
+        motionGroupByInstance,
+        surfaces,
+        cuts,
+        min,
+        max,
+        dimensions,
+        parameters,
+        triangles,
+        ...(reach && motions.length > 0 && { reach }),
+    };
+}
+export const EASINGS = {
+    linear: (u) => u,
+    smooth: (u) => 3 * u * u - 2 * u * u * u,
+    soft: (u) => 6 * u ** 5 - 15 * u ** 4 + 10 * u ** 3,
+};
+export function finitePoseFraction(motion, time) {
+    const u = Math.max(0, Math.min(1, (time - motion.delay) / motion.duration));
+    return EASINGS[motion.easing](u);
+}
+export function motionTimeline(evaluation) {
+    const perPart = Object.create(null);
+    let T = 0;
+    for (const motion of evaluation.motions) {
+        if (motion.kind === 'spin')
+            continue;
+        const end = motion.delay + motion.duration;
+        T = Math.max(T, end);
+        const part = perPart[motion.partId];
+        perPart[motion.partId] = {
+            A: Math.min(part?.A ?? Infinity, motion.delay),
+            B: Math.max(part?.B ?? 0, end),
+        };
+    }
+    return { T, perPart };
 }
 export function sweepRecipe(recipe) {
     const cases = [{}];