@hatiolab/figure-model 0.1.76 → 0.1.78

package/dist/v3-from-v2.js

@@ -1,2053 +0,0 @@
-/*
- * Copyright © HatioLab Inc. All rights reserved.
- */
-/*
- * V2 → V3 converter (ADR-0087 decisions 1 and 2).
- *
- * A V2 source describes each part by an authored box and a per-axis rule that says how the part
- * follows the instance size: `scale`, `fixed`/`min`/`max`/`center`, `span`, `aspect-*`, and `repeat`.
- * Every one of those rules is a first-degree expression in the instance size (`src/sizing.ts`), so the
- * same placement can be written as a V3 graph of `add@1`, `mul@1`, `div@1` and `fit-pitch@1` nodes.
- * That is what this file does. It reproduces V2 behaviour; it does not improve the asset.
- *
- * What it cannot express, it refuses by name (ADR-0087 decision 2: no silent flattening):
- *   - a hollow polygon (V3 has hollow boxes only), a polygon whose path does not fill its declared size
- *   - a part rotated off the axes whose size still follows the instance (V2 shears it; V3 placement is rigid,
- *     ruling 1: those parts are re-authored, not converted)
- *   - a scale channel (a state input moving a dimension), until the shape-dimension contract §2 is implemented
- *   - joints and parameters, until `docs/v3-motion-contract.md` is implemented
- *
- * What it normalises on purpose it lists in `notes` with the value before and after: a corner radius V2 clamped
- * when drawing, a polygon path recentred with its placement moved by the same amount, the palette it snapshotted.
- * What it converts but does not carry, it lists in `lost`. Nothing is dropped without being named in one of the two.
- *
- * `compareV2WithV3` is the definition of "the same" from ADR-0087 decision 2: same part list, each
- * part's centre, world extents and rotation within tolerance, same material, at the base size and at
- * every combination of doubled axes.
- */
-import { defaultInstanceSizeRange, foldInstanceSizeRange, V3_SIZE_POSITIVE_STEP } from "./v3-instance-size.js";
-import { compileV3Asset } from "./v3-asset.js";
-import { v3WorldBoxesOf, v3WritersOf } from "./v3-gate.js";
-import { V3ContractError } from "./v3-contract.js";
-import { validate } from "./validate.js";
-import { centredPart } from "./origin.js";
-import { rotatedExtentOf } from "./blueprint.js";
-import { anchorOf, clearance, longAxis, repeatOffset, repeatPlan, sizingPosition, sizingScale } from "./sizing.js";
-import { AXES, REPEAT_LIMIT, SEGMENT_PRESETS } from "./types.js";
-import { driverValue } from "./v3-driver.js";
-import { hausdorff, scalePoints, transformPoints, v2BodyPoints } from "./v3-mesh-compare.js";
-import { jointOriginPosition } from "./sizing.js";
-/** A short stable fingerprint of the palette, so a report can say which colours it snapshotted. */
-export function paletteHash(palette) {
-    const text = JSON.stringify(Object.entries(palette).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
-    let h = 5381;
-    for (let i = 0; i < text.length; i++)
-        h = ((h * 33) ^ text.charCodeAt(i)) >>> 0;
-    return h.toString(16).padStart(8, '0');
-}
-/** The V3 design inputs that stand for the instance size, in mm. */
-export const V3_SIZE_INPUTS = Object.freeze({ x: 'size.x', y: 'size.y', z: 'size.z' });
-/** Above this many state inputs the corners are not enumerated for the declared volume; the resting pose stands. */
-const OCCUPANCY_STATE_CAP = 10;
-const ONE = { kind: 'one' };
-const SEG_DEFAULT = 12;
-const RIGHT_ANGLE_TOLERANCE = 1e-9;
-/** Builds the V3 graph value by value. Constants are shared by value; node ids stay readable. */
-class GraphBuilder {
-    graph = { version: 'r3-spatial-1', inputs: [], constants: [], nodes: [] };
-    ids = new Set();
-    constants = new Map();
-    claim(id, path) {
-        if (this.ids.has(id))
-            throw new V3ContractError('DUPLICATE_WRITER', path, `${id} already exists`);
-        this.ids.add(id);
-        return id;
-    }
-    input(id, unit, min, max, role) {
-        this.graph.inputs.push({ id: this.claim(id, 'input'), unit, min, max, role });
-        return id;
-    }
-    constant(raw, unit, hint) {
-        const value = raw === 0 ? 0 : raw; // -0 would not survive JSON
-        const key = `${unit}:${value}`;
-        const known = this.constants.get(key);
-        if (known)
-            return known;
-        let id = `k.${hint}`;
-        for (let n = 2; this.ids.has(id); n++)
-            id = `k.${hint}.${n}`;
-        this.claim(id, 'constant');
-        this.graph.constants.push({ id, unit, value });
-        this.constants.set(key, id);
-        return id;
-    }
-    node(id, op, args, port, params) {
-        const out = `${id}.value`;
-        const node = { id: this.claim(id, 'node'), op, args, outputs: { [port]: this.claim(out, id) } };
-        if (params)
-            node.params = params;
-        this.graph.nodes.push(node);
-        return out;
-    }
-    add(id, a, b) {
-        return this.node(id, 'add@1', [a, b], 'value');
-    }
-    mul(id, a, b) {
-        return this.node(id, 'mul@1', [a, b], 'value');
-    }
-    div(id, a, b) {
-        return this.node(id, 'div@1', [a, b], 'value');
-    }
-    /** A length as a graph reference: constants become shared constant entries. */
-    len(v, hint) {
-        return v.kind === 'ref' ? v.ref : this.constant(v.value, 'mm', hint);
-    }
-}
-function round6(v) {
-    return Math.round(v * 1e6) / 1e6;
-}
-function isRightAngle(deg) {
-    const turns = deg / 90;
-    return Math.abs(turns - Math.round(turns)) < RIGHT_ANGLE_TOLERANCE;
-}
-/** Rx·Ry·Rz for degrees, the order V2 (`three` 'XYZ') and V3 `rigid@1` share. */
-export function eulerXYZ(rotation) {
-    const rad = Math.PI / 180;
-    const cx = Math.cos((rotation?.x ?? 0) * rad), sx = Math.sin((rotation?.x ?? 0) * rad);
-    const cy = Math.cos((rotation?.y ?? 0) * rad), sy = Math.sin((rotation?.y ?? 0) * rad);
-    const cz = Math.cos((rotation?.z ?? 0) * rad), sz = Math.sin((rotation?.z ?? 0) * rad);
-    return [
-        [cy * cz, -cy * sz, sy],
-        [sx * sy * cz + cx * sz, -sx * sy * sz + cx * cz, -sx * cy],
-        [-cx * sy * cz + sx * sz, cx * sy * sz + sx * cz, cx * cy]
-    ];
-}
-/**
- * Which world axis each local axis lies nearest to, for any rotation; null when two local axes claim one world axis
- * (a 45° turn). Used only when re-authoring a rotated part without shear.
- */
-function nearestAxisPermutation(rotation) {
-    const r = eulerXYZ(rotation);
-    const out = {};
-    const taken = new Set();
-    for (const [i, local] of AXES.entries()) {
-        let best = 'x', size = -1;
-        for (const [a, world] of AXES.entries()) {
-            const v = Math.abs(r[a][i]);
-            if (v > size)
-                (size = v), (best = world);
-        }
-        if (taken.has(best))
-            return null;
-        taken.add(best);
-        out[local] = best;
-    }
-    return out;
-}
-/**
- * Does scaling per world axis commute with this rotation?
- *
- * V2 bakes the rotation into the mesh and then scales it per world axis: the drawn body is `S·R·v`. A rigid V3
- * part scales its own dimensions and then rotates: `R·S·v`. Those are the same body exactly when `S` and `R`
- * commute, and diag(f) commutes with R when every pair of axes the rotation mixes carries the same factor.
- *
- * This is not a corner case. ROLL_CRADLE's pads are turned 41° about X and follow the instance on Y and Z with
- * the same factor (`anchor: y scale, z aspect-y`), so V2 never sheared them — it scaled them uniformly inside
- * the plane the rotation turns in. Such a part converts exactly, with each local dimension taking its own axis's
- * factor, and needs no re-authoring.
- */
-function scalingCommutesWithRotation(rotation, same) {
-    const R = eulerXYZ(rotation);
-    for (const [i, a] of AXES.entries())
-        for (const [j, b] of AXES.entries()) {
-            if (i === j)
-                continue;
-            if (Math.abs(R[i][j]) > MIXING_TOLERANCE && !same(a, b))
-                return false;
-        }
-    return true;
-}
-/** Below this, a rotation does not mix two axes enough to tell a shear from a uniform scale at figure sizes. */
-const MIXING_TOLERANCE = 1e-9;
-/** Which world axis each local axis lands on, when the rotation is a multiple of 90° on every axis. */
-function axisPermutation(rotation) {
-    if (!AXES.every(a => isRightAngle(rotation?.[a] ?? 0)))
-        return null;
-    const r = eulerXYZ(rotation);
-    const out = {};
-    for (const [i, local] of AXES.entries()) {
-        const world = AXES.find((_, a) => Math.abs(r[a][i]) > 0.5);
-        if (!world)
-            return null;
-        out[local] = world;
-    }
-    return out;
-}
-function materialOf(part, palette) {
-    const m = part.material ?? {};
-    const known = ['token', 'preset', 'transparent', 'emissive'];
-    const extra = Object.keys(m).filter(k => !known.includes(k));
-    if (extra.length)
-        return { refusal: { code: 'MATERIAL_FIELD', part: part.name, detail: `V3 material has no ${extra.join(', ')}` } };
-    if (!m.token)
-        return { refusal: { code: 'MATERIAL_TOKEN', part: part.name, detail: 'material has no palette token' } };
-    if (!Object.hasOwn(palette, m.token))
-        return { refusal: { code: 'PALETTE_TOKEN', part: part.name, detail: `no colour for ${m.token}` } };
-    const material = { token: m.token };
-    if (m.preset !== undefined)
-        material.preset = m.preset;
-    if (m.transparent !== undefined)
-        material.transparent = m.transparent;
-    if (m.emissive) {
-        const token = m.emissive.token ?? m.token;
-        if (!Object.hasOwn(palette, token))
-            return { refusal: { code: 'PALETTE_TOKEN', part: part.name, detail: `no colour for emissive ${token}` } };
-        // V2 reads a missing `on` as off (`keys.ts`); V3 wants it written down.
-        material.emissive = { token, intensity: m.emissive.intensity, on: m.emissive.on ?? false };
-    }
-    return { material };
-}
-/**
- * Convert one validated V2 source to a V3 asset that places every part where V2 places it, at every
- * instance size in the input range. See the file comment for what is refused and what is listed as lost.
- */
-export function convertV2ToV3(source, options) {
-    const lost = [];
-    const refusals = [];
-    const notes = [];
-    const rangeChanges = [];
-    let method = 'mechanical';
-    const checked = validate(source);
-    if (checked.errors.length) {
-        return {
-            status: 'refused',
-            refusals: checked.errors.map(e => ({ code: 'V2_INVALID', part: e.path, detail: `${e.code}: ${e.message}` })),
-            lost,
-            rangeChanges,
-            notes
-        };
-    }
-    const src = source;
-    const base = src.base;
-    const palette = options.palette;
-    notes.push({ code: 'PALETTE', detail: `colours snapshotted from palette ${options.paletteId ?? `#${paletteHash(palette)}`}` });
-    /*
-      Not a loss (chief architect's ruling, 2026-09-24): in V2 the grade only capped the part count. V3 measures the
-      same budget as triangles, draw calls and how many fit on one screen (`v3CostOf`), so the grade is replaced, not
-      carried. A V3 proposer must not ask for it either.
-    */
-    /* Carried (user, 2026-09-24): the detail level budgets the part count before a part is added. */
-    if (src.styleKit)
-        lost.push({ code: 'STYLE_KIT', detail: `styleKit "${src.styleKit}" has no V3 field` });
-    /*
-      A figure with joints is a mechanism, and a mechanism does not shear: it should grow by one ratio (chief architect's
-      ruling 2026-09-24). The converter proposes that and does not apply it -- `sizing: 'uniform'` is the author's to
-      declare, with `scale-uniformly`, after looking at what the figure does at another size.
-    */
-    if (Array.isArray(src.joints) && src.joints.length)
-        notes.push({ code: 'UNIFORM_SIZING_PROPOSED', detail: `${src.joints.length} joint(s): a mechanism should grow by one ratio -- declare it with scale-uniformly` });
-    const g = new GraphBuilder();
-    const asset = {
-        version: 'figure-v3-asset-1',
-        name: options.name ?? src.type,
-        document: {
-            version: 'figure-v3-prototype-1',
-            model: g.graph,
-            capabilities: {
-                version: 'r3-capability-3',
-                assetFrame: 'asset',
-                bindings: [],
-                // ADR-0051 ④: the names travel; V3 checks them against the same list V2 did.
-                ...(src.capabilities?.length ? { names: [...src.capabilities] } : {})
-            }
-        },
-        designInputs: {},
-        stateDefaults: {},
-        palette: {},
-        appearance: [],
-        // ADR-0044 · ADR-0045: the V2 base box and placement become the declared volume, written as the reach on
-        // each side of the origin (designer's ruling 2026-09-23). V2 read a missing placement as floor.
-        occupancy: { bounds: null, placement: src.placement ?? 'floor' },
-        ...(src.detailLevel ? { detailLevel: src.detailLevel } : {})
-    };
-    // Instance size inputs. The range starts at the pitch on a spreading repeat axis (V2 draws at least one
-    // copy below that; `fit-pitch@1` draws none) and stops where V2 would silently clamp the copy count.
-    // A spanned part fills the room between its two gaps. Below that room V2 draws a 0.001 mm sliver (`sizing.ts`
-    // SLIVER); V3 refuses a non-positive dimension, so the minimum is the room plus the numerical step above zero.
-    // Shrinking the accepted range is a behaviour change and is recorded as one (designer's ruling 2). The edges are
-    // read off the V2 parts here; turning them into a range is `foldInstanceSizeRange`, which the authoring command
-    // `declare-instance-size` calls too (chief architect's ruling 2026-09-24).
-    const parts = src.parts.map(p => centredPart(p, base));
-    const limits = [];
-    for (const cp of parts) {
-        if (cp.sizing !== 'repeat' || !cp.repeat)
-            continue;
-        const axis = cp.repeat.axis;
-        if (anchorOf(withSizing(cp), base, axis) === 'scale')
-            continue;
-        limits.push({ axis, part: cp.name, kind: 'repeat', pitch: cp.repeat.pitch, cap: REPEAT_LIMIT * cp.repeat.pitch });
-    }
-    for (const cp of parts) {
-        const subject = withSizing(cp);
-        for (const a of AXES) {
-            if (anchorOf(subject, base, a) !== 'span')
-                continue;
-            const gaps = clearance(subject, base, a);
-            limits.push({ axis: a, part: cp.name, kind: 'span', room: gaps.min + gaps.max });
-        }
-    }
-    const folded = foldInstanceSizeRange(defaultInstanceSizeRange(base), limits);
-    for (const move of folded.moves) {
-        const limit = move.limit;
-        if (limit.kind === 'repeat') {
-            rangeChanges.push({
-                input: V3_SIZE_INPUTS[limit.axis],
-                part: limit.part,
-                v2: `any size; above ${limit.cap} mm V2 stopped adding copies at ${REPEAT_LIMIT} and drew the rest as a shorter row`,
-                v3: { min: move.range.min, max: limit.cap },
-                reason: `V3 refuses a size whose repeat count would exceed ${REPEAT_LIMIT} (fit-pitch@1 RESOURCE_LIMIT) instead of clamping the count`
-            });
-        }
-        else if (limit.kind === 'span') {
-            rangeChanges.push({
-                input: V3_SIZE_INPUTS[limit.axis],
-                part: limit.part,
-                v2: `any size; at or below ${round6(limit.room)} mm the spanned part was drawn as a 0.001 mm sliver`,
-                v3: { min: move.range.min, max: move.range.max },
-                reason: `the spanned part must keep a positive length (${V3_SIZE_POSITIVE_STEP} mm is the numerical step above zero, not a minimum part size)`
-            });
-        }
-    }
-    const sizeMin = { x: folded.range.x.min, y: folded.range.y.min, z: folded.range.z.min };
-    const sizeMax = { x: folded.range.x.max, y: folded.range.y.max, z: folded.range.z.max };
-    const size = {};
-    for (const a of AXES) {
-        size[a] = g.input(V3_SIZE_INPUTS[a], 'mm', sizeMin[a], sizeMax[a], 'design');
-        asset.designInputs[V3_SIZE_INPUTS[a]] = base[a];
-    }
-    const ratio = (v, hint) => g.constant(round6(v), 'ratio', hint);
-    const scaleFactor = new Map();
-    const factorOfScale = (a) => {
-        let f = scaleFactor.get(a);
-        if (!f) {
-            f = { kind: 'ref', ref: g.div(`scale.${a}`, size[a], g.constant(base[a], 'mm', `base.${a}`)), sig: `scale.${a}` };
-            scaleFactor.set(a, f);
-        }
-        return f;
-    };
-    const times = (id, v, f) => {
-        if (f.kind === 'one')
-            return v;
-        if (v.kind === 'const' && v.value === 0)
-            return v;
-        return { kind: 'ref', ref: g.mul(id, g.len(v, id), f.ref) };
-    };
-    const plans = [];
-    const seen = new Set();
-    // Motion (docs/v3-motion-contract.md), planned after the parts and read when the part nodes are written.
-    const info = new Map();
-    const spinOf = new Map();
-    const shiftsOf = new Map();
-    // A scale channel: per local axis, a ratio the part's dimensions are multiplied by (contract §2: dims × affine(p)).
-    const scaleOf = new Map();
-    /** part name → the flag value saying whether it is shown. Written by a channel that V2 spelled as scale 0. */
-    const visibilityOf = new Map();
-    /** Per part and axis: how far a state channel stretches or shrinks it, from the channel's own keys. */
-    const scaleRangeOf = new Map();
-    /** Per part: where it sits, how big it is, and whether it moves on its own. Read when the volume is declared. */
-    const reachOf = new Map();
-    /** Per joint: the three length values of its origin, and the joint above it. */
-    const jointOriginOf = new Map();
-    const frameOf = new Map(); // part → the joint whose frame carries it
-    const motionOf = new Map(); // joint → pose asset.rest → asset
-    const partsByName = new Map(parts.map(cp => [cp.name, cp]));
-    const jointByChild = new Map((src.joints ?? []).map(j => [j.child, j]));
-    const carrierJointOf = (name) => {
-        for (let p = partsByName.get(name); p; p = p.parent ? partsByName.get(p.parent) : undefined) {
-            const j = jointByChild.get(p.name);
-            if (j)
-                return j.name;
-        }
-        return undefined;
-    };
-    for (const cp of parts) {
-        const carrier = carrierJointOf(cp.name);
-        if (carrier)
-            frameOf.set(cp.name, carrier);
-    }
-    for (const cp of parts) {
-        const name = cp.name;
-        if (!/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(name)) {
-            refusals.push({ code: 'PART_ID', part: name, detail: 'V3 ids start with a letter and use letters, digits, _ . -' });
-            continue;
-        }
-        if (seen.has(name)) {
-            refusals.push({ code: 'PART_ID', part: name, detail: 'duplicate part name' });
-            continue;
-        }
-        seen.add(name);
-        if (cp.parent && !frameOf.has(name))
-            lost.push({ code: 'PARENT', part: name, detail: `attached to "${cp.parent}" with no joint above it; V3 places it in the asset frame, where it already was at rest` });
-        if (cp.label)
-            lost.push({ code: 'LABEL', part: name, detail: 'label has no V3 field' });
-        if (cp.materialSlot)
-            lost.push({ code: 'MATERIAL_SLOT', part: name, detail: 'materialSlot has no V3 field' });
-        if (cp.capability)
-            lost.push({ code: 'PART_CAPABILITY', part: name, detail: 'a capability anchor: V2 never draws it; its slot/port role is not carried as a V3 binding yet, so it is placed nowhere' });
-        const { material, refusal } = materialOf(cp, palette);
-        if (refusal) {
-            refusals.push(refusal);
-            continue;
-        }
-        for (const token of [material.token, material.emissive?.token])
-            if (token)
-                asset.palette[token] = palette[token];
-        if (cp.primitive === 'wall')
-            lost.push({ code: 'WALL_KIND', part: name, detail: 'drawn as a box; the "wall" kind has no V3 field' });
-        const hollow = cp.shape?.hollow && cp.shape.hollow.wall > 0 ? cp.shape.hollow : null;
-        if (hollow && cp.primitive !== 'rect') {
-            refusals.push({ code: 'NO_PROVIDER', part: name, detail: `V3 has no hollow ${cp.primitive}` });
-            continue;
-        }
-        // A polygon's path is drawn as written, so its bounding box may sit off the part centre. V3 keeps the visible
-        // position: the path is recentred and the placement moves by the same amount (ADR-0087 ruling 3).
-        let path = cp.primitive === 'polygon' ? cp.shape?.path ?? [] : [];
-        const recentre = { x: 0, z: 0 };
-        if (cp.primitive === 'polygon') {
-            const xs = path.map(q => q.x), zs = path.map(q => q.y);
-            const spanX = Math.max(...xs) - Math.min(...xs), spanZ = Math.max(...zs) - Math.min(...zs);
-            if (path.length < 3 || Math.abs(spanX - cp.transform.size.x) > 1e-6 || Math.abs(spanZ - cp.transform.size.z) > 1e-6) {
-                // V2 sizing reads `size` while the drawing reads the path; when they disagree there is no one truth to keep.
-                refusals.push({
-                    code: 'POLYGON_SIZE_MISMATCH',
-                    part: name,
-                    detail: `path spans ${spanX}×${spanZ}; size says ${cp.transform.size.x}×${cp.transform.size.z}`
-                });
-                continue;
-            }
-            recentre.x = round6((Math.max(...xs) + Math.min(...xs)) / 2);
-            recentre.z = round6((Math.max(...zs) + Math.min(...zs)) / 2);
-            if (recentre.x !== 0 || recentre.z !== 0) {
-                path = path.map(q => ({ x: round6(q.x - recentre.x), y: round6(q.y - recentre.z) }));
-                notes.push({
-                    code: 'POLYGON_RECENTRED',
-                    part: name,
-                    detail: `path was drawn about (${recentre.x}, ${recentre.z}) in its own frame; moved to the origin and the placement moved by the same amount, so it draws where it drew`
-                });
-            }
-            if (cp.shape?.round)
-                lost.push({ code: 'POLYGON_ROUND', part: name, detail: 'V2 ignores round on a polygon; so does V3' });
-        }
-        const segments = cp.segments ?? SEG_DEFAULT;
-        if ((cp.primitive === 'cylinder' || cp.primitive === 'sphere') && !SEGMENT_PRESETS.includes(segments)) {
-            refusals.push({ code: 'SEGMENTS', part: name, detail: `${segments} segments; V3 accepts ${SEGMENT_PRESETS.join(', ')}` });
-            continue;
-        }
-        const subject = withSizing(cp);
-        const extent = rotatedExtentOf(cp);
-        const rules = { x: anchorOf(subject, base, 'x'), y: anchorOf(subject, base, 'y'), z: anchorOf(subject, base, 'z') };
-        const repeat = cp.sizing === 'repeat' && cp.repeat ? cp.repeat : null;
-        // World factor per axis: how much the rotated part's extent along that axis follows the instance.
-        const factor = {};
-        const centre = {};
-        const pending = [];
-        for (const a of AXES) {
-            const rule = rules[a];
-            const gaps = clearance(subject, base, a);
-            const reach = extent[a] / 2;
-            const pos = cp.transform.position[a];
-            if (rule === 'scale') {
-                factor[a] = factorOfScale(a);
-                centre[a] = pos === 0 ? { kind: 'const', value: 0 } : { kind: 'ref', ref: g.mul(`${name}.${a}.centre`, size[a], ratio(pos / base[a], `${name}.${a}.at`)) };
-            }
-            else if (rule === 'span') {
-                const free = g.add(`${name}.${a}.free`, size[a], g.constant(round6(-(gaps.min + gaps.max)), 'mm', `${name}.${a}.gaps`));
-                factor[a] = { kind: 'ref', ref: g.div(`${name}.${a}.factor`, free, g.constant(extent[a], 'mm', `${name}.${a}.own`)), sig: `span.${name}.${a}` };
-                centre[a] = { kind: 'const', value: round6((gaps.min - gaps.max) / 2) };
-            }
-            else if (rule === 'min') {
-                factor[a] = ONE;
-                centre[a] = { kind: 'ref', ref: g.add(`${name}.${a}.centre`, g.mul(`${name}.${a}.half`, size[a], ratio(-0.5, 'minusHalf')), g.constant(round6(gaps.min + reach), 'mm', `${name}.${a}.fromMin`)) };
-            }
-            else if (rule === 'max') {
-                factor[a] = ONE;
-                centre[a] = { kind: 'ref', ref: g.add(`${name}.${a}.centre`, g.mul(`${name}.${a}.half`, size[a], ratio(0.5, 'half')), g.constant(round6(-(gaps.max + reach)), 'mm', `${name}.${a}.fromMax`)) };
-            }
-            else if (rule === 'center') {
-                factor[a] = ONE;
-                centre[a] = { kind: 'const', value: pos };
-            }
-            else {
-                pending.push(a); // aspect-*: follows another axis, settled below
-            }
-        }
-        // A capability anchor is a place, not a body: V2 compiles it apart from the drawn groups and never renders it
-        // (the independent check against the V2 renderer found the converter drawing one). Its position is kept for
-        // joints that attach to it; nothing is placed.
-        if (cp.capability) {
-            info.set(name, { centre, factor, repeat: false });
-            continue;
-        }
-        // A curved part keeps a round section: both cross axes take the geometric mean of their two factors
-        // (`sizing.ts` keepRound). When the two are the same expression the mean is that expression; otherwise
-        // it is a `geomean@1` node. V2 does this before an aspect axis copies its neighbour, so the copy sees the mean.
-        if ((cp.primitive === 'cylinder' || cp.primitive === 'sphere') && cp.keepRound !== false) {
-            const spin = cp.primitive === 'sphere' ? null : longAxis(subject);
-            const across = AXES.filter(a => a !== spin);
-            const fs = across.map(a => factor[a] ?? ONE); // an aspect axis is still unresolved here and counts as fixed, as V2's keepRound sees it
-            const same = fs.every(f => f.kind === 'one') || fs.every(f => f.kind === 'ref' && f.sig === fs[0].sig);
-            if (!same) {
-                const asRef = (f) => (f.kind === 'one' ? ratio(1, 'one') : f.ref);
-                const even = { kind: 'ref', ref: g.node(`${name}.round`, 'geomean@1', fs.map(asRef), 'value'), sig: `round.${name}` };
-                for (const a of across)
-                    factor[a] = even;
-            }
-        }
-        for (const a of pending) {
-            const named = rules[a].slice('aspect-'.length);
-            factor[a] = factor[named];
-            centre[a] = times(`${name}.${a}.centre`, { kind: 'const', value: cp.transform.position[a] }, factor[named]);
-        }
-        // The V3 asset frame has its origin at the bottom of the box (ADR-0065); V2 sizing works from the centre.
-        centre.y = { kind: 'ref', ref: g.add(`${name}.y.fromBottom`, g.len(centre.y, `${name}.y.centred`), g.mul(`${name}.y.lift`, size.y, ratio(0.5, 'half'))) };
-        // A recentred polygon moves back by R·c, and that offset follows the world factor of each axis as the drawn
-        // mesh did in V2 (rotation baked, then scaled per world axis).
-        if (recentre.x !== 0 || recentre.z !== 0) {
-            const R = eulerXYZ(cp.transform.rotation);
-            for (const [a, axis] of AXES.entries()) {
-                const k = round6(R[a][0] * recentre.x + R[a][2] * recentre.z);
-                if (k === 0)
-                    continue;
-                const shift = times(`${name}.${axis}.recentre`, { kind: 'const', value: k }, factor[axis]);
-                centre[axis] = { kind: 'ref', ref: g.add(`${name}.${axis}.drawnAt`, g.len(centre[axis], `${name}.${axis}.declared`), g.len(shift, `${name}.${axis}.shift`)) };
-            }
-        }
-        // Local dimensions scale by the factor of the world axis each local axis lands on.
-        let perm = axisPermutation(cp.transform.rotation);
-        const follows = AXES.some(a => factor[a].kind !== 'one');
-        // Fastened to another part: rigid, with the centre riding that part's face (designer's ruling 2026-09-22).
-        const fastening = options.reauthor?.attach?.find(x => x.part === name);
-        if (fastening) {
-            const mount = parts.find(x => x.name === fastening.to);
-            if (!mount) {
-                refusals.push({ code: 'ATTACH_TARGET', part: name, detail: `it is to be fastened to "${fastening.to}", which is not a part of this figure` });
-                continue;
-            }
-            /*
-              Which face it is fastened to: the one it stands out through. A panel set into its housing still counts,
-              which is how the notching machine's control panel is drawn — it is sunk into the enclosure and only its
-              front shows. Exactly one face must qualify, or there is nothing to call the mounting.
-            */
-            const reachOf = (q, a) => ({ lo: q.transform.position[a] - q.transform.size[a] / 2, hi: q.transform.position[a] + q.transform.size[a] / 2 });
-            const held = [];
-            for (const a of AXES) {
-                const mine = reachOf(cp, a), theirs = reachOf(mount, a);
-                if (mine.hi > theirs.hi + 1e-9)
-                    held.push({ axis: a, face: theirs.hi, offset: cp.transform.position[a] - theirs.hi });
-                else if (mine.lo < theirs.lo - 1e-9)
-                    held.push({ axis: a, face: theirs.lo, offset: cp.transform.position[a] - theirs.lo });
-            }
-            if (held.length !== 1) {
-                refusals.push({
-                    code: 'ATTACH_FACE',
-                    part: name,
-                    detail: held.length
-                        ? `it stands out of "${fastening.to}" on ${held.map(h => h.axis).join(' and ')}; which face holds it cannot be read from the drawing`
-                        : `it is wholly inside "${fastening.to}", so there is no face it stands out through`
-                });
-                continue;
-            }
-            const face = held[0];
-            if (anchorOf(withSizing(mount), base, face.axis) !== 'scale') {
-                refusals.push({ code: 'ATTACH_MOUNT', part: name, detail: `"${fastening.to}" does not follow the instance proportionally on ${face.axis}, so its face is not a ratio of the size` });
-                continue;
-            }
-            // The mount's face is that ratio of the instance size; the gap the author drew is kept as it is.
-            const faceRatio = face.face / base[face.axis];
-            const rideTo = g.add(`${name}.${face.axis}.fastened`, g.mul(`${name}.${face.axis}.face`, size[face.axis], ratio(round6(faceRatio), `${name}.${face.axis}.faceAt`)), g.constant(round6(face.offset), 'mm', `${name}.${face.axis}.gap`));
-            for (const a of AXES)
-                factor[a] = ONE;
-            centre[face.axis] = { kind: 'ref', ref: rideTo };
-            perm = { x: 'x', y: 'y', z: 'z' };
-            method = 're-authored';
-            notes.push({
-                code: 'RE_AUTHORED_FASTENED',
-                part: name,
-                detail: `tilted (${AXES.map(a => `${a}:${cp.transform.rotation?.[a] ?? 0}°`).join(', ')}) and following the instance, which V2 shears. Re-authored: it keeps its authored dimensions and tilt, and its centre rides the ${face.axis} face of "${fastening.to}" at the ${face.offset.toFixed(1)} mm the author drew. The gap between them is the same at every instance size`
-            });
-        }
-        if (!perm && follows) {
-            // A rotation that only mixes axes carrying the same factor is not a shear: scaling and rotating commute,
-            // so each local axis keeps its own axis's factor and the body is the one V2 draws.
-            const sameFactor = (a, b) => {
-                const x = factor[a], y = factor[b];
-                if (x.kind === 'one' && y.kind === 'one')
-                    return true;
-                return x.kind === 'ref' && y.kind === 'ref' && x.sig !== undefined && x.sig === y.sig;
-            };
-            if (scalingCommutesWithRotation(cp.transform.rotation, sameFactor)) {
-                perm = { x: 'x', y: 'y', z: 'z' };
-                notes.push({
-                    code: 'ROTATED_UNIFORM_PLANE',
-                    part: name,
-                    detail: `turned off the axes and following the instance, but every pair of axes the rotation mixes carries the same factor, so scaling and rotating commute. V2 scaled it uniformly inside the plane it turns in rather than shearing it; converted as V2 draws it, with no re-authoring`
-                });
-            }
-        }
-        if (!perm && follows) {
-            const nearest = options.reauthor?.rotatedFollows === 'nearest-axis' ? nearestAxisPermutation(cp.transform.rotation) : null;
-            if (!nearest) {
-                refusals.push({ code: 'ROTATED_FOLLOWS', part: name, detail: 'rotated off the axes and its size follows the instance; V2 shears it, V3 cannot' });
-                continue;
-            }
-            perm = nearest;
-            method = 're-authored';
-            const rot = cp.transform.rotation ?? {};
-            notes.push({
-                code: 'RE_AUTHORED_ROTATED',
-                part: name,
-                detail: `rotated (${AXES.map(a => `${a}:${rot[a] ?? 0}°`).join(', ')}) and its size follows the instance; V2 sheared the mesh. Re-authored rigid: each local dimension follows the world axis it lies nearest to (${AXES.map(a => `${a}→${nearest[a]}`).join(', ')}). Same as V2 where the factors on the in-plane axes agree; different elsewhere, by design`
-            });
-        }
-        // A channel scale is planned after the parts and read when the shape node is written, so `dim` is called
-        // inside the shape closures only.
-        const withChannel = (v, local, hint) => {
-            const sc = scaleOf.get(name)?.[local];
-            if (!sc)
-                return v;
-            return { kind: 'ref', ref: g.mul(`${name}.${hint}.scaled`, g.len(v, `${name}.${hint}`), sc) };
-        };
-        // Memoised: the shape writes it and the declared volume reads it, and a node id may only be claimed once.
-        const dims = {};
-        const raws = {};
-        /** The dimension before any state channel scales it. The declared volume measures from this. */
-        const rawDim = (local) => (raws[local] ??= times(`${name}.dim.${local}`, { kind: 'const', value: cp.transform.size[local] }, perm ? factor[perm[local]] : ONE));
-        const dim = (local) => (dims[local] ??= withChannel(rawDim(local), local, `dim.${local}`));
-        const channelSplits = () => {
-            const sc = scaleOf.get(name);
-            return !!sc && (sc.x ?? null) !== (sc.z ?? null);
-        };
-        const localFrame = `${name}.local`;
-        // A part that spins gets its shape in a `spun` frame; the turn maps spun → local.
-        const shapeFrame = () => (spinOf.has(name) ? `${name}.spun` : localFrame);
-        const rot = cp.transform.rotation;
-        const rotationRefs = AXES.map(a => g.constant(rot?.[a] ?? 0, 'deg', `deg.${rot?.[a] ?? 0}`));
-        let shape;
-        if (cp.primitive === 'cylinder') {
-            // V2 builds every cylinder from a unit cylinder with equal end radii and scales it by size (things-scene
-            // geometry-bank): size.x ≠ size.z, or two cross factors that differ with keepRound off, is an elliptic
-            // cylinder, never a frustum. Equal radii by the same expression stay on cylinder-shape@1.
-            const fx = perm ? factor[perm.x] : ONE, fz = perm ? factor[perm.z] : ONE;
-            const sameFactor = (fx.kind === 'one' && fz.kind === 'one') || (fx.kind === 'ref' && fz.kind === 'ref' && fx.sig === fz.sig);
-            const equalSizes = Math.abs(cp.transform.size.x - cp.transform.size.z) <= 1e-9;
-            if (!(sameFactor && equalSizes))
-                notes.push({ code: 'ELLIPTIC_SECTION', part: name, detail: `section is not a circle (${!equalSizes ? `size.x ${cp.transform.size.x} ≠ size.z ${cp.transform.size.z}` : 'keepRound is off and the two cross axes follow the instance differently'}); written as cylinder-shape@2 with radiusX and radiusZ, as V2 drew it` });
-            shape = () => {
-                const radiusX = withChannel(times(`${name}.dim.radiusX`, { kind: 'const', value: cp.transform.size.x / 2 }, fx), 'x', 'radiusX');
-                const radiusZ = withChannel(times(`${name}.dim.radiusZ`, { kind: 'const', value: cp.transform.size.z / 2 }, fz), 'z', 'radiusZ');
-                const length = dim('y');
-                const round = sameFactor && equalSizes && !channelSplits();
-                return round
-                    ? g.node(`${name}.shape`, 'cylinder-shape@1', [g.len(radiusX, `${name}.radius`), g.len(length, `${name}.length`)], 'shape', { frame: shapeFrame() })
-                    : g.node(`${name}.shape`, 'cylinder-shape@2', [g.len(radiusX, `${name}.radiusX`), g.len(radiusZ, `${name}.radiusZ`), g.len(length, `${name}.length`)], 'shape', { frame: shapeFrame() });
-            };
-        }
-        else if (cp.primitive === 'sphere') {
-            const r = (local) => withChannel(times(`${name}.dim.radius${local.toUpperCase()}`, { kind: 'const', value: cp.transform.size[local] / 2 }, perm ? factor[perm[local]] : ONE), local, `radius${local.toUpperCase()}`);
-            shape = () => {
-                const [rx, ry, rz] = [r('x'), r('y'), r('z')];
-                return g.node(`${name}.shape`, 'sphere-shape@1', [g.len(rx, `${name}.rx`), g.len(ry, `${name}.ry`), g.len(rz, `${name}.rz`)], 'shape', { frame: shapeFrame() });
-            };
-        }
-        else if (cp.primitive === 'polygon') {
-            const fx = perm ? factor[perm.x] : ONE, fz = perm ? factor[perm.z] : ONE;
-            shape = () => {
-                const h = dim('y');
-                const points = path.flatMap((q, i) => [
-                    withChannel(times(`${name}.p${i}.x`, { kind: 'const', value: q.x }, fx), 'x', `p${i}.x`),
-                    withChannel(times(`${name}.p${i}.z`, { kind: 'const', value: q.y }, fz), 'z', `p${i}.z`)
-                ]);
-                return g.node(`${name}.shape`, 'polygon-shape@1', [g.len(h, `${name}.h`), ...points.map((v, i) => g.len(v, `${name}.pt${i}`))], 'shape', { frame: shapeFrame() });
-            };
-        }
-        else if (cp.primitive === 'rect') {
-            // V2 draws the corner with min(round, width/2, depth/2) (things-scene roundedRect). Write what was drawn.
-            const declared = cp.shape?.round ?? 0;
-            const round = round6(Math.min(declared, cp.transform.size.x / 2, cp.transform.size.z / 2));
-            if (round < declared)
-                notes.push({ code: 'ROUND_CLAMPED', part: name, detail: `corner radius declared ${declared} mm, drawn ${round} mm (half of the ${cp.transform.size.x}×${cp.transform.size.z} section)` });
-            // V2 scales the finished mesh per world axis, so a corner drawn with radius r becomes an elliptic arc with
-            // semi-axes r·fx, r·fz (shape-dimension contract §1). When the two factors are one expression, @1 is enough.
-            const fx = perm ? factor[perm.x] : ONE, fy = perm ? factor[perm.y] : ONE, fz = perm ? factor[perm.z] : ONE;
-            const sameFactor = (fx.kind === 'one' && fz.kind === 'one') || (fx.kind === 'ref' && fz.kind === 'ref' && fx.sig === fz.sig);
-            if (round > 0 && !sameFactor)
-                notes.push({ code: 'CORNER_PER_AXIS', part: name, detail: `corner radius ${round} mm follows x and z differently under sizing; written with per-axis corner semi-axes, as V2 drew it` });
-            shape = () => {
-                const roundX = withChannel(times(`${name}.roundX`, { kind: 'const', value: round }, fx), 'x', 'roundX');
-                const roundZ = withChannel(times(`${name}.roundZ`, { kind: 'const', value: round }, fz), 'z', 'roundZ');
-                const perAxis = round > 0 && (!sameFactor || channelSplits());
-                const [w, h, d] = [dim('x'), dim('y'), dim('z')];
-                if (hollow) {
-                    // A wall's thickness follows the axis it lies across and the floor follows the height.
-                    const wallX = withChannel(times(`${name}.wallX`, { kind: 'const', value: hollow.wall }, fx), 'x', 'wallX');
-                    const wallZ = withChannel(times(`${name}.wallZ`, { kind: 'const', value: hollow.wall }, fz), 'z', 'wallZ');
-                    const floor = withChannel(times(`${name}.floor`, { kind: 'const', value: hollow.floor ?? hollow.wall }, fy), 'y', 'floor');
-                    return perAxis
-                        ? g.node(`${name}.shape`, 'hollow-box@2', [g.len(w, `${name}.w`), g.len(h, `${name}.h`), g.len(d, `${name}.d`), g.len(roundX, `${name}.roundX`), g.len(roundZ, `${name}.roundZ`), g.len(wallX, `${name}.wallX`), g.len(wallZ, `${name}.wallZ`), g.len(floor, `${name}.floor`)], 'shape', { frame: shapeFrame() })
-                        : g.node(`${name}.shape`, 'hollow-box@1', [g.len(w, `${name}.w`), g.len(h, `${name}.h`), g.len(d, `${name}.d`), g.len(roundX, `${name}.round`), g.len(wallX, `${name}.wallX`), g.len(wallZ, `${name}.wallZ`), g.len(floor, `${name}.floor`)], 'shape', { frame: shapeFrame() });
-                }
-                return perAxis
-                    ? g.node(`${name}.shape`, 'rounded-box@2', [g.len(w, `${name}.w`), g.len(h, `${name}.h`), g.len(d, `${name}.d`), g.len(roundX, `${name}.roundX`), g.len(roundZ, `${name}.roundZ`)], 'shape', { frame: shapeFrame() })
-                    : g.node(`${name}.shape`, 'rounded-box@1', [g.len(w, `${name}.w`), g.len(h, `${name}.h`), g.len(d, `${name}.d`), g.len(roundX, `${name}.round`)], 'shape', { frame: shapeFrame() });
-            };
-        }
-        else {
-            shape = () => {
-                const [w, h, d] = [dim('x'), dim('y'), dim('z')];
-                return g.node(`${name}.shape`, 'box-shape@1', [g.len(w, `${name}.w`), g.len(h, `${name}.h`), g.len(d, `${name}.d`)], 'shape', { frame: shapeFrame() });
-            };
-        }
-        const appearance = { target: name, material: material };
-        if (cp.primitive === 'cylinder' || cp.primitive === 'sphere')
-            appearance.segments = segments;
-        info.set(name, { centre, factor, repeat: !!repeat });
-        /** The widest this body's side can be: its own dimension, times the most a state channel stretches it. */
-        const widestOf = (a) => {
-            const range = scaleRangeOf.get(name)?.[a];
-            if (!scaleOf.get(name)?.[a])
-                return dim(a);
-            if (!range)
-                return null; // a channel whose reach is not known; the volume cannot be produced from it
-            const k = Math.max(Math.abs(range.min), Math.abs(range.max));
-            return k === 1 ? rawDim(a) : times(`${name}.widest.${a}`, rawDim(a), { kind: 'ref', ref: ratio(round6(k), `${name}.widest.${a}.k`), sig: `widest.${name}.${a}` });
-        };
-        /*
-          A part's dimensions are its own, measured along its own axes; the declared volume is measured along the
-          asset's. A body turned by its authored rotation fills, on one asset axis, the sum of its three sides
-          weighted by how much each leans onto that axis — the box around the turned box. For a quarter turn that is
-          a plain swap, and for anything between it is wider than the body, which is the direction to be wrong in.
-          Reading the local side as if it were the world side is how a motor lying on its side came to be declared
-          15 mm short.
-        */
-        const rotationMatrix = eulerXYZ(cp.transform.rotation);
-        const worldSpan = (a) => {
-            const row = rotationMatrix[AXES.indexOf(a)];
-            /*
-              A bound that rounds inward is not a bound, so every weight that stays is rounded away from zero.
-      
-              A weight too small to be worth its own node is not moved onto another axis: the axes carry different
-              sides, and 5e-10 of a 100000 mm side is not covered by 5e-10 more of a 0.01 mm one (V3 designer's
-              counterexample 2026-09-23). It is dropped only when its own side is a fixed length, and then its whole
-              contribution in millimetres is added on, rounded up. A side that follows the instance keeps its term.
-            */
-            const terms = [];
-            let extraMm = 0;
-            for (const [i, local] of AXES.entries()) {
-                const k = Math.abs(row[i]);
-                if (k === 0)
-                    continue;
-                const side = widestOf(local);
-                if (!side)
-                    return null;
-                const up = Math.ceil(k * 1e6) / 1e6;
-                if (k < 1e-9 && side.kind === 'const') {
-                    extraMm += Math.ceil(up * side.value * 1e6) / 1e6;
-                    continue;
-                }
-                terms.push({ k: up, len: side });
-            }
-            return { terms, extraMm };
-        };
-        // The declared volume is built from the structure, so it needs each body's own reach and where it sits.
-        reachOf.set(name, {
-            centre,
-            dim,
-            turns: () => spinOf.has(name),
-            widest: widestOf,
-            worldSpan,
-            slides: () => (shiftsOf.get(name) ?? [])
-                .filter(sh => sh.travel)
-                .map(sh => ({ axis: sh.axis, factor: factor[sh.axis], travel: sh.travel }))
-        });
-        if (!repeat) {
-            plans.push({
-                appearance,
-                nodes: () => {
-                    const s = shape();
-                    const shifts = shiftsOf.get(name) ?? [];
-                    const frame = frameOf.get(name);
-                    const finalTo = frame ? 'asset.rest' : 'asset';
-                    // rest: local → F0; each slide F_k → F_k+1 along an asset axis; the last lands in finalTo.
-                    let pose = g.node(`${name}.pose`, 'rigid@1', [...AXES.map(a => g.len(centre[a], `${name}.${a}`)), ...rotationRefs], 'pose', { from: localFrame, to: shifts.length ? `${name}.rest0` : finalTo });
-                    shifts.forEach((shift, k) => {
-                        const axis = AXES.map(a => ratio(a === shift.axis ? 1 : 0, a === shift.axis ? 'one' : 'zeroRatio'));
-                        const slide = g.node(`${name}.slide${k}`, 'axis-slide@1', [...axis, shift.q], 'pose', { from: `${name}.rest${k}`, to: k === shifts.length - 1 ? finalTo : `${name}.rest${k + 1}` });
-                        pose = g.node(`${name}.shifted${k}`, 'compose@1', [slide, pose], 'pose');
-                    });
-                    if (frame)
-                        pose = g.node(`${name}.moved`, 'compose@1', [motionOf.get(frame), pose], 'pose');
-                    const spin = spinOf.get(name);
-                    if (spin) {
-                        const axis = AXES.map(a => ratio(a === spin.axis ? 1 : 0, a === spin.axis ? 'one' : 'zeroRatio'));
-                        const turn = g.node(`${name}.turn`, 'axis-turn@1', [...axis, spin.q], 'pose', { from: `${name}.spun`, to: localFrame });
-                        pose = g.node(`${name}.spinning`, 'compose@1', [pose, turn], 'pose');
-                    }
-                    g.node(name, 'place@1', [s, pose], 'placed');
-                }
-            });
-            continue;
-        }
-        // Repeat: copies pitch apart in the world (times the world factor of that axis), centred on the authored
-        // position, count = floor(room / pitch) with room = the instance size when the row spreads, else the base.
-        const axis = repeat.axis;
-        const spreads = rules[axis] !== 'scale';
-        const itemFrame = `${name}.item`;
-        plans.push({
-            appearance,
-            nodes: () => {
-                const s = shape();
-                let memberPose = g.node(`${name}.pose`, 'rigid@1', [...AXES.map(a => (a === axis ? g.constant(0, 'mm', 'zero') : g.len(centre[a], `${name}.${a}`))), ...rotationRefs], 'pose', { from: localFrame, to: itemFrame });
-                // A spinning repeated part (the conveyor's rollers) turns each copy about its own axis: the turn goes on the member.
-                const spin = spinOf.get(name);
-                if (spin) {
-                    const axisRefs = AXES.map(a => ratio(a === spin.axis ? 1 : 0, a === spin.axis ? 'one' : 'zeroRatio'));
-                    const turn = g.node(`${name}.turn`, 'axis-turn@1', [...axisRefs, spin.q], 'pose', { from: `${name}.spun`, to: localFrame });
-                    memberPose = g.node(`${name}.spinning`, 'compose@1', [memberPose, turn], 'pose');
-                }
-                const member = g.node(name, 'member@1', [s, memberPose], 'placed');
-                const assembly = g.node(`${name}.assembly`, 'assembly@1', [member], 'assembly');
-                let layout;
-                let rowStart;
-                if (spreads) {
-                    const zero = g.constant(0, 'mm', 'zero');
-                    const pitch = g.constant(repeat.pitch, 'mm', `${name}.pitch`);
-                    layout = g.node(`${name}.layout`, 'fit-pitch@1', [size[axis], zero, zero, pitch, pitch, ratio(0.5, 'half'), g.constant(REPEAT_LIMIT, 'count', 'repeatLimit')], 'layout');
-                    rowStart = g.add(`${name}.rowStart`, g.len(centre[axis], `${name}.${axis}`), g.mul(`${name}.halfRow`, size[axis], ratio(-0.5, 'minusHalf')));
-                }
-                else {
-                    // A fixed count spread pitch·factor apart: `fixed-count@1` spaces `count` items evenly over L - e,
-                    // so L = (count - 1)·pitch·factor + e with a 1 mm item extent, and the row starts e/2 before the first copy.
-                    const count = Math.max(1, Math.min(REPEAT_LIMIT, Math.floor(base[axis] / repeat.pitch)));
-                    const e = g.constant(1, 'mm', 'one');
-                    const row = times(`${name}.row`, { kind: 'const', value: (count - 1) * repeat.pitch }, factor[axis]);
-                    const L = g.add(`${name}.rowLength`, g.len(row, `${name}.row`), e);
-                    layout = g.node(`${name}.layout`, 'fixed-count@1', [g.constant(count, 'count', `${name}.count`), L, g.constant(0, 'mm', 'zero'), g.constant(0, 'mm', 'zero'), e, ratio(0.5, 'half'), g.constant(REPEAT_LIMIT, 'count', 'repeatLimit')], 'layout');
-                    const halfRow = times(`${name}.halfRow`, { kind: 'const', value: -((count - 1) * repeat.pitch) / 2 }, factor[axis]);
-                    rowStart = g.add(`${name}.rowStart`, g.add(`${name}.rowCentre`, g.len(centre[axis], `${name}.${axis}`), g.len(halfRow, `${name}.halfRow`)), g.constant(-0.5, 'mm', 'minusHalfMm'));
-                }
-                // The row as a whole shifts with a translation channel and moves with the joint frame that carries it.
-                const shifts = shiftsOf.get(name) ?? [];
-                const frame = frameOf.get(name);
-                const finalTo = frame ? 'asset.rest' : 'asset';
-                let rootPose = g.node(`${name}.root`, 'rigid@1', [...AXES.map(a => (a === axis ? rowStart : g.constant(0, 'mm', 'zero'))), ...AXES.map(() => g.constant(0, 'deg', 'deg.0'))], 'pose', { from: itemFrame, to: shifts.length ? `${name}.rest0` : finalTo });
-                shifts.forEach((shift, k) => {
-                    const axisRefs = AXES.map(a => ratio(a === shift.axis ? 1 : 0, a === shift.axis ? 'one' : 'zeroRatio'));
-                    const slide = g.node(`${name}.slide${k}`, 'axis-slide@1', [...axisRefs, shift.q], 'pose', { from: `${name}.rest${k}`, to: k === shifts.length - 1 ? finalTo : `${name}.rest${k + 1}` });
-                    rootPose = g.node(`${name}.shifted${k}`, 'compose@1', [slide, rootPose], 'pose');
-                });
-                if (frame)
-                    rootPose = g.node(`${name}.moved`, 'compose@1', [motionOf.get(frame), rootPose], 'pose');
-                g.node(`${name}.repeat`, 'repeat@1', [layout, assembly, rootPose], 'collection', { axis });
-            }
-        });
-    }
-    asset.occupancy.bounds = {
-        x: { min: g.mul('occupancy.x.min', size.x, ratio(-0.5, 'minusHalf')), max: g.mul('occupancy.x.max', size.x, ratio(0.5, 'half')) },
-        y: { min: g.constant(0, 'mm', 'zero'), max: V3_SIZE_INPUTS.y },
-        z: { min: g.mul('occupancy.z.min', size.z, ratio(-0.5, 'minusHalf')), max: g.mul('occupancy.z.max', size.z, ratio(0.5, 'half')) }
-    };
-    const motion = planMotion({ src, g, base, size, info, spinOf, shiftsOf, scaleOf, scaleRangeOf, visibilityOf, jointOriginOf, lost, frameOf, motionOf, asset, refusals, notes, rangeChanges, ratio, times, factorOfScale });
-    if (motion.reauthored)
-        method = 're-authored';
-    if (refusals.length)
-        return { status: 'refused', refusals, lost, rangeChanges, notes };
-    for (const plan of plans) {
-        plan.nodes();
-        const shown = visibilityOf.get(plan.appearance.target);
-        asset.appearance.push(shown ? { ...plan.appearance, visibility: shown } : plan.appearance);
-    }
-    if (options.occupancy === 'measured') {
-        /** Which joint carries a part: the nearest one above it in the parent chain. */
-        const jointsByChild = new Map((src.joints ?? []).map(j => [j.child, j.name]));
-        const carrierOfPart = (name) => {
-            for (let p = partsByName.get(name); p; p = p.parent ? partsByName.get(p.parent) : undefined) {
-                const j = jointsByChild.get(p.name);
-                if (j)
-                    return j;
-            }
-            return undefined;
-        };
-        declareOccupancy({ g, parts, reachOf, jointOriginOf, carrierOf: carrierOfPart, base, designInputs: asset.designInputs, asset, refusals, notes });
-        if (refusals.length)
-            return { status: 'refused', refusals, lost, rangeChanges, notes };
-    }
-    try {
-        compileV3Asset(asset);
-    }
-    catch (e) {
-        const err = e;
-        return { status: 'refused', refusals: [{ code: `V3_${err.code ?? 'COMPILE'}`, part: err.path, detail: err.message }], lost, rangeChanges, notes };
-    }
-    return { status: 'converted', method, asset, lost, rangeChanges, notes };
-}
-/**
- * Declares the volume the figure occupies, from the structure of the figure rather than from measurements.
- *
- * V2 had one box for two jobs: the size a figure is authored and placed at, and the room it takes up. In V3
- * they are separate (V3 designer's ruling 2026-09-22), and the volume is the reach on each side of the origin
- * (ruling 2026-09-23), so it can describe a part below the mounting plane or off one side only.
- *
- * **Why not measure it.** An earlier version sampled the reach at three instance sizes on one axis and fitted a
- * straight line. That says nothing between or beyond those sizes, nothing about changing two axes together, and
- * nothing about the poses between the state corners it happened to visit. Passing the third point proved
- * nothing (designer's ruling 2026-09-23).
- *
- * **What is built instead.** For every body, a bound that holds in every allowed state because of how the
- * figure is put together, written as graph values so it is right at every instance size by construction:
- *
- *   a body that does not move        exactly its own box
- *   a body that turns where it sits  its centre, give or take its own reach
- *   a body carried by joints         the outermost joint's origin, give or take the chain: the distance out
- *                                    to each joint below it, any sliding travel those joints allow, and the
- *                                    body's own reach
- *
- * A turning joint can point what hangs below it in any direction, so the chain is summed as lengths and applied
- * to every axis. That is wider than the true swept volume; it is a bound that can be explained, not a guess.
- * Joint angle ranges can tighten it later. This is arithmetic about where the parts can be, not a claim about
- * collisions, loads or safety, and it applies to a revolving door and a lift the same way it applies to an arm.
- *
- * A length is summed as `|dx| + |dy| + |dz|`, which is at least the straight-line distance, so the bound stays
- * on the safe side. `|x|` is `max(x, -x)`.
- */
-/**
- * A value read as `base + Σ slope_a · size_a`, or null when it is not of that shape.
- *
- * This reads the graph, it does not sample it, so what it returns is the value at every instance size and not
- * a fit through a few of them. It is how the declaration knows which parts can never leave the authored box:
- * every size input is positive, so a difference whose base and slopes are all non-negative is never negative.
- */
-function affineInSize(g, designInputs, ref) {
-    const zero = () => ({ x: 0, y: 0, z: 0 });
-    const constants = new Map(g.graph.constants.map(k => [k.id, k.value * (k.unit === 'cm' ? 10 : k.unit === 'm' ? 1000 : k.unit === 'percent' ? 0.01 : 1)]));
-    const writers = new Map();
-    for (const n of g.graph.nodes)
-        for (const out of Object.values(n.outputs))
-            writers.set(out, n);
-    const seen = new Set();
-    const walk = (r) => {
-        if (seen.has(r))
-            return null;
-        seen.add(r);
-        try {
-            for (const a of AXES)
-                if (r === V3_SIZE_INPUTS[a])
-                    return { base: 0, slope: { ...zero(), [a]: 1 } };
-            if (constants.has(r))
-                return { base: constants.get(r), slope: zero() };
-            if (Object.hasOwn(designInputs, r))
-                return { base: designInputs[r], slope: zero() };
-            const n = writers.get(r);
-            if (!n)
-                return null;
-            if (n.op === 'add@1') {
-                const a = walk(n.args[0]), b = walk(n.args[1]);
-                return a && b ? { base: a.base + b.base, slope: { x: a.slope.x + b.slope.x, y: a.slope.y + b.slope.y, z: a.slope.z + b.slope.z } } : null;
-            }
-            if (n.op === 'div@1') {
-                const a = walk(n.args[0]), b = walk(n.args[1]);
-                // Only a constant denominator keeps the value affine; a span's factor is (size − gaps) / a fixed length.
-                if (!a || !b || AXES.some(x => b.slope[x] !== 0) || b.base === 0)
-                    return null;
-                return { base: a.base / b.base, slope: { x: a.slope.x / b.base, y: a.slope.y / b.base, z: a.slope.z / b.base } };
-            }
-            if (n.op === 'mul@1') {
-                const a = walk(n.args[0]), b = walk(n.args[1]);
-                if (!a || !b)
-                    return null;
-                const flat = (v) => AXES.every(x => v.slope[x] === 0);
-                if (flat(b))
-                    return { base: a.base * b.base, slope: { x: a.slope.x * b.base, y: a.slope.y * b.base, z: a.slope.z * b.base } };
-                if (flat(a))
-                    return { base: a.base * b.base, slope: { x: b.slope.x * a.base, y: b.slope.y * a.base, z: b.slope.z * a.base } };
-                return null;
-            }
-            return null;
-        }
-        finally {
-            seen.delete(r);
-        }
-    };
-    return walk(ref);
-}
-function declareOccupancy(c) {
-    const { g, parts, reachOf, jointOriginOf, carrierOf, base, designInputs, asset, refusals, notes } = c;
-    const authoredBounds = asset.occupancy.bounds;
-    const affOfLen = (l) => (l.kind === 'const' ? { base: l.value, slope: { x: 0, y: 0, z: 0 } } : affineInSize(g, designInputs, l.ref));
-    const affAdd = (a, b, k = 1) => ({
-        base: a.base + k * b.base,
-        slope: AXES.reduce((o, x) => ((o[x] = a.slope[x] + k * b.slope[x]), o), {})
-    });
-    const affScale = (a, k) => ({ base: a.base * k, slope: AXES.reduce((o, x) => ((o[x] = a.slope[x] * k), o), {}) });
-    /** Is this value never past the authored bound on that side, at any instance size? Read from the graph. */
-    const neverPast = (mine, a, side) => {
-        const theirs = affineInSize(g, designInputs, authoredBounds[a][side]);
-        if (!mine || !theirs)
-            return false;
-        // min side: authored − mine ≤ 0 everywhere. max side: mine − authored ≤ 0 everywhere.
-        const d = side === 'min'
-            ? { base: theirs.base - mine.base, slope: AXES.reduce((o, x) => ((o[x] = theirs.slope[x] - mine.slope[x]), o), {}) }
-            : { base: mine.base - theirs.base, slope: AXES.reduce((o, x) => ((o[x] = mine.slope[x] - theirs.slope[x]), o), {}) };
-        // Only the slack that floating point itself needs. SAME_TOLERANCE_MM is how close V2 and V3 must draw the
-        // same body; borrowing it here let a part hang 1 mm outside the volume that is supposed to hold it.
-        return d.base <= FLOAT_SLACK_MM && AXES.every(x => d.slope[x] <= FLOAT_SLACK_MM * 1e-3);
-    };
-    let seq = 0;
-    const id = () => `occ.v${seq++}`;
-    const isNum = (v) => 'n' in v;
-    const ref = (v, hint) => (isNum(v) ? g.constant(round6(v.n), 'mm', hint) : v.ref);
-    const ofLen = (l) => (l.kind === 'const' ? { n: l.value } : { ref: l.ref });
-    /*
-      The same sum turns up again and again: every body on a shelf is half its own depth from the same place, and
-      every joint in a chain is measured from the one above it by parts that share it. Writing each of those once
-      is what keeps a twenty-part figure inside the document's node limit, and it changes no value.
-    */
-    const shared = new Map();
-    const once = (key, build) => {
-        const known = shared.get(key);
-        if (known)
-            return known;
-        const made = build();
-        shared.set(key, made);
-        return made;
-    };
-    const add = (a, b) => {
-        if (isNum(a) && isNum(b))
-            return { n: a.n + b.n };
-        if (isNum(a) && a.n === 0)
-            return b;
-        if (isNum(b) && b.n === 0)
-            return a;
-        const ra = ref(a, id()), rb = ref(b, id());
-        const key = `+|${[ra, rb].sort().join('|')}`;
-        return { ref: once(key, () => g.add(id(), ra, rb)) };
-    };
-    const scale = (a, k) => {
-        if (isNum(a))
-            return { n: a.n * k };
-        if (k === 1)
-            return a;
-        const key = `*|${a.ref}|${round6(k)}`;
-        return { ref: once(key, () => g.mul(id(), a.ref, g.constant(k, 'ratio', `occ.k${round6(k)}`))) };
-    };
-    const abs = (a) => {
-        if (isNum(a))
-            return { n: Math.abs(a.n) };
-        const negated = ref(scale(a, -1), id());
-        return { ref: once(`abs|${a.ref}`, () => g.node(id(), 'max@1', [a.ref, negated], 'value')) };
-    };
-    const sum = (vs) => vs.reduce(add, { n: 0 });
-    /** |a − b| summed over the three axes: at least the straight-line distance between two places. */
-    const spread = (a, b) => sum(a.map((v, i) => abs(add(v, scale(b[i], -1)))));
-    const low = { x: [], y: [], z: [] };
-    const high = { x: [], y: [], z: [] };
-    /** The reach of a chain of joints, shared by every part that hangs from it. */
-    const chainReach = new Map();
-    /** Per chain: how far each body hanging from it reaches, so only the furthest is written. */
-    const furthest = new Map();
-    const originVals = (j) => jointOriginOf.get(j).origin.map(r => ({ ref: r }));
-    const reachOfChain = (chain) => {
-        const key = chain.join('/');
-        const known = chainReach.get(key);
-        if (known)
-            return known;
-        const below = chain.length > 1 ? reachOfChain(chain.slice(0, -1)) : { n: 0 };
-        const step = chain.length > 1 ? spread(originVals(chain[chain.length - 2]), originVals(chain[chain.length - 1])) : { n: 0 };
-        const travel = { n: jointOriginOf.get(chain[chain.length - 1]).slide };
-        const out = sum([below, step, travel]);
-        chainReach.set(key, out);
-        return out;
-    };
-    for (const cp of parts) {
-        const own = reachOf.get(cp.name);
-        if (!own)
-            continue; // a capability anchor or a refused part: nothing is drawn for it
-        /*
-          A body whose size follows a state input is measured at the widest that channel allows, from the channel's
-          own keys, so the declared volume stands still while the figure moves (shape-dimension contract §2). A
-          channel whose reach is not known is reported rather than guessed at.
-        */
-        if (AXES.some(a => own.widest(a) === null || own.worldSpan(a) === null)) {
-            refusals.push({
-                code: 'OCCUPANCY_STATE_SIZED',
-                part: cp.name,
-                detail: `its size follows a state channel whose reach is not known, so the volume cannot be produced from it; a declared volume has to stand still while the figure moves`
-            });
-            continue;
-        }
-        const centre = AXES.map(a => ofLen(own.centre[a]));
-        // Built only where it is used: a body needs either its own half-sides or its reach in any direction, not both.
-        const halfCache = {};
-        const half = (a) => {
-            const span = own.worldSpan(a);
-            return (halfCache[a] ??= scale(add(sum(span.terms.map(t => scale(ofLen(t.len), t.k))), { n: span.extraMm }), 0.5));
-        };
-        /** Half of all three sides together: at least the way from the centre to any corner, however it is turned. */
-        let anyWayCache = null;
-        const anyWay = () => (anyWayCache ??= scale(sum(AXES.map(a => ofLen(own.widest(a)))), 0.5));
-        const chain = [];
-        for (let j = carrierOf(cp.name); j; j = jointOriginOf.get(j)?.above) {
-            if (chain.includes(j))
-                break;
-            chain.unshift(j);
-        }
-        if (!chain.length) {
-            /*
-              It stays in one frame. Turning where it sits is covered by its own reach in every direction; sliding is
-              covered by an interval along the axis it slides on, which handles a negative direction and an
-              asymmetric range without widening the other axes (designer's ruling 2026-09-23). Nothing above it
-              rotates, so the axis it slides along is the axis it slides along at every pose.
-      
-              There is no shortcut here for a part that looks like it stays inside. `neverPast` decides that, by
-              reading the value rather than by trusting that position and shape scale together — keepRound, a fixed
-              section and a repeat all break that, and an overhang tolerated at the authored size grows with it.
-            */
-            const round = own.turns() ? anyWay() : null;
-            const travelOn = (a) => {
-                let lo = { n: 0 }, hi = { n: 0 };
-                for (const sl of own.slides()) {
-                    if (sl.axis !== a)
-                        continue;
-                    /*
-                      Every world factor the converter writes is positive, so the interval keeps the travel's own order.
-                      The travel is a length, so it enters as millimetres; the factor is the ratio it is stretched by.
-                    */
-                    const fac = sl.factor;
-                    const f = (v) => fac.kind === 'one'
-                        ? { n: v }
-                        : { ref: once(`travel|${fac.ref}|${round6(v)}`, () => g.mul(id(), g.constant(round6(v), 'mm', `occ.travel${round6(v)}`), fac.ref)) };
-                    lo = add(lo, f(Math.min(sl.travel.min, sl.travel.max)));
-                    hi = add(hi, f(Math.max(sl.travel.min, sl.travel.max)));
-                }
-                return { lo, hi };
-            };
-            const affCentre = AXES.map(a => affOfLen(own.centre[a]));
-            const affHalf = AXES.map(a => {
-                const d = affOfLen(own.widest(a));
-                return d && affScale(d, 0.5);
-            });
-            const affRound = own.turns()
-                ? affHalf.reduce((acc, h) => (acc && h ? affAdd(acc, h) : null), { base: 0, slope: { x: 0, y: 0, z: 0 } })
-                : null;
-            for (const [i, a] of AXES.entries()) {
-                const rAff = own.turns() ? affRound : affHalf[i];
-                const t = travelOn(a);
-                const tAff = (v) => (isNum(v) ? { base: v.n, slope: { x: 0, y: 0, z: 0 } } : affineInSize(g, designInputs, v.ref));
-                const cA = affCentre[i];
-                const tLo = tAff(t.lo), tHi = tAff(t.hi);
-                const loAff = cA && rAff && tLo ? affAdd(affAdd(cA, rAff, -1), tLo) : null;
-                const hiAff = cA && rAff && tHi ? affAdd(affAdd(cA, rAff), tHi) : null;
-                const reach = own.turns() ? round : half(a);
-                if (!neverPast(loAff, a, 'min'))
-                    low[a].push(add(add(centre[i], scale(reach, -1)), t.lo));
-                if (!neverPast(hiAff, a, 'max'))
-                    high[a].push(add(add(centre[i], reach), t.hi));
-            }
-            continue;
-        }
-        /*
-          Every body on one chain swings about the same place, so the chain keeps the furthest of them and writes
-          one pair of bounds. A pair for each body would say the same thing, only more of it.
-        */
-        const radius = sum([reachOfChain(chain), spread(originVals(chain[chain.length - 1]), centre), anyWay()]);
-        const key = chain.join('/');
-        const held = furthest.get(key);
-        furthest.set(key, held ? { chain, radius: [...held.radius, radius] } : { chain, radius: [radius] });
-        notes.push({
-            code: 'OCCUPANCY_FROM_STRUCTURE',
-            part: cp.name,
-            detail: `carried by ${chain.join(' → ')}, so it can be anywhere within that chain's reach of ${chain[0]}: the way out to each joint below it, any sliding travel they allow, and its own size. The declared volume holds that at every instance size, without measuring a pose`
-        });
-    }
-    for (const { chain, radius } of furthest.values()) {
-        const anchor = originVals(chain[0]);
-        const worst = radius.every(isNum)
-            ? { n: Math.max(...radius.map(r => r.n)) }
-            : radius.length === 1
-                ? radius[0]
-                : { ref: g.node(id(), 'max@1', radius.map((r, i) => ref(r, `occ.r${i}`)), 'value') };
-        for (const [i, a] of AXES.entries()) {
-            low[a].push(add(anchor[i], scale(worst, -1)));
-            high[a].push(add(anchor[i], worst));
-        }
-    }
-    if (!reachOf.size) {
-        refusals.push({ code: 'OCCUPANCY_NO_BODIES', part: '*', detail: 'nothing is drawn, so there is no volume to declare' });
-        return;
-    }
-    for (const a of AXES) {
-        if (low[a].length)
-            asset.occupancy.bounds[a].min = g.node(`occupancy.${a}.min.held`, 'min@1', [authoredBounds[a].min, ...low[a].map((v, i) => ref(v, `occ.${a}.lo${i}`))], 'value');
-        if (high[a].length)
-            asset.occupancy.bounds[a].max = g.node(`occupancy.${a}.max.held`, 'max@1', [authoredBounds[a].max, ...high[a].map((v, i) => ref(v, `occ.${a}.hi${i}`))], 'value');
-    }
-}
-/** The subject the sizing rules read: `sizing` filled in like the blueprint does. */
-function withSizing(cp) {
-    return { ...cp, sizing: cp.sizing ?? 'scale' };
-}
-const I3 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
-const mm3 = (a, b) => a.map(r => [0, 1, 2].map(j => r[0] * b[0][j] + r[1] * b[1][j] + r[2] * b[2][j]));
-const mv3 = (a, v) => a.map(r => r[0] * v[0] + r[1] * v[1] + r[2] * v[2]);
-const tr3 = (a) => [0, 1, 2].map(i => [0, 1, 2].map(j => a[j][i]));
-/** Rotation about a unit axis by degrees (Rodrigues), the matrix three's setFromAxisAngle builds. */
-export function axisAngle(axis, deg) {
-    const n = Math.hypot(axis.x, axis.y, axis.z);
-    const [x, y, z] = [axis.x / n, axis.y / n, axis.z / n];
-    const q = (deg * Math.PI) / 180, c = Math.cos(q), s = Math.sin(q), k = 1 - c;
-    return [
-        [c + x * x * k, x * y * k - z * s, x * z * k + y * s],
-        [y * x * k + z * s, c + y * y * k, y * z * k - x * s],
-        [z * x * k - y * s, z * y * k + x * s, c + z * z * k]
-    ];
-}
-/** V2's channel sampling (`things-scene` sampleChannel): hold the ends, `step` keeps the earlier key. */
-function sampleV2(channel, at) {
-    const keys = channel.keys;
-    if (at <= keys[0].at)
-        return keys[0].value;
-    const last = keys[keys.length - 1];
-    if (at >= last.at)
-        return last.value;
-    let i = 0;
-    while (i < keys.length - 2 && keys[i + 1].at <= at)
-        i++;
-    const from = keys[i], to = keys[i + 1];
-    if (channel.interpolation === 'step')
-        return from.value;
-    const span = to.at - from.at;
-    const r = span > 0 ? (at - from.at) / span : 0;
-    if (typeof from.value === 'number')
-        return (from.value + r * (to.value - from.value));
-    const f = from.value, t = to.value;
-    return { x: f.x + r * (t.x - f.x), y: f.y + r * (t.y - f.y), z: f.z + r * (t.z - f.z) };
-}
-/** V2's clip length: the last key time across its channels, in seconds. */
-export function v2ClipDuration(clip) {
-    let last = 0;
-    for (const ch of clip.channels) {
-        const end = ch.keys[ch.keys.length - 1]?.at;
-        if (typeof end === 'number' && end > last)
-            last = end;
-    }
-    return last;
-}
-/**
- * Where V2 draws every part (and copy) at an instance scale and a motion state, as oriented world boxes.
- * Motion follows things-scene: a translation channel shifts the part in the figure frame by the part's world
- * factor; a rotation channel turns it about its own centre in its own frame (R_part·R_ch·R_part⁻¹); a joint turns
- * everything in its frame about its sized origin, parents first (ADR-0066).
- */
-export function v2WorldBoxes(source, scale, state = {}, options = {}) {
-    const base = source.base;
-    const out = [];
-    const shifts = new Map();
-    const scales = new Map();
-    const turns = new Map();
-    const jointValues = new Map();
-    const rotationOf = new Map(source.parts.map(p => [p.name, eulerXYZ(p.transform.rotation)]));
-    const apply = (channels, at) => {
-        for (const ch of channels) {
-            if (ch.path === undefined) {
-                jointValues.set(ch.target, (jointValues.get(ch.target) ?? 0) + sampleV2(ch, at));
-                continue;
-            }
-            const v = sampleV2(ch, at);
-            if (ch.path === 'scale') {
-                const s0 = scales.get(ch.target) ?? { x: 1, y: 1, z: 1 };
-                scales.set(ch.target, { x: s0.x * v.x, y: s0.y * v.y, z: s0.z * v.z });
-            }
-            else if (ch.path === 'translation') {
-                const s0 = shifts.get(ch.target) ?? { x: 0, y: 0, z: 0 };
-                shifts.set(ch.target, { x: s0.x + v.x, y: s0.y + v.y, z: s0.z + v.z });
-            }
-            else if (ch.path === 'rotation') {
-                const Rp = rotationOf.get(ch.target) ?? I3;
-                const Rch = eulerXYZ(v);
-                const wrapped = mm3(mm3(Rp, Rch), tr3(Rp));
-                turns.set(ch.target, mm3(turns.get(ch.target) ?? I3, wrapped));
-            }
-        }
-    };
-    for (const p of source.parameters ?? []) {
-        const value = state.parameters?.[p.name] ?? p.default ?? p.range.min;
-        const u = p.range.max > p.range.min ? (value - p.range.min) / (p.range.max - p.range.min) : 0;
-        apply(p.clip.channels, u);
-    }
-    for (const clip of source.animations ?? []) {
-        const duration = v2ClipDuration(clip);
-        const t = state.clipTime?.[clip.name] ?? 0;
-        apply(clip.channels, duration > 0 ? t % duration : 0);
-    }
-    // Joint frames: world transform per joint, parents first.
-    const partsByName = new Map(source.parts.map(p => [p.name, p]));
-    const jointByChild = new Map((source.joints ?? []).map(j => [j.child, j]));
-    const carrierOf = (name) => {
-        for (let p = partsByName.get(name); p; p = p.parent ? partsByName.get(p.parent) : undefined) {
-            const j = jointByChild.get(p.name);
-            if (j)
-                return j;
-        }
-        return undefined;
-    };
-    const worldOf = new Map();
-    const worldJoint = (j) => {
-        const known = worldOf.get(j.name);
-        if (known)
-            return known;
-        const child = partsByName.get(j.child);
-        const attach = child.parent ? partsByName.get(child.parent) : undefined;
-        const cj = { origin: { ...j.origin, y: j.origin.y - base.y / 2 } };
-        const at = jointOriginPosition(cj, attach ? withSizing(centredPart(attach, base)) : undefined, scale, base);
-        const o = [at.x * scale.x, at.y * scale.y + (base.y * scale.y) / 2, at.z * scale.z];
-        const limits = j.limits;
-        let q = jointValues.get(j.name) ?? 0;
-        if (limits)
-            q = Math.min(Math.max(q, limits.min), limits.max);
-        let local;
-        if (j.type === 'prismatic') {
-            const n = Math.hypot(j.axis.x, j.axis.y, j.axis.z);
-            local = { r: I3, t: [(j.axis.x / n) * q * scale.x, (j.axis.y / n) * q * scale.y, (j.axis.z / n) * q * scale.z] };
-        }
-        else {
-            const R = axisAngle(j.axis, q);
-            const Ro = mv3(R, o);
-            local = { r: R, t: [o[0] - Ro[0], o[1] - Ro[1], o[2] - Ro[2]] };
-        }
-        const parentJoint = attach ? carrierOf(attach.name) : undefined;
-        const world = parentJoint ? composeRT(worldJoint(parentJoint), local) : local;
-        worldOf.set(j.name, world);
-        return world;
-    };
-    for (const part of source.parts) {
-        // Capability anchors are not drawn by V2 (blueprint `anchors`, not `groups`).
-        if (part.capability)
-            continue;
-        const cp = withSizing(centredPart(part, base));
-        const at = sizingPosition(cp, scale, base);
-        const sized = sizingScale(cp, scale, base);
-        const drawnSize = { ...cp.transform.size };
-        const extent = rotatedExtentOf(cp);
-        let rotation = eulerXYZ(part.transform.rotation);
-        const world = (a) => ({ centre: at[a] * scale[a], extent: extent[a] * sized[a] * scale[a], factor: sized[a] * scale[a] });
-        const box = { x: world('x'), y: world('y'), z: world('z') };
-        box.y.centre += (base.y * scale.y) / 2;
-        // A polygon is drawn where its path says, which may be off the part centre: rotation baked, then scaled per world axis.
-        let bodyPath = part.shape?.path;
-        if (part.primitive === 'polygon' && part.shape?.path?.length) {
-            const xs = part.shape.path.map(q => q.x), zs = part.shape.path.map(q => q.y);
-            const c = [(Math.max(...xs) + Math.min(...xs)) / 2, 0, (Math.max(...zs) + Math.min(...zs)) / 2];
-            for (const [a, axis] of AXES.entries())
-                box[axis].centre += (rotation[a][0] * c[0] + rotation[a][2] * c[2]) * box[axis].factor;
-            // The sampled body is centred on its drawn centre, so the path is taken about that centre.
-            bodyPath = part.shape.path.map(q => ({ x: q.x - c[0], y: q.y - c[2] }));
-        }
-        // A scale channel multiplies the part's own dimensions about its centre (V2 pose.scale in the part frame).
-        const chScale = scales.get(part.name) ?? { x: 1, y: 1, z: 1 };
-        // Surface points: body in its own frame → channel scale → baked rotation → scaled per world axis → motion → centre.
-        const localPoints = options.points
-            ? scalePoints(transformPoints(scalePoints(v2BodyPoints({ primitive: part.primitive, size: drawnSize, segments: part.segments ?? SEG_DEFAULT, round: part.shape?.round, hollow: part.shape?.hollow, path: bodyPath }), chScale), rotation, [0, 0, 0]), { x: box.x.factor, y: box.y.factor, z: box.z.factor })
-            : null;
-        // Local dimensions: each local axis lands on a world axis and takes that axis's factor, times any channel scale
-        // (V2 applies pose.scale in the part's own frame, about its centre).
-        /*
-          Which world axis each local axis takes its factor from. A right-angle rotation permutes them. A rotation
-          that only mixes axes carrying the same factor commutes with the scaling, so each local axis keeps its own
-          (`scalingCommutesWithRotation`). Anything else is a real shear: the drawn body is not a box, so there are no
-          local dimensions to report and the unscaled ones stand in. The surface points are sampled from the sheared
-          body either way, so a shear is still caught by the mesh comparison.
-        */
-        const perm = axisPermutation(part.transform.rotation) ??
-            (scalingCommutesWithRotation(part.transform.rotation, (a, b) => Math.abs(box[a].factor - box[b].factor) <= 1e-9)
-                ? { x: 'x', y: 'y', z: 'z' }
-                : null);
-        const dims = [
-            drawnSize.x * (perm ? box[perm.x].factor : 1) * chScale.x,
-            drawnSize.y * (perm ? box[perm.y].factor : 1) * chScale.y,
-            drawnSize.z * (perm ? box[perm.z].factor : 1) * chScale.z
-        ];
-        // Motion on the part itself: shift in the figure frame by the world factor, turn about the centre.
-        const shift = shifts.get(part.name);
-        if (shift)
-            for (const a of AXES)
-                box[a].centre += shift[a] * box[a].factor;
-        const turn = turns.get(part.name);
-        let motionRotation = I3;
-        if (turn) {
-            rotation = mm3(turn, rotation);
-            motionRotation = turn;
-        }
-        // Then the joint frame that carries it.
-        const carrier = carrierOf(part.name);
-        const W = carrier ? worldJoint(carrier) : undefined;
-        const plan = repeatPlan(cp, scale, base);
-        const copies = plan ? plan.count : 1;
-        for (let i = 0; i < copies; i++) {
-            let centre = { x: box.x.centre, y: box.y.centre, z: box.z.centre };
-            if (plan)
-                centre[plan.axis] += repeatOffset(i, plan.count, plan.pitch) * box[plan.axis].factor;
-            let R = rotation;
-            let M = motionRotation;
-            if (W) {
-                const c = mv3(W.r, [centre.x, centre.y, centre.z]);
-                centre = { x: c[0] + W.t[0], y: c[1] + W.t[1], z: c[2] + W.t[2] };
-                R = mm3(W.r, rotation);
-                M = mm3(W.r, motionRotation);
-            }
-            // V2 hides a part by scaling it to nothing. Nothing is drawn there, so it is not a drawn body.
-            if (dims.some(d => d <= 0))
-                continue;
-            const ext = AXES.map((_, a) => dims.reduce((sum, d, i) => sum + Math.abs(R[a][i]) * d, 0));
-            const box2 = { part: part.name, centre, extent: { x: ext[0], y: ext[1], z: ext[2] }, dims, rotation: R };
-            if (localPoints)
-                box2.points = transformPoints(localPoints, M, [centre.x, centre.y, centre.z]);
-            out.push(box2);
-        }
-    }
-    return out;
-}
-function composeRT(a, b) {
-    const rt = mv3(a.r, b.t);
-    return { r: mm3(a.r, b.r), t: [rt[0] + a.t[0], rt[1] + a.t[1], rt[2] + a.t[2]] };
-}
-/** Where a converted V3 asset draws every part at an instance size, as world boxes. */
-export function v3WorldBoxes(asset, size, stateOverrides = {}, options = {}) {
-    const inputs = { ...asset.designInputs, 'size.x': size.x, 'size.y': size.y, 'size.z': size.z };
-    const evaluated = compileV3Asset({ ...asset, designInputs: inputs }).evaluate(stateOverrides);
-    return v3WorldBoxesOf(evaluated.geometry, v3WritersOf(asset), options);
-}
-/**
- * Instance scales at which a repeated part's copy count changes, one just below and one just above each
- * boundary near the base count (completion criterion: repeat-count boundaries).
- */
-export function repeatBoundaryScales(source) {
-    const out = [];
-    for (const part of source.parts) {
-        if (part.sizing !== 'repeat' || !part.repeat)
-            continue;
-        const axis = part.repeat.axis, pitch = part.repeat.pitch, length = source.base[axis];
-        const count = Math.floor(length / pitch);
-        for (const k of [count, count + 1]) {
-            for (const delta of [-0.5, 0.5]) {
-                const L = k * pitch + delta;
-                if (L <= 0)
-                    continue;
-                out.push({ x: 1, y: 1, z: 1, [axis]: L / length });
-            }
-        }
-    }
-    return out;
-}
-/** ADR-0087 decision 2 tolerances. */
-/** The only slack a bound may have: what double arithmetic leaves behind, not a product tolerance. */
-const FLOAT_SLACK_MM = 1e-9;
-export const SAME_TOLERANCE_MM = 1;
-export const SAME_TOLERANCE_DEG = 0.1;
-/** The V3 state overrides that stand for a V2 motion state: parameters by name, drivers at their clip's time. */
-export function v3StateOverrides(asset, state) {
-    const units = new Map(asset.document.model.inputs.map(i => [i.id, i.unit]));
-    const out = {};
-    for (const [name, value] of Object.entries(state.parameters ?? {}))
-        if (units.has(name))
-            out[name] = value;
-    for (const d of asset.drivers ?? []) {
-        const t = state.clipTime?.[d.clip] ?? 0;
-        const unit = units.get(d.state);
-        out[d.state] = driverValue(d, t, unit === 'deg' || unit === 'rad' ? unit : 'other');
-    }
-    return out;
-}
-function rotationAngleDeg(a, b) {
-    // The angle of a·bᵀ. Its trace is the sum of the element-wise products of a and b.
-    let trace = 0;
-    for (let i = 0; i < 3; i++)
-        for (let k = 0; k < 3; k++)
-            trace += a[i][k] * b[i][k];
-    const c = Math.min(1, Math.max(-1, (trace - 1) / 2));
-    return (Math.acos(c) * 180) / Math.PI;
-}
-/**
- * "The same" (ADR-0087 decision 2): the V2 source and the V3 asset draw the same parts, each with the same
- * centre and local dimensions within 1 mm and the same rotation within 0.1° (as a relative angle), with the same
- * material, at the base size and at every combination of doubled axes, at rest and at every motion state given.
- */
-export function compareV2WithV3(source, asset, options = {}) {
-    const opts = typeof options === 'number' ? { factor: options } : options;
-    const factor = opts.factor ?? 2;
-    const mesh = opts.mesh ?? true;
-    const steps = opts.shrink ? [1, factor, 1 / factor] : [1, factor];
-    const scales = [];
-    for (const x of steps)
-        for (const y of steps)
-            for (const z of steps)
-                scales.push({ x, y, z });
-    scales.push(...(opts.extraScales ?? []));
-    const states = [{ label: 'rest' }, ...(opts.states ?? [])];
-    const differences = [];
-    let boxesCompared = 0;
-    const materials = new Map(asset.appearance.map(a => [a.target, a]));
-    for (const part of source.parts) {
-        if (part.capability)
-            continue; // an anchor has no body on either side
-        const look = materials.get(part.name);
-        if (!look) {
-            differences.push({ part: part.name, scale: scales[0], state: 'rest', what: 'appearance', v2: JSON.stringify(part.material), v3: 'missing' });
-            continue;
-        }
-        const expected = { token: part.material.token };
-        if (part.material.preset !== undefined)
-            expected.preset = part.material.preset;
-        if (part.material.transparent !== undefined)
-            expected.transparent = part.material.transparent;
-        if (part.material.emissive)
-            expected.emissive = { token: part.material.emissive.token ?? part.material.token, intensity: part.material.emissive.intensity, on: part.material.emissive.on ?? false };
-        if (JSON.stringify(expected) !== JSON.stringify(look.material))
-            differences.push({ part: part.name, scale: scales[0], state: 'rest', what: 'material', v2: JSON.stringify(expected), v3: JSON.stringify(look.material) });
-        if ((part.primitive === 'cylinder' || part.primitive === 'sphere') && look.segments !== (part.segments ?? SEG_DEFAULT))
-            differences.push({ part: part.name, scale: scales[0], state: 'rest', what: 'segments', v2: String(part.segments ?? SEG_DEFAULT), v3: String(look.segments) });
-    }
-    const byPart = (boxes) => {
-        const m = new Map();
-        for (const b of boxes)
-            (m.get(b.part) ?? m.set(b.part, []).get(b.part)).push(b);
-        for (const list of m.values())
-            list.sort((p, q) => p.centre.x - q.centre.x || p.centre.y - q.centre.y || p.centre.z - q.centre.z);
-        return m;
-    };
-    for (const state of states) {
-        const overrides = v3StateOverrides(asset, state);
-        for (const scale of scales) {
-            const size = { x: source.base.x * scale.x, y: source.base.y * scale.y, z: source.base.z * scale.z };
-            const v2 = byPart(v2WorldBoxes(source, scale, state, { points: mesh }));
-            let v3;
-            try {
-                v3 = byPart(v3WorldBoxes(asset, size, overrides, { points: mesh }));
-            }
-            catch (e) {
-                // V3 refuses what V2 drew anyway (a collapsed span as a sliver, a joint value past its limit). Recorded, not thrown.
-                const err = e;
-                differences.push({ part: '*', scale, state: state.label, what: `refused:${err.code}`, v2: 'draws it', v3: err.message });
-                continue;
-            }
-            for (const name of new Set([...v2.keys(), ...v3.keys()])) {
-                const a = v2.get(name) ?? [], b = v3.get(name) ?? [];
-                if (a.length !== b.length) {
-                    differences.push({ part: name, scale, state: state.label, what: 'copies', v2: String(a.length), v3: String(b.length) });
-                    continue;
-                }
-                for (const [i, p] of a.entries()) {
-                    const q = b[i];
-                    boxesCompared++;
-                    const tag = a.length > 1 ? `[${i}]` : '';
-                    for (const axis of AXES)
-                        if (Math.abs(p.centre[axis] - q.centre[axis]) > SAME_TOLERANCE_MM)
-                            differences.push({ part: name, scale, state: state.label, what: `centre.${axis}${tag}`, v2: p.centre[axis].toFixed(3), v3: q.centre[axis].toFixed(3) });
-                    for (const [i, d] of p.dims.entries())
-                        if (Math.abs(d - q.dims[i]) > SAME_TOLERANCE_MM)
-                            differences.push({ part: name, scale, state: state.label, what: `dims.${AXES[i]}${tag}`, v2: d.toFixed(3), v3: q.dims[i].toFixed(3) });
-                    const turn = rotationAngleDeg(p.rotation, q.rotation);
-                    if (turn > SAME_TOLERANCE_DEG)
-                        differences.push({ part: name, scale, state: state.label, what: `rotation${tag}`, v2: JSON.stringify(p.rotation.map(r => r.map(v => +v.toFixed(4)))), v3: `${turn.toFixed(3)}° apart` });
-                    if (mesh && p.points && q.points) {
-                        const gap = hausdorff(p.points, q.points);
-                        if (gap > SAME_TOLERANCE_MM)
-                            differences.push({ part: name, scale, state: state.label, what: `mesh${tag}`, v2: `${p.points.length} points`, v3: `surface ${gap.toFixed(3)} mm apart` });
-                    }
-                }
-            }
-        }
-    }
-    return {
-        same: differences.length === 0,
-        scales,
-        states: states.map(s => s.label),
-        boxesCompared,
-        sampling: { toleranceMm: SAME_TOLERANCE_MM, toleranceDeg: SAME_TOLERANCE_DEG, mesh, cornerDivisions: SEGMENT_PRESETS[0], sphereGrid: '6 rings × 12 around + poles', cylinderSegments: "the part's own segment count, both rims" },
-        differences
-    };
-}
-const V2_UNIT = { '%': 'percent', deg: 'deg', rad: 'rad', mm: 'mm', cm: 'cm', m: 'm', s: 's' };
-/**
- * Motion, per docs/v3-motion-contract.md. State inputs stand for V2 parameters (name, unit, range, default kept)
- * and for what clips drive; joints become `attach@1(T·turn·T⁻¹)` chains parents first; part channels become a
- * slide along an asset axis (times the part's world factor, as V2 shifted it) or a spin about the part's own axis.
- * What the contract does not cover is refused by name; a channel that moves nothing is noted and skipped.
- */
-function planMotion(c) {
-    const { src, g, base, size, info, spinOf, shiftsOf, scaleOf, scaleRangeOf, visibilityOf, jointOriginOf, lost, frameOf, motionOf, asset, refusals, notes, rangeChanges, ratio } = c;
-    let reauthored = false;
-    const params = src.parameters ?? [];
-    const clips = src.animations ?? [];
-    const joints = src.joints ?? [];
-    if (!params.length && !clips.length && !joints.length)
-        return { reauthored };
-    const partsByName = new Map(src.parts.map(p => [p.name, p]));
-    const jointsByName = new Map(joints.map(j => [j.name, j]));
-    // State inputs for parameters.
-    const paramUnit = new Map();
-    for (const p of params) {
-        const unit = V2_UNIT[p.range.unit];
-        if (!unit) {
-            refusals.push({ code: 'PARAMETER_UNIT', part: p.name, detail: `unit "${p.range.unit}" has no V3 unit` });
-            continue;
-        }
-        // V2 keeps parameters, parts and joints in separate name spaces; a V3 graph has one. The parameter keeps its
-        // name (motion contract), so a clash is refused rather than renamed behind the author's back.
-        if (partsByName.has(p.name) || jointsByName.has(p.name) && joints.some(j => j.name === p.name && j.child === p.name)) {
-            refusals.push({ code: 'NAME_COLLISION', part: p.name, detail: `parameter "${p.name}" shares its name with a part; V3 state inputs and parts share one name space` });
-            continue;
-        }
-        g.input(p.name, unit, p.range.min, p.range.max, 'state');
-        asset.stateDefaults[p.name] = p.default ?? p.range.min;
-        paramUnit.set(p.name, unit);
-        /*
-          What a person sees for this input, and how fast the figure travels to a new value for it. Both are kept
-          (V3 designer's ruling 2026-09-22): the label is display metadata beside the stable id, and the sweep is
-          the asset's own statement about its movement — a gripper that closes over 0.6 s must not close at once.
-        */
-        const policy = {};
-        if (p.label)
-            policy.label = p.label;
-        if (p.clip?.duration !== undefined && Number.isFinite(p.clip.duration) && p.clip.duration >= 0)
-            policy.sweep = p.clip.duration;
-        if (Object.keys(policy).length)
-            (asset.stateInputs ??= {})[p.name] = policy;
-    }
-    /** q = v0 + (p - min)·(v1 - v0)/(max - min), written in the output unit. Null when the channel does not move. */
-    const affine = (p, v0, v1, outUnit, hint) => {
-        if (v0 === v1)
-            return null;
-        const pUnit = paramUnit.get(p.name);
-        if (!pUnit)
-            return undefined;
-        const span = p.range.max - p.range.min;
-        let slopeUnit;
-        let slope;
-        if (pUnit === outUnit) {
-            slopeUnit = 'ratio';
-            slope = (v1 - v0) / span;
-        }
-        else if (pUnit === 'percent') {
-            // A percent input reaches the kernel as a ratio (×0.01), so the slope is per ratio.
-            slopeUnit = outUnit;
-            slope = ((v1 - v0) * 100) / span;
-        }
-        else {
-            refusals.push({ code: 'PARAMETER_UNIT', part: p.name, detail: `a ${pUnit} parameter cannot write a ${outUnit} value here` });
-            return undefined;
-        }
-        const u = g.add(`${hint}.u`, p.name, g.constant(round6(-p.range.min), pUnit, `${hint}.min`));
-        return g.add(`${hint}.q`, g.mul(`${hint}.scaled`, u, g.constant(round6(slope), slopeUnit, `${hint}.slope`)), g.constant(round6(v0), outUnit, `${hint}.v0`));
-    };
-    /** A dimensionless factor f = s0 + (p - min)·(s1 - s0)/(max - min), for a scale channel. */
-    const affineRatio = (p, s0, s1, hint) => {
-        const pUnit = paramUnit.get(p.name);
-        if (!pUnit)
-            return undefined;
-        const span = p.range.max - p.range.min;
-        if (pUnit !== 'percent' && pUnit !== 'ratio') {
-            // A slope in ratio-per-<unit> has no V3 unit; only dimensionless parameters may scale a dimension.
-            refusals.push({ code: 'PARAMETER_UNIT', part: p.name, detail: `a ${pUnit} parameter cannot scale a dimension; a percent or ratio parameter can` });
-            return undefined;
-        }
-        const slope = pUnit === 'percent' ? ((s1 - s0) * 100) / span : (s1 - s0) / span;
-        const u = g.add(`${hint}.u`, p.name, g.constant(round6(-p.range.min), pUnit, `${hint}.min`));
-        return g.add(`${hint}.f`, g.mul(`${hint}.scaled`, u, g.constant(round6(slope), 'ratio', `${hint}.slope`)), g.constant(round6(s0), 'ratio', `${hint}.s0`));
-    };
-    /**
-     * A dimensionless factor through every key of a linear channel: f = curve(u, at₀,s₀, at₁,s₁, …) with u = (p − min)/span
-     * as a ratio in [0, 1], the keys' `at` in the same ratio (piecewise-linear curves, V3 designer's approval
-     * 2026-09-22). Two keys at 0 and 1 take the affine form instead, so earlier assets keep their graphs.
-     */
-    /** The parameter mapped onto 0..1 as a ratio, the axis every key's `at` is measured on. */
-    const unitPosition = (p, hint) => {
-        const pUnit = paramUnit.get(p.name);
-        if (!pUnit)
-            return undefined;
-        if (pUnit !== 'percent' && pUnit !== 'ratio') {
-            refusals.push({ code: 'PARAMETER_UNIT', part: p.name, detail: `a ${pUnit} parameter cannot scale or hide a part; a percent or ratio parameter can` });
-            return undefined;
-        }
-        const span = p.range.max - p.range.min;
-        const slope = pUnit === 'percent' ? 100 / span : 1 / span;
-        const u = g.add(`${hint}.u`, p.name, g.constant(round6(-p.range.min), pUnit, `${hint}.min`));
-        return g.mul(`${hint}.u01`, u, g.constant(round6(slope), 'ratio', `${hint}.perSpan`));
-    };
-    const curveRatio = (p, keys, hint) => {
-        const u01 = unitPosition(p, hint);
-        if (u01 === undefined)
-            return undefined;
-        const args = [u01];
-        keys.forEach((k, i) => args.push(g.constant(round6(k.at), 'ratio', `${hint}.at${i}`), g.constant(round6(k.value), 'ratio', `${hint}.s${i}`)));
-        return g.node(`${hint}.curve`, 'curve@1', args, 'value');
-    };
-    /** A linear channel with keys in order inside [0, 1]; anything else is refused by name. */
-    const linearKeys = (ch, owner) => {
-        const keys = ch.keys;
-        if ((ch.interpolation ?? 'linear') !== 'linear') {
-            refusals.push({ code: 'PARAMETER_CURVE', part: owner, detail: `channel to ${ch.target}: ${ch.interpolation} interpolation is not written into the graph; linear keys are` });
-            return false;
-        }
-        if (keys.length < 2 || keys.some((k, i) => i > 0 && !(k.at > keys[i - 1].at)) || keys[0].at < 0 || keys[keys.length - 1].at > 1) {
-            refusals.push({ code: 'PARAMETER_CURVE', part: owner, detail: `channel to ${ch.target}: keys must be two or more, strictly increasing, inside [0, 1]` });
-            return false;
-        }
-        return true;
-    };
-    const twoKeyLinear = (ch, owner) => {
-        const keys = ch.keys;
-        if (keys.length !== 2 || keys[0].at !== 0 || keys[1].at !== 1 || (ch.interpolation ?? 'linear') !== 'linear') {
-            refusals.push({ code: 'PARAMETER_CURVE', part: owner, detail: `channel to ${ch.target}: only two linear keys at 0 and 1 are written into the graph` });
-            return false;
-        }
-        return true;
-    };
-    const varying = (keys) => AXES.filter(a => keys.some(k => k.value[a] !== keys[0].value[a]));
-    // Which parameter drives each joint; refuse two writers.
-    const jointWriter = new Map();
-    const partWriters = new Map(); // `${part}/${path}/${axis}` → owners
-    const claim = (key, owner, part) => {
-        const owners = partWriters.get(key) ?? new Set();
-        if (owners.size && !owners.has(owner)) {
-            refusals.push({ code: 'MOTION_MULTI_WRITER', part, detail: `${[...owners].join(', ')} and ${owner} both write ${key}; one writer per state` });
-            return false;
-        }
-        owners.add(owner);
-        partWriters.set(key, owners);
-        return true;
-    };
-    for (const p of params) {
-        if (!paramUnit.has(p.name))
-            continue;
-        for (const ch of p.clip.channels) {
-            if (ch.path === undefined) {
-                if (!jointsByName.has(ch.target)) {
-                    refusals.push({ code: 'PARAMETER_TARGET', part: p.name, detail: `channel targets "${ch.target}", which is not a joint` });
-                    continue;
-                }
-                if (!twoKeyLinear(ch, p.name))
-                    continue;
-                if (jointWriter.has(ch.target)) {
-                    refusals.push({ code: 'MOTION_MULTI_WRITER', part: ch.target, detail: `${jointWriter.get(ch.target).p.name} and ${p.name} both drive the joint` });
-                    continue;
-                }
-                const keys = ch.keys;
-                jointWriter.set(ch.target, { p, v0: keys[0].value, v1: keys[1].value });
-                continue;
-            }
-            const part = partsByName.get(ch.target);
-            if (!part) {
-                refusals.push({ code: 'PARAMETER_TARGET', part: p.name, detail: `channel targets "${ch.target}", which is not a part` });
-                continue;
-            }
-            if (!info.has(ch.target))
-                continue; // the part itself was refused above, and that refusal already names it
-            if (ch.pivot) {
-                refusals.push({ code: 'MOTION_PIVOT', part: ch.target, detail: 'a rotation pivot away from the part centre is not covered by the motion contract' });
-                continue;
-            }
-            const keys = ch.keys;
-            const axes = varying(keys);
-            if (ch.path === 'scale') {
-                // Shape-dimension contract §2: a state input may change a dimension. Each varying axis of the part gets a
-                // ratio factor affine in the parameter; the part's centre does not move (V2 scaled about the centre).
-                if (axes.length === 0) {
-                    notes.push({ code: 'MOTION_STATIC_CHANNEL', part: ch.target, detail: `parameter ${p.name} has a scale channel whose keys do not change; nothing to write` });
-                    continue;
-                }
-                if (!linearKeys(ch, p.name))
-                    continue;
-                if (!axisPermutation(partsByName.get(ch.target).transform.rotation)) {
-                    refusals.push({ code: 'ROTATED_FOLLOWS', part: ch.target, detail: 'a scale channel on a part rotated off the axes would shear it; not covered' });
-                    continue;
-                }
-                /*
-                  A scale of 0 is how V2 hides a part: the lamp glow is scaled to nothing until the gate opens. A V3
-                  dimension stays positive (designer's ruling 2026-09-22), so this is not a size at all — it is
-                  visibility, and it becomes a flag. Covered shape: the channel starts at 0 on every varying axis and,
-                  from its first non-zero key on, sits at exactly 1 (the part's declared size) on all of them. The part
-                  then keeps its own dimensions and is shown from that key onwards.
-        
-                  Anything else — a channel that hides and also resizes — is refused by name. Writing it as a floored
-                  size would make "not visible" mean "very small", which is the thing that was refused.
-                */
-                const hidesAt = keys.findIndex(k => axes.every(a => k.value[a] > 0));
-                if (keys.some(k => axes.some(a => k.value[a] <= 0))) {
-                    const shaped = hidesAt > 0 &&
-                        keys.slice(0, hidesAt).every(k => axes.every(a => k.value[a] === 0)) &&
-                        keys.slice(hidesAt).every(k => axes.every(a => k.value[a] === 1));
-                    if (!shaped) {
-                        refusals.push({ code: 'SCALE_ZERO', part: ch.target, detail: `parameter ${p.name} scales ${ch.target} to zero and to sizes other than its own; hiding and resizing in one channel is not covered` });
-                        continue;
-                    }
-                    if (visibilityOf.has(ch.target)) {
-                        refusals.push({ code: 'MOTION_MULTI_WRITER', part: ch.target, detail: `two channels decide whether ${ch.target} is shown` });
-                        continue;
-                    }
-                    let claimed = true;
-                    for (const axis of axes)
-                        if (!claim(`${ch.target}/scale/${axis}`, p.name, ch.target)) {
-                            claimed = false;
-                            break;
-                        }
-                    if (!claimed)
-                        continue;
-                    const hint = `${p.name}.${ch.target}.shown`;
-                    const u01 = unitPosition(p, hint);
-                    if (u01 === undefined)
-                        continue;
-                    const at = keys[hidesAt].at;
-                    visibilityOf.set(ch.target, g.node(`${hint}.flag`, 'at-least@1', [u01, g.constant(round6(at), 'ratio', `${hint}.at`)], 'value'));
-                    reauthored = true;
-                    notes.push({
-                        code: 'RE_AUTHORED_VISIBILITY',
-                        part: ch.target,
-                        detail: `V2 hid ${ch.target} by scaling it to 0 and grew it to full size between ${keys[hidesAt - 1].at} and ${at} of parameter ${p.name}. V3 gives the part its own dimensions at all times and a visibility flag that turns on at ${at}. Identical to V2 below ${keys[hidesAt - 1].at} (hidden) and at ${at} and above (full size); inside that band V2 drew a growing part and V3 draws none. The growth was a way of spelling on and off, so it is re-authored, not floored to a small size`
-                    });
-                    continue;
-                }
-                const twoKeys = keys.length === 2 && keys[0].at === 0 && keys[1].at === 1;
-                const entry = scaleOf.get(ch.target) ?? {};
-                let ok = true;
-                for (const axis of axes) {
-                    if (!claim(`${ch.target}/scale/${axis}`, p.name, ch.target)) {
-                        ok = false;
-                        break;
-                    }
-                    const hint = `${p.name}.${ch.target}.scale.${axis}`;
-                    const f = twoKeys
-                        ? affineRatio(p, keys[0].value[axis], keys[1].value[axis], hint)
-                        : curveRatio(p, keys.map(k => ({ at: k.at, value: k.value[axis] })), hint);
-                    if (f === undefined) {
-                        ok = false;
-                        break;
-                    }
-                    entry[axis] = f;
-                }
-                if (!ok)
-                    continue;
-                scaleOf.set(ch.target, entry);
-                const ranges = scaleRangeOf.get(ch.target) ?? {};
-                for (const axis of axes) {
-                    const vs = keys.map(k => k.value[axis]);
-                    ranges[axis] = { min: Math.min(...vs), max: Math.max(...vs) };
-                }
-                scaleRangeOf.set(ch.target, ranges);
-                const shape = twoKeys ? `${keys[0].value[axes[0]]} → ${keys[1].value[axes[0]]} on ${axes[0]}` : `${keys.length} keys on ${axes[0]}: ${keys.map(k => `${k.at}:${k.value[axes[0]]}`).join(' ')}`;
-                notes.push({ code: 'STATE_DIMENSION', part: ch.target, detail: `dimensions on ${axes.join(', ')} follow parameter ${p.name} (${shape}); the occupancy must hold over its range` });
-                continue;
-            }
-            if (axes.length === 0) {
-                notes.push({ code: 'MOTION_STATIC_CHANNEL', part: ch.target, detail: `parameter ${p.name} has a ${ch.path} channel whose keys do not change; nothing to write` });
-                continue;
-            }
-            if (axes.length > 1) {
-                refusals.push({ code: 'MOTION_COMPOUND_CHANNEL', part: ch.target, detail: `${ch.path} varies on ${axes.join(', ')} at once; one axis per channel is covered` });
-                continue;
-            }
-            if (!twoKeyLinear(ch, p.name))
-                continue;
-            const axis = axes[0];
-            if (!claim(`${ch.target}/${ch.path}/${axis}`, p.name, ch.target))
-                continue;
-            const q = affine(p, keys[0].value[axis], keys[1].value[axis], ch.path === 'rotation' ? 'deg' : 'mm', `${p.name}.${ch.target}.${ch.path}`);
-            if (q === undefined)
-                continue;
-            if (q === null)
-                continue;
-            if (ch.path === 'rotation') {
-                if (spinOf.has(ch.target)) {
-                    refusals.push({ code: 'MOTION_MULTI_WRITER', part: ch.target, detail: 'two rotation channels on one part' });
-                    continue;
-                }
-                spinOf.set(ch.target, { axis, q });
-            }
-            else {
-                // V2 shifts a part in the figure frame by the part's world factor along that axis.
-                const f = info.get(ch.target).factor[axis];
-                const scaled = f.kind === 'one' ? q : g.mul(`${p.name}.${ch.target}.shift.${axis}`, q, f.ref);
-                const ends = [keys[0].value[axis], keys[1].value[axis]];
-                (shiftsOf.get(ch.target) ?? shiftsOf.set(ch.target, []).get(ch.target)).push({ axis, q: scaled, travel: { min: Math.min(...ends), max: Math.max(...ends) } });
-            }
-        }
-    }
-    // Clips: a driver per channel, writing a state input of its own.
-    const drivers = [];
-    for (const clip of clips) {
-        const duration = v2ClipDuration(clip);
-        if (!(duration > 0)) {
-            notes.push({ code: 'MOTION_STATIC_CLIP', detail: `animation "${clip.name}" has no duration; nothing to write` });
-            continue;
-        }
-        for (const ch of clip.channels) {
-            const owner = `clip ${clip.name}`;
-            if (ch.path === undefined) {
-                refusals.push({ code: 'ANIMATION_CHANNEL', part: ch.target, detail: `${owner} drives a joint directly; joints are driven by parameters in this contract` });
-                continue;
-            }
-            if (!partsByName.has(ch.target)) {
-                refusals.push({ code: 'ANIMATION_CHANNEL', part: ch.target, detail: `${owner} targets a part that does not exist` });
-                continue;
-            }
-            if (!info.has(ch.target))
-                continue; // refused above under its own name
-            if (ch.path === 'scale') {
-                refusals.push({ code: 'ANIMATION_CHANNEL', part: ch.target, detail: `${owner} scales the part; a scale channel is shape deformation, not covered` });
-                continue;
-            }
-            if (ch.pivot) {
-                refusals.push({ code: 'MOTION_PIVOT', part: ch.target, detail: 'a rotation pivot away from the part centre is not covered' });
-                continue;
-            }
-            const keys = ch.keys;
-            const axes = varying(keys);
-            if (axes.length === 0) {
-                notes.push({ code: 'MOTION_STATIC_CHANNEL', part: ch.target, detail: `${owner} has a ${ch.path} channel whose keys do not change; nothing to write` });
-                continue;
-            }
-            if (axes.length > 1) {
-                refusals.push({ code: 'MOTION_COMPOUND_CHANNEL', part: ch.target, detail: `${ch.path} varies on ${axes.join(', ')} at once; one axis per channel is covered` });
-                continue;
-            }
-            const axis = axes[0];
-            if (!claim(`${ch.target}/${ch.path}/${axis}`, owner, ch.target))
-                continue;
-            const values = keys.map(k => k.value[axis]);
-            const rotation = ch.path === 'rotation';
-            const stateId = rotation ? `${ch.target}.spin` : `${ch.target}.shift.${axis}`;
-            const min = Math.min(...values), max = Math.max(...values);
-            g.input(stateId, rotation ? 'deg' : 'mm', rotation ? -180 : min, rotation ? 180 : max, 'state');
-            asset.stateDefaults[stateId] = rotation ? normalise180(values[0]) : values[0];
-            drivers.push({
-                id: `${clip.name}/${ch.target}/${ch.path}`,
-                clip: clip.name,
-                state: stateId,
-                time: { unit: 's', duration },
-                keys: keys.map(k => ({ at: round6(k.at / duration), value: k.value[axis] })),
-                interpolation: ch.interpolation ?? 'linear',
-                loop: 'wrap',
-                accumulates: rotation
-            });
-            notes.push({ code: 'CLIP_TIME', detail: `animation "${clip.name}": V2 keys in seconds, last at ${duration} s; written as duration ${duration} s with fractional keys` });
-            if (rotation) {
-                if (spinOf.has(ch.target)) {
-                    refusals.push({ code: 'MOTION_MULTI_WRITER', part: ch.target, detail: 'two rotation channels on one part' });
-                    continue;
-                }
-                spinOf.set(ch.target, { axis, q: stateId });
-            }
-            else {
-                const f = info.get(ch.target).factor[axis];
-                const scaled = f.kind === 'one' ? stateId : g.mul(`${clip.name}.${ch.target}.shift.${axis}`, stateId, f.ref);
-                (shiftsOf.get(ch.target) ?? shiftsOf.set(ch.target, []).get(ch.target)).push({ axis, q: scaled, travel: { min, max } });
-            }
-        }
-    }
-    if (drivers.length)
-        asset.drivers = drivers;
-    // Joints, parents first.
-    const carrierOf = (name) => {
-        for (let p = partsByName.get(name); p; p = p.parent ? partsByName.get(p.parent) : undefined) {
-            const j = joints.find(x => x.child === p.name);
-            if (j)
-                return j;
-        }
-        return undefined;
-    };
-    const depth = (j) => {
-        const child = partsByName.get(j.child);
-        const above = child?.parent ? carrierOf(child.parent) : undefined;
-        return above ? 1 + depth(above) : 0;
-    };
-    for (const j of [...joints].sort((a, b) => depth(a) - depth(b))) {
-        const child = partsByName.get(j.child);
-        if (!child || !info.has(j.child)) {
-            refusals.push({ code: 'JOINT_CHILD', part: j.name, detail: `child "${j.child}" was not converted` });
-            continue;
-        }
-        if (info.get(j.child).repeat) {
-            refusals.push({ code: 'MOTION_REPEAT', part: j.child, detail: 'a repeated part cannot be a joint child in this contract' });
-            continue;
-        }
-        // The state input: the driving parameter's affine, or the joint's own input when nothing drives it.
-        let q;
-        const writer = jointWriter.get(j.name);
-        const limits = j.limits;
-        if (writer) {
-            const r = affine(writer.p, writer.v0, writer.v1, j.type === 'prismatic' ? 'mm' : 'deg', `${writer.p.name}.${j.name}`);
-            if (r === undefined)
-                continue;
-            if (r === null) {
-                notes.push({ code: 'MOTION_STATIC_CHANNEL', part: j.name, detail: `parameter ${writer.p.name} does not change the joint; it stays at 0` });
-                q = g.constant(0, j.type === 'prismatic' ? 'mm' : 'deg', 'zeroQ');
-            }
-            else
-                q = r;
-        }
-        else {
-            const [min, max] = limits ? [limits.min, limits.max] : j.type === 'continuous' ? [-180, 180] : [-1e6, 1e6];
-            q = g.input(j.name, j.type === 'prismatic' ? 'mm' : 'deg', min, max, 'state');
-            asset.stateDefaults[j.name] = 0;
-        }
-        if (limits && !writer)
-            rangeChanges.push({ input: j.name, part: j.name, v2: `any value; outside [${limits.min}, ${limits.max}] V2 clamped it to the limit`, v3: { min: limits.min, max: limits.max }, reason: 'V3 refuses a joint value outside its limits (INPUT_RANGE) instead of clamping' });
-        if (limits && writer)
-            notes.push({ code: 'JOINT_LIMIT', part: j.name, detail: `the joint's limits [${limits.min}, ${limits.max}] are carried by the parameter ${writer.p.name}'s own range; V3 refuses a value outside it where V2 clamped` });
-        if (j.type === 'prismatic')
-            notes.push({ code: 'PRISMATIC_TRAVEL', part: j.name, detail: 'V2 scaled the travel by the instance scale; V3 travel is the value itself, per the contract' });
-        // Sized origin: the carrying part's centre plus the rest offset scaled by that part's world factor (jointOriginPosition).
-        const attach = child.parent ? partsByName.get(child.parent) : undefined;
-        const originC = { ...j.origin, y: j.origin.y - base.y / 2 };
-        const originRef = [];
-        for (const a of AXES) {
-            let expr;
-            if (attach && info.has(attach.name)) {
-                const ai = info.get(attach.name);
-                const ac = centredPart(attach, base).transform.position;
-                const offset = c.times(`${j.name}.origin.${a}.offset`, { kind: 'const', value: round6(originC[a] - ac[a]) }, ai.factor[a]);
-                expr = { kind: 'ref', ref: g.add(`${j.name}.origin.${a}`, g.len(ai.centre[a], `${j.name}.origin.${a}.seat`), g.len(offset, `${j.name}.origin.${a}.off`)) };
-            }
-            else {
-                // No carrying part: only the instance scale moves the origin (V2 keeps the rest position).
-                const v = a === 'y' ? originC.y + base.y / 2 : originC[a];
-                expr = v === 0 ? { kind: 'const', value: 0 } : { kind: 'ref', ref: g.mul(`${j.name}.origin.${a}`, size[a], ratio(v / base[a], `${j.name}.origin.${a}.at`)) };
-            }
-            originRef.push(g.len(expr, `${j.name}.origin.${a}`));
-        }
-        const n = Math.hypot(j.axis.x, j.axis.y, j.axis.z);
-        // Full precision: the kernel accepts a unit axis to 1e-6 and normalises, but the converter does not round it.
-        const axisRefs = AXES.map(a => g.constant(j.axis[a] / n, 'ratio', `${j.name}.axis.${a}`));
-        const zeroDeg = AXES.map(() => g.constant(0, 'deg', 'deg.0'));
-        const onParent = `${j.name}.onParent`, onChild = `${j.name}.onChild`;
-        const parentJoint = attach ? carrierOf(attach.name) : undefined;
-        jointOriginOf.set(j.name, {
-            origin: [...originRef],
-            ...(parentJoint ? { above: parentJoint.name } : {}),
-            slide: j.type === 'prismatic' ? Math.max(Math.abs(limits?.min ?? 0), Math.abs(limits?.max ?? 0)) : 0
-        });
-        const restFrame = 'asset.rest';
-        const toFrame = parentJoint ? restFrame : 'asset';
-        const A = g.node(`${j.name}.frameOnParent`, 'rigid@1', [...originRef, ...zeroDeg], 'pose', { from: onParent, to: toFrame });
-        const B = g.node(`${j.name}.frameOnChild`, 'rigid@1', [...originRef, ...zeroDeg], 'pose', { from: onChild, to: restFrame });
-        const O = g.node(`${j.name}.motion`, j.type === 'prismatic' ? 'axis-slide@1' : 'axis-turn@1', [...axisRefs, q], 'pose', { from: onChild, to: onParent });
-        let M = g.node(`${j.name}.attach`, 'attach@1', [A, O, B], 'pose');
-        if (parentJoint)
-            M = g.node(`${j.name}.chain`, 'compose@1', [motionOf.get(parentJoint.name), M], 'pose');
-        motionOf.set(j.name, M);
-    }
-    return { reauthored };
-}
-function normalise180(deg) {
-    const w = ((((deg + 180) % 360) + 360) % 360) - 180;
-    return w === 180 ? -180 : w;
-}
-//# sourceMappingURL=v3-from-v2.js.map