@ludic-labs/assembly 0.0.0-stage → 0.4.0

package/dist/compiler.js

@@ -0,0 +1,1264 @@
+import { requireValue } from "./required.js";
+import { MeshBuilder } from "./compat.js";
+import { appendMesh, emptyMesh, meshBounds, removeDegenerateTriangles, sourceHash, validateMesh, } from "./mesh.js";
+import { add, applyPoint, applyVector, compose, quantize, sub, translation as moveBy } from "./math.js";
+import { DEFAULT_SIDES, DEFAULT_SPHERE_SIDES, MAX_SIDES, MIN_SIDES, alongSegment, axisRotation, coil, legacyCoil, cone, ellipsoid, eulerRotation, extrude, frustum, isIdentity, lathe, orientProfile, outlineArea, outlineSelfIntersects, profileSelfIntersects, transformMesh, wedge, } from "./shapes.js";
+import { AssetCompileError } from "./diagnostics.js";
+export { AssetCompileError };
+export const SCHEMA = "asset-assembly/0.1";
+/** Characters: joints, mirrored sides, slots, identities, states and limbs. */
+export const SCHEMA_V2 = "asset-assembly/0.2";
+/** Schema 0.2 plus rotations, arrays, sided round shapes, spheres, cones, wedges, lathes and extrusions. */
+export const SCHEMA_V3 = "asset-assembly/0.3";
+export const AXES = {
+    "+x": [1, 0, 0],
+    "-x": [-1, 0, 0],
+    "+y": [0, 1, 0],
+    "-y": [0, -1, 0],
+    "+z": [0, 0, 1],
+    "-z": [0, 0, -1],
+};
+export const ANCHORS = [
+    "center",
+    "top-center",
+    "bottom-center",
+    "left-center",
+    "right-center",
+    "front-center",
+    "back-center",
+];
+const SHAPE_FIELDS = {
+    box: ["size", "bevel"],
+    cylinder: ["radius", "height"],
+    funnel: ["bottomRadius", "topRadius", "height"],
+    beam: ["from", "to", "width"],
+    tube: ["from", "to", "radius"],
+    coil: ["radius", "thickness"],
+};
+const SHAPE_FIELDS_V3 = {
+    ...SHAPE_FIELDS,
+    cylinder: ["radius", "height", "sides"],
+    funnel: ["bottomRadius", "topRadius", "height", "sides"],
+    tube: ["from", "to", "radius", "sides"],
+    coil: ["radius", "thickness", "sides"],
+    sphere: ["radius", "sides"],
+    ellipsoid: ["size", "sides"],
+    cone: ["radius", "height", "sides"],
+    wedge: ["size"],
+    lathe: ["profile", "sides"],
+    extrude: ["outline", "height"],
+};
+/** Largest number of instances one array may create. */
+export const MAX_ARRAY_COUNT = 256;
+const pointer = (s) => s.replaceAll("~", "~0").replaceAll("/", "~1");
+/** A string value as itself; anything else as "", without coercion (which can throw or alias). */
+const text = (v) => (typeof v === "string" ? v : "");
+const strings = (v) => v.filter((o) => typeof o === "string");
+const record = (v) => !!v &&
+    typeof v === "object" &&
+    !Array.isArray(v) &&
+    (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
+const has = (v, k) => Object.hasOwn(v, k);
+const idPattern = /^[A-Za-z][A-Za-z0-9_-]{0,79}$/;
+/** Strict runtime validation. Unknown fields fail instead of being silently ignored. */
+function schemaDiagnostics(input) {
+    const diagnostics = [];
+    const fail = (path, message, code = "SCHEMA_ERROR", received) => diagnostics.push({ code, path, message, ...(received === undefined ? {} : { received }) });
+    const obj = (v, path, allowed, required = []) => {
+        if (!record(v)) {
+            fail(path, "Expected a plain JSON object.");
+            return false;
+        }
+        for (const k of Object.keys(v))
+            if (!allowed.includes(k))
+                fail(`${path}/${pointer(k)}`, "Unknown field or unsupported operation.", "UNKNOWN_FIELD");
+        for (const k of required)
+            if (!has(v, k))
+                fail(`${path}/${k}`, "Required field is missing.");
+        return true;
+    };
+    const v3 = record(input) && input.schema === SCHEMA_V3, v2 = v3 || (record(input) && input.schema === SCHEMA_V2);
+    if (!obj(input, "", [
+        "schema",
+        "units",
+        "parameters",
+        "materials",
+        "groups",
+        "parts",
+        "groundPivot",
+        ...(v2 ? ["joints", "slots", "identities", "states", "limbs"] : []),
+    ], ["schema", "units", "materials", "parts"]))
+        return diagnostics;
+    const root = input;
+    if (root.schema !== SCHEMA && !v2)
+        fail("/schema", `Expected ${SCHEMA}, ${SCHEMA_V2} or ${SCHEMA_V3}.`, "UNSUPPORTED_SCHEMA", root.schema);
+    if (!["meters", "tiles"].includes(text(root.units)))
+        fail("/units", "Choose meters or tiles.");
+    const params = record(root.parameters) ? root.parameters : {};
+    const scalar = (v, path) => {
+        if (typeof v === "number") {
+            if (!Number.isFinite(v))
+                fail(path, "Number must be finite.", "NON_FINITE_VALUE");
+            return;
+        }
+        if (obj(v, path, ["parameter"], ["parameter"])) {
+            const name = v.parameter;
+            if (typeof name !== "string" || !has(params, name))
+                fail(`${path}/parameter`, "Unknown scalar parameter.", "UNKNOWN_PARAMETER", name);
+        }
+    };
+    const point = (v, path) => {
+        if (obj(v, path, ["x", "y", "z"], ["x", "y", "z"]))
+            for (const a of ["x", "y", "z"])
+                scalar(v[a], `${path}/${a}`);
+    };
+    const dictionary = (v, path, fn, min = 0, max = 256) => {
+        if (!record(v)) {
+            fail(path, "Expected a dictionary of named objects.");
+            return;
+        }
+        if (Object.keys(v).length < min || Object.keys(v).length > max)
+            fail(path, `Expected ${min}–${max} entries.`, "GEOMETRY_BUDGET");
+        for (const [id, entry] of Object.entries(v)) {
+            if (!idPattern.test(id))
+                fail(`${path}/${pointer(id)}`, "IDs must start with a letter and contain letters, digits, underscores or hyphens.");
+            fn(entry, `${path}/${pointer(id)}`, id);
+        }
+    };
+    if (root.parameters !== undefined)
+        dictionary(root.parameters, "/parameters", (v, p) => {
+            if (typeof v !== "number" || !Number.isFinite(v))
+                fail(p, "Parameter must be a finite numeric scalar.", "NON_FINITE_VALUE");
+        });
+    dictionary(root.materials, "/materials", (v, p) => {
+        if (obj(v, p, ["color", "tintable"], ["color"])) {
+            const m = v;
+            if (typeof m.color !== "string" || !/^#[0-9a-fA-F]{6}$/.test(m.color))
+                fail(`${p}/color`, "Expected #rrggbb.");
+            if (m.tintable !== undefined && typeof m.tintable !== "boolean")
+                fail(`${p}/tintable`, "Expected a boolean.");
+        }
+    }, 1);
+    if (root.groups !== undefined)
+        dictionary(root.groups, "/groups", (v, p) => {
+            if (obj(v, p, ["parent", "position"], ["position"])) {
+                const g = v;
+                point(g.position, `${p}/position`);
+                if (g.parent !== undefined && typeof g.parent !== "string")
+                    fail(`${p}/parent`, "Expected a group ID.");
+            }
+        });
+    if (root.groundPivot !== undefined)
+        point(root.groundPivot, "/groundPivot");
+    dictionary(root.parts, "/parts", (v, p) => {
+        if (!obj(v, p, [
+            "shape",
+            "material",
+            "placement",
+            "parent",
+            "anchors",
+            ...(v2 ? ["joint", "sides", "slot", "option", "when"] : []),
+            ...(v3 ? ["rotation", "array"] : []),
+        ], ["shape", "material", "placement"]))
+            return;
+        const part = v;
+        if (v2) {
+            if (part.joint !== undefined && typeof part.joint !== "string")
+                fail(`${p}/joint`, "Expected a joint ID.");
+            if (part.sides !== undefined && part.sides !== "both")
+                fail(`${p}/sides`, 'Expected "both". Author the left (−X) side; the right side is mirrored.');
+            if ((part.slot === undefined) !== (part.option === undefined))
+                fail(`${p}/${part.slot === undefined ? "slot" : "option"}`, "Declare slot and option together.");
+            else if (part.slot !== undefined) {
+                const options = record(root.slots) ? root.slots[text(part.slot)] : null;
+                if (typeof part.slot !== "string" || !Array.isArray(options))
+                    fail(`${p}/slot`, "Unknown slot.", "UNKNOWN_SLOT", part.slot);
+                else if (!options.includes(part.option))
+                    diagnostics.push({
+                        code: "UNKNOWN_SLOT_OPTION",
+                        path: `${p}/option`,
+                        message: "Choose an option declared by this slot.",
+                        received: part.option,
+                        expected: strings(options),
+                    });
+            }
+            if (part.when !== undefined) {
+                const states = record(root.states) ? root.states : {};
+                dictionary(part.when, `${p}/when`, (values, wp, channel) => {
+                    const declared = states[channel];
+                    if (!Array.isArray(declared)) {
+                        diagnostics.push({
+                            code: "UNKNOWN_STATE",
+                            path: wp,
+                            message: "Choose a state channel declared in states.",
+                            received: channel,
+                            expected: Object.keys(states).sort(),
+                        });
+                        return;
+                    }
+                    if (!Array.isArray(values) || values.length < 1 || new Set(values).size !== values.length)
+                        fail(wp, "Expected an array of distinct states in which the part is visible.");
+                    else
+                        values.forEach((value, i) => {
+                            if (!declared.includes(value))
+                                diagnostics.push({
+                                    code: "UNKNOWN_STATE_VALUE",
+                                    path: `${wp}/${i}`,
+                                    message: "Choose a state declared by this channel.",
+                                    received: value,
+                                    expected: strings(declared),
+                                });
+                        });
+                });
+            }
+            if (part.sides !== undefined && record(part.placement) && part.placement.type === "repeat")
+                fail(`${p}/sides`, "Mirrored sides cannot be combined with corner repetition.", "UNSUPPORTED_COMBINATION");
+        }
+        if (typeof part.material !== "string" || !record(root.materials) || !has(root.materials, part.material))
+            fail(`${p}/material`, "Unknown material ID.", "UNKNOWN_MATERIAL", part.material);
+        if (part.parent !== undefined && typeof part.parent !== "string")
+            fail(`${p}/parent`, "Expected a group ID.");
+        if (part.anchors !== undefined)
+            dictionary(part.anchors, `${p}/anchors`, (v, p) => point(v, p));
+        const s = part.shape;
+        if (!record(s)) {
+            fail(`${p}/shape`, "Expected a shape object.");
+            return;
+        }
+        const shapeFields = v3 ? SHAPE_FIELDS_V3 : SHAPE_FIELDS;
+        const kind = text(s.type), fields = has(shapeFields, kind) ? shapeFields[kind] : null;
+        if (!fields)
+            diagnostics.push({
+                code: "UNKNOWN_SHAPE",
+                path: `${p}/shape/type`,
+                message: v3 || !has(SHAPE_FIELDS_V3, kind) ? "Unknown primitive." : `${kind} requires ${SCHEMA_V3}.`,
+                received: s.type,
+                expected: Object.keys(shapeFields),
+            });
+        else if (obj(s, `${p}/shape`, ["type", ...fields], ["type", ...fields.filter((k) => k !== "bevel" && k !== "sides")]))
+            for (const k of fields) {
+                if (s[k] === undefined)
+                    continue;
+                if (k === "size") {
+                    if (obj(s[k], `${p}/shape/size`, ["width", "height", "depth"], ["width", "height", "depth"]))
+                        for (const a of ["width", "height", "depth"])
+                            scalar(s[k][a], `${p}/shape/size/${a}`);
+                }
+                else if (k === "from" || k === "to")
+                    point(s[k], `${p}/shape/${k}`);
+                else if (k === "sides") {
+                    if (!Number.isInteger(s[k]) || s[k] < MIN_SIDES || s[k] > MAX_SIDES)
+                        fail(`${p}/shape/sides`, `Expected an integer from ${MIN_SIDES} to ${MAX_SIDES}.`, "SCHEMA_ERROR", s[k]);
+                }
+                else if (k === "profile" || k === "outline") {
+                    const [a, b, min] = k === "profile" ? ["radius", "y", 2] : ["x", "z", 3];
+                    if (!Array.isArray(s[k]) || s[k].length < min || s[k].length > 64)
+                        fail(`${p}/shape/${k}`, `Expected an array of ${min}–64 { ${a}, ${b} } points.`);
+                    else
+                        s[k].forEach((v, i) => {
+                            if (obj(v, `${p}/shape/${k}/${i}`, [a, b], [a, b]))
+                                for (const c of [a, b])
+                                    scalar(v[c], `${p}/shape/${k}/${i}/${c}`);
+                        });
+                }
+                else
+                    scalar(s[k], `${p}/shape/${k}`);
+            }
+        if (v3 && part.rotation !== undefined && obj(part.rotation, `${p}/rotation`, ["x", "y", "z"])) {
+            const r = part.rotation;
+            if (!Object.keys(r).length)
+                fail(`${p}/rotation`, "Give at least one of x, y or z in degrees.");
+            for (const a of ["x", "y", "z"])
+                if (r[a] !== undefined)
+                    scalar(r[a], `${p}/rotation/${a}`);
+        }
+        if (v3 && part.array !== undefined)
+            arrayDiagnostics(part, p, fail, obj, scalar, point);
+        const placement = part.placement;
+        if (!record(placement)) {
+            fail(`${p}/placement`, "Expected a placement object.");
+            return;
+        }
+        const pk = text(placement.type), pf = {
+            absolute: ["selfAnchor", "position"],
+            attach: ["selfAnchor", "target", "offset"],
+            repeat: ["selfAnchor", "pattern", "target", "edgeInset"],
+        };
+        if (!has(pf, pk)) {
+            fail(`${p}/placement/type`, "Unknown placement relationship.", "UNKNOWN_PLACEMENT", pk);
+            return;
+        }
+        obj(placement, `${p}/placement`, ["type", ...requireValue(pf[pk])], ["type", ...requireValue(pf[pk]).filter((k) => k !== "offset")]);
+        if (typeof placement.selfAnchor !== "string")
+            fail(`${p}/placement/selfAnchor`, "Expected an anchor name.");
+        if (pk === "absolute")
+            point(placement.position, `${p}/placement/position`);
+        else {
+            const t = placement.target, key = pk === "attach" ? "anchor" : "face";
+            if (obj(t, `${p}/placement/target`, ["part", key], ["part", key])) {
+                if (typeof t.part !== "string")
+                    fail(`${p}/placement/target/part`, "Expected a part or instance ID.");
+                if (typeof t[key] !== "string")
+                    fail(`${p}/placement/target/${key}`, "Expected a name.");
+            }
+            if (pk === "attach" && placement.offset !== undefined)
+                point(placement.offset, `${p}/placement/offset`);
+            if (pk === "repeat") {
+                if (placement.pattern !== "corners")
+                    fail(`${p}/placement/pattern`, "Only corners repetition is supported.", "UNKNOWN_PATTERN", placement.pattern);
+                if (record(t) && t.face !== "top" && t.face !== "bottom")
+                    fail(`${p}/placement/target/face`, "Choose top or bottom.");
+                if (obj(placement.edgeInset, `${p}/placement/edgeInset`, ["x", "z"], ["x", "z"]))
+                    for (const a of ["x", "z"])
+                        scalar(placement.edgeInset[a], `${p}/placement/edgeInset/${a}`);
+            }
+        }
+    }, 1);
+    if (v2)
+        jointDiagnostics(root, diagnostics, obj, point, dictionary, v3);
+    return diagnostics;
+}
+/** Structural rules for schema 0.3 arrays. */
+function arrayDiagnostics(part, p, fail, obj, scalar, point) {
+    const a = part.array, path = `${p}/array`;
+    if (!record(a)) {
+        fail(path, "Expected an array object with a type of line, grid or radial.");
+        return;
+    }
+    const count = (v, at, min) => {
+        if (!Number.isInteger(v) || v < min || v > MAX_ARRAY_COUNT)
+            fail(at, `Expected an integer count from ${min} to ${MAX_ARRAY_COUNT}.`, "SCHEMA_ERROR", v);
+    };
+    const flag = (k) => {
+        if (a[k] !== undefined && typeof a[k] !== "boolean")
+            fail(`${path}/${k}`, "Expected a boolean.");
+    };
+    if (a.type === "line") {
+        if (!obj(a, path, ["type", "count", "step", "centered"], ["type", "count", "step"]))
+            return;
+        count(a.count, `${path}/count`, 2);
+        point(a.step, `${path}/step`);
+        flag("centered");
+    }
+    else if (a.type === "grid") {
+        if (!obj(a, path, ["type", "count", "spacing", "centered"], ["type", "count", "spacing"]))
+            return;
+        if (obj(a.count, `${path}/count`, ["x", "y", "z"])) {
+            const c = a.count;
+            for (const k of ["x", "y", "z"])
+                if (c[k] !== undefined)
+                    count(c[k], `${path}/count/${k}`, 1);
+            const total = ["x", "y", "z"].reduce((n, k) => n * (Number.isInteger(c[k]) ? c[k] : 1), 1);
+            if (total < 2 || total > MAX_ARRAY_COUNT)
+                fail(`${path}/count`, `A grid needs 2–${MAX_ARRAY_COUNT} instances in total.`, "GEOMETRY_BUDGET", total);
+        }
+        if (obj(a.spacing, `${path}/spacing`, ["x", "y", "z"])) {
+            const sp = a.spacing;
+            for (const k of ["x", "y", "z"])
+                if (sp[k] !== undefined)
+                    scalar(sp[k], `${path}/spacing/${k}`);
+        }
+        flag("centered");
+    }
+    else if (a.type === "radial") {
+        if (!obj(a, path, ["type", "count", "radius", "axis", "start", "sweep", "orient"], ["type", "count", "radius"]))
+            return;
+        count(a.count, `${path}/count`, 2);
+        scalar(a.radius, `${path}/radius`);
+        if (a.axis !== undefined && !["x", "y", "z"].includes(text(a.axis)))
+            fail(`${path}/axis`, "Choose x, y or z.", "UNKNOWN_AXIS", a.axis);
+        for (const k of ["start", "sweep"])
+            if (a[k] !== undefined)
+                scalar(a[k], `${path}/${k}`);
+        flag("orient");
+    }
+    else
+        fail(`${path}/type`, "Choose line, grid or radial.", "UNKNOWN_PATTERN", a.type);
+    if (record(part.placement) && part.placement.type === "repeat")
+        fail(path, "Arrays cannot be combined with corner repetition.", "UNSUPPORTED_COMBINATION");
+    if (part.sides !== undefined)
+        fail(path, "Arrays cannot be combined with mirrored sides.", "UNSUPPORTED_COMBINATION");
+}
+/** Structural rules for the schema 0.2 fields. */
+function jointDiagnostics(root, diagnostics, obj, point, dictionary, v3 = false) {
+    const fail = (path, message, code = "SCHEMA_ERROR", extra = {}) => diagnostics.push({ code, path, message, ...extra });
+    if (root.states !== undefined)
+        dictionary(root.states, "/states", (v, p) => {
+            if (!Array.isArray(v) || v.length < 2 || v.length > 16) {
+                fail(p, "Expected an array of 2–16 states; the first is the rest state.");
+                return;
+            }
+            v.forEach((state, i) => {
+                if (typeof state !== "string" || !idPattern.test(state))
+                    fail(`${p}/${i}`, "State IDs must start with a letter and contain letters, digits, _ or -.");
+                else if (v.indexOf(state) !== i)
+                    fail(`${p}/${i}`, "Duplicate state.", "DUPLICATE_NAME");
+            });
+        });
+    if (root.limbs !== undefined)
+        dictionary(root.limbs, "/limbs", (v, p) => {
+            if (!obj(v, p, ["sides", "effector", "reach", "level"], ["effector", "reach"]))
+                return;
+            const limb = v;
+            if (limb.sides !== undefined && limb.sides !== "both")
+                fail(`${p}/sides`, 'Expected "both".');
+            if (obj(limb.effector, `${p}/effector`, ["part", "anchor"], ["part", "anchor"])) {
+                const e = limb.effector;
+                if (typeof e.part !== "string")
+                    fail(`${p}/effector/part`, "Expected a part or instance ID.");
+                else {
+                    const target = record(root.parts) ? root.parts[requireValue(e.part.split("/")[0])] : null;
+                    if (record(target) && target.slot !== undefined)
+                        fail(`${p}/effector/part`, "Limb effectors cannot be slotted parts.", "SLOTTED_LIMB");
+                }
+                if (typeof e.anchor !== "string")
+                    fail(`${p}/effector/anchor`, "Expected an anchor name.");
+            }
+            const ref = (r, rp) => {
+                if (obj(r, rp, ["joint", "dof"], ["joint", "dof"]))
+                    for (const k of ["joint", "dof"])
+                        if (typeof r[k] !== "string")
+                            fail(`${rp}/${k}`, "Expected a name.");
+            };
+            if (!Array.isArray(limb.reach) || limb.reach.length < 1 || limb.reach.length > 3)
+                fail(`${p}/reach`, "Expected one to three { joint, dof } entries, from the chain root outward.");
+            else
+                limb.reach.forEach((r, i) => ref(r, `${p}/reach/${i}`));
+            if (limb.level !== undefined)
+                ref(limb.level, `${p}/level`);
+        });
+    const slots = record(root.slots) ? root.slots : {};
+    if (root.slots !== undefined)
+        dictionary(root.slots, "/slots", (v, p) => {
+            if (!Array.isArray(v) || v.length < 1 || v.length > 32) {
+                fail(p, "Expected an array of 1–32 option IDs; the first option is the default.");
+                return;
+            }
+            v.forEach((option, i) => {
+                if (typeof option !== "string" || !idPattern.test(option))
+                    fail(`${p}/${i}`, "Option IDs must start with a letter and contain letters, digits, _ or -.");
+                else if (v.indexOf(option) !== i)
+                    fail(`${p}/${i}`, "Duplicate option.", "DUPLICATE_NAME");
+            });
+        });
+    if (root.joints !== undefined)
+        dictionary(root.joints, "/joints", (v, p) => {
+            if (!obj(v, p, ["parent", "sides", "face", "pivot", "dofs"], ["pivot", "dofs"]))
+                return;
+            const joint = v;
+            if (joint.face !== undefined && typeof joint.face !== "boolean")
+                fail(`${p}/face`, "Expected a boolean.");
+            if (joint.parent !== undefined && typeof joint.parent !== "string")
+                fail(`${p}/parent`, "Expected a joint ID.");
+            if (joint.sides !== undefined && joint.sides !== "both")
+                fail(`${p}/sides`, 'Expected "both". Author the left (−X) side; the right side is mirrored.');
+            const pivot = joint.pivot;
+            if (record(pivot) && has(pivot, "position")) {
+                if (obj(pivot, `${p}/pivot`, ["position"], ["position"]))
+                    point(pivot.position, `${p}/pivot/position`);
+            }
+            else if (obj(pivot, `${p}/pivot`, ["part", "anchor"], ["part", "anchor"])) {
+                const r = pivot;
+                if (typeof r.part !== "string")
+                    fail(`${p}/pivot/part`, "Expected a part or instance ID.");
+                else {
+                    const target = record(root.parts) ? root.parts[requireValue(r.part.split("/")[0])] : null;
+                    if (record(target) && target.slot !== undefined)
+                        fail(`${p}/pivot/part`, "Every identity shares one skeleton, so joints cannot pivot on slotted parts. Pivot on a part outside slots or use a position.", "SLOTTED_PIVOT", { received: r.part });
+                }
+                if (typeof r.anchor !== "string")
+                    fail(`${p}/pivot/anchor`, "Expected an anchor name.");
+            }
+            if (!Array.isArray(joint.dofs) || joint.dofs.length < 1 || joint.dofs.length > 3) {
+                fail(`${p}/dofs`, "Expected an ordered array of 1–3 degrees of freedom.");
+                return;
+            }
+            const names = [];
+            joint.dofs.forEach((dof, i) => {
+                const dp = `${p}/dofs/${i}`;
+                if (!obj(dof, dp, ["name", "axis", "limits", ...(v3 ? ["continuous"] : [])], ["name", "axis", "limits"]))
+                    return;
+                const d = dof;
+                if (d.continuous !== undefined && typeof d.continuous !== "boolean")
+                    fail(`${dp}/continuous`, "Expected a boolean.");
+                if (typeof d.name !== "string" || !idPattern.test(d.name))
+                    fail(`${dp}/name`, "DOF names must start with a letter and contain letters, digits, _ or -.");
+                else if (names.includes(d.name))
+                    fail(`${dp}/name`, "Duplicate DOF name.", "DUPLICATE_NAME");
+                else
+                    names.push(d.name);
+                if (typeof d.axis !== "string" || !has(AXES, d.axis))
+                    fail(`${dp}/axis`, "Choose a signed axis.", "UNKNOWN_AXIS", {
+                        received: d.axis,
+                        expected: Object.keys(AXES),
+                    });
+                const l = d.limits;
+                if (!Array.isArray(l) ||
+                    l.length !== 2 ||
+                    !l.every((n) => typeof n === "number" && Number.isFinite(n)))
+                    fail(`${dp}/limits`, "Expected [minimum, maximum] in degrees.");
+                else {
+                    // Continuous DOFs (schema 0.3) may key up to ten turns per cycle.
+                    const bound = v3 && d.continuous === true ? 3600 : 360;
+                    if (!(l[0] < l[1]) || l[0] > 0 || l[1] < 0 || l[0] < -bound || l[1] > bound)
+                        fail(`${dp}/limits`, `Limits must satisfy −${bound} ≤ minimum ≤ 0 ≤ maximum ≤ ${bound} with minimum < maximum; the rest value is 0.`, "JOINT_LIMIT", { received: l });
+                }
+            });
+        });
+    const params = record(root.parameters) ? root.parameters : {}, materials = record(root.materials) ? root.materials : {};
+    if (root.identities !== undefined)
+        dictionary(root.identities, "/identities", (v, p) => {
+            if (!obj(v, p, ["parameters", "materials", "slots"]))
+                return;
+            const identity = v;
+            const overrides = (field, known, check) => {
+                if (identity[field] === undefined)
+                    return;
+                dictionary(identity[field], `${p}/${field}`, (value, vp, key) => {
+                    if (!has(known, key))
+                        fail(vp, `Identities may only override declared ${field}.`, "UNKNOWN_IDENTITY_OVERRIDE", {
+                            received: key,
+                            expected: Object.keys(known).sort(),
+                        });
+                    else
+                        check(value, vp, key);
+                });
+            };
+            overrides("parameters", params, (value, vp) => {
+                if (typeof value !== "number" || !Number.isFinite(value))
+                    fail(vp, "Parameter must be a finite numeric scalar.", "NON_FINITE_VALUE");
+            });
+            overrides("materials", materials, (value, vp) => {
+                if (obj(value, vp, ["color"], ["color"])) {
+                    const c = value.color;
+                    if (typeof c !== "string" || !/^#[0-9a-fA-F]{6}$/.test(c))
+                        fail(`${vp}/color`, "Expected #rrggbb.");
+                }
+            });
+            overrides("slots", slots, (value, vp, key) => {
+                const options = slots[key];
+                if (Array.isArray(options) && !options.includes(value))
+                    fail(vp, "Choose an option declared by this slot.", "UNKNOWN_SLOT_OPTION", {
+                        received: value,
+                        expected: strings(options),
+                    });
+            });
+        });
+}
+const neg = (v) => (v === 0 ? 0 : -v);
+const mirrorPoint = (p) => [neg(p[0]), p[1], p[2]];
+const swapSide = (ref) => ref.endsWith("/left")
+    ? `${ref.slice(0, -5)}/right`
+    : ref.endsWith("/right")
+        ? `${ref.slice(0, -6)}/left`
+        : ref;
+/** Exact reflection across the asset's X = 0 plane, with winding reversed to keep faces outward. */
+function mirrorInstance(left, id) {
+    const m = left.mesh, mesh = {
+        positions: m.positions.map((v, i) => (i % 3 === 0 ? neg(v) : v)),
+        normals: m.normals.map((v, i) => (i % 3 === 0 ? neg(v) : v)),
+        colors: [...m.colors],
+        indices: [],
+    };
+    for (let i = 0; i < m.indices.length; i += 3)
+        mesh.indices.push(requireValue(m.indices[i]), requireValue(m.indices[i + 2]), requireValue(m.indices[i + 1]));
+    const swap = { "left-center": "right-center", "right-center": "left-center" };
+    return {
+        id,
+        part: left.part,
+        material: left.material,
+        translation: mirrorPoint(left.translation),
+        bounds: {
+            min: [neg(left.bounds.max[0]), left.bounds.min[1], left.bounds.min[2]],
+            max: [neg(left.bounds.min[0]), left.bounds.max[1], left.bounds.max[2]],
+        },
+        anchors: Object.fromEntries(Object.entries(left.anchors).map(([k, v]) => [swap[k] ?? k, mirrorPoint(v)])),
+        mesh,
+        joint: left.joint === undefined || left.joint === null ? left.joint : swapSide(left.joint),
+        ...(left.when ? { when: structuredClone(left.when) } : {}),
+    };
+}
+function resolve(spec, options) {
+    const stop = (code, path, message, extra = {}) => {
+        throw new AssetCompileError([{ code, path, message, ...extra }]);
+    };
+    const v3 = spec.schema === SCHEMA_V3, v2 = v3 || spec.schema === SCHEMA_V2;
+    let identity = null;
+    if (options.identity !== undefined) {
+        if (!v2 || !spec.identities || !has(spec.identities, options.identity))
+            stop("UNKNOWN_IDENTITY", "/identities", "Choose an identity declared by this asset.", {
+                received: options.identity,
+                expected: Object.keys(spec.identities ?? {}).sort(),
+            });
+        identity = options.identity;
+    }
+    const chosen = identity === null ? null : requireValue(requireValue(spec.identities)[identity]);
+    const params = { ...spec.parameters, ...chosen?.parameters };
+    const materials = structuredClone(spec.materials);
+    for (const [id, m] of Object.entries(chosen?.materials ?? {}))
+        requireValue(materials[id]).color = m.color;
+    const slots = {};
+    for (const id of Object.keys(spec.slots ?? {}).sort())
+        slots[id] = chosen?.slots?.[id] ?? requireValue(requireValue(requireValue(spec.slots)[id])[0]);
+    const active = (id) => {
+        const part = requireValue(spec.parts[id]);
+        return part.slot === undefined || slots[part.slot] === part.option;
+    };
+    /** Instances an array creates (schema 0.3). */
+    const arrayCount = (a) => a.type === "grid" ? (a.count.x ?? 1) * (a.count.y ?? 1) * (a.count.z ?? 1) : a.count;
+    /**
+     * Schema 0.3: a joint whose pivot names an arrayed part without an instance index is copied once per
+     * instance, as <joint>/0 … <joint>/n−1. Returns the number of copies, or 0.
+     */
+    const copiesOf = (id) => {
+        const j = v3 && spec.joints && has(spec.joints, id) ? requireValue(spec.joints[id]) : null;
+        if (!j || !("part" in j.pivot) || j.pivot.part.includes("/"))
+            return 0;
+        const target = has(spec.parts, j.pivot.part) ? requireValue(spec.parts[j.pivot.part]) : null;
+        return target?.array ? arrayCount(target.array) : 0;
+    };
+    const jointIds = () => Object.keys(spec.joints ?? {})
+        .flatMap((id) => {
+        const n = copiesOf(id);
+        if (n)
+            return Array.from({ length: n }, (_, k) => `${id}/${k}`);
+        return requireValue(requireValue(spec.joints)[id]).sides === "both"
+            ? [`${id}/left`, `${id}/right`]
+            : [id];
+    })
+        .sort();
+    /**
+     * Resolve a joint reference. Inside a left-side declaration a bare sided joint means the same side;
+     * inside copy k of an array a bare copied joint means its copy k.
+     */
+    const bindJoint = (ref, path, side, copy = null, count = null) => {
+        const [id, suffix, extra] = ref.split("/"), joint = spec.joints && id && has(spec.joints, id) ? spec.joints[id] : null, unknown = () => stop("UNKNOWN_JOINT", path, "Choose a joint declared by this asset.", {
+            received: ref,
+            expected: jointIds(),
+        });
+        if (!joint || extra !== undefined)
+            return unknown();
+        const copies = copiesOf(requireValue(id));
+        if (copies) {
+            if (suffix !== undefined)
+                return /^(0|[1-9][0-9]*)$/.test(suffix) && Number(suffix) < copies ? ref : unknown();
+            // A bare copied name pairs copy k with copy k only between joints copied over the same count.
+            if (copy === null || (count !== null && count !== copies))
+                return stop("AMBIGUOUS_JOINT", path, copy === null
+                    ? `Joint ${id} has one copy per array instance; choose one, for example ${id}/0.`
+                    : `Joint ${id} has ${copies} copies and this joint has ${count}; choose one, for example ${id}/0.`, {
+                    received: ref,
+                    expected: Array.from({ length: copies }, (_, k) => `${id}/${k}`),
+                });
+            if (copy >= copies)
+                return stop("JOINT_ARRAY_MISMATCH", path, `Joint ${id} has ${copies} copies; this array has more instances.`, {
+                    received: copy,
+                    expected: [String(copies)],
+                });
+            return `${id}/${copy}`;
+        }
+        if (joint.sides !== "both")
+            return suffix === undefined ? requireValue(id) : unknown();
+        if (suffix === undefined)
+            return side
+                ? `${id}/${side}`
+                : stop("AMBIGUOUS_JOINT", path, `Choose a side, for example ${id}/left.`, {
+                    received: ref,
+                    expected: [`${id}/left`, `${id}/right`],
+                });
+        return suffix === "left" || suffix === "right" ? ref : unknown();
+    };
+    const number = (s, path) => {
+        const n = typeof s === "number" ? s : requireValue(params[s.parameter]);
+        if (!Number.isFinite(n))
+            stop("NON_FINITE_VALUE", path, "Resolved value must be finite.");
+        return n;
+    };
+    const point = (p, path) => [
+        number(p.x, `${path}/x`),
+        number(p.y, `${path}/y`),
+        number(p.z, `${path}/z`),
+    ];
+    const positive = (s, path, allowZero = false) => {
+        const n = number(s, path);
+        if (n < 0 || (!allowZero && n === 0) || n > 1e6)
+            stop("IMPOSSIBLE_BOUNDS", path, `Expected ${allowZero ? "nonnegative" : "positive"} dimension at most 1000000.`);
+        return n;
+    };
+    const limits = { instances: options.maxInstances ?? 1024, triangles: options.maxTriangles ?? 200000 };
+    if (!Number.isInteger(limits.instances) ||
+        limits.instances < 1 ||
+        !Number.isInteger(limits.triangles) ||
+        limits.triangles < 1)
+        stop("GEOMETRY_BUDGET", "", "Budgets must be positive integers.");
+    const groupMap = new Map(), groupStack = new Set();
+    const group = (id) => {
+        if (id === undefined)
+            return [0, 0, 0];
+        if (groupMap.has(id))
+            return requireValue(groupMap.get(id));
+        const path = `/groups/${pointer(id)}`;
+        if (!spec.groups || !has(spec.groups, id))
+            return stop("UNKNOWN_REFERENCE", path, "Unknown parent group.", { received: id });
+        if (groupStack.has(id))
+            return stop("DEPENDENCY_CYCLE", path, "Cyclic group hierarchy.");
+        groupStack.add(id);
+        const g = requireValue(spec.groups[id]), p = add(group(g.parent), point(g.position, `${path}/position`));
+        groupStack.delete(id);
+        groupMap.set(id, p);
+        return p;
+    };
+    for (const id of Object.keys(spec.groups ?? {}).sort())
+        group(id);
+    const built = new Map(), visiting = new Set();
+    let triangles = 0, instanceCount = 0;
+    /** Schema 0.3 part orientation, or null when the part is not rotated. */
+    const partRotation = (part, path) => {
+        if (!v3 || !part.rotation)
+            return null;
+        const angle = (k) => {
+            const v = requireValue(part.rotation)[k];
+            if (v === undefined)
+                return 0;
+            const n = number(v, `${path}/rotation/${k}`);
+            if (Math.abs(n) > 360)
+                stop("INVALID_ROTATION", `${path}/rotation/${k}`, "Rotations are degrees from −360 to 360.", {
+                    received: n,
+                });
+            return n;
+        };
+        const m = eulerRotation(angle("x"), angle("y"), angle("z"));
+        return isIdentity(m) ? null : m;
+    };
+    const sidesOf = (s, fallback = DEFAULT_SIDES) => s.sides ?? fallback;
+    const localMesh = (part, path, rotation) => {
+        const s = part.shape, m = new MeshBuilder(), color = parseInt(requireValue(materials[part.material]).color.slice(1), 16);
+        const dim = (v, k, zero = false) => positive(v, `${path}/shape/${k}`, zero);
+        switch (s.type) {
+            case "box": {
+                const w = dim(s.size.width, "size/width"), h = dim(s.size.height, "size/height"), d = dim(s.size.depth, "size/depth"), bevel = s.bevel === undefined ? 0.018 : dim(s.bevel, "bevel", true);
+                if (bevel > 0)
+                    m.box(0, 0, 0, w, h, d, color, bevel);
+                else {
+                    const bottom = [
+                        [-w / 2, 0, -d / 2],
+                        [w / 2, 0, -d / 2],
+                        [w / 2, 0, d / 2],
+                        [-w / 2, 0, d / 2],
+                    ], top = bottom.map(([x, , z]) => [x, h, z]), center = [0, h / 2, 0];
+                    m.face(bottom, color, center);
+                    m.face(top, color, center);
+                    for (let i = 0; i < 4; i++)
+                        m.face([
+                            requireValue(bottom[i]),
+                            requireValue(bottom[(i + 1) % 4]),
+                            requireValue(top[(i + 1) % 4]),
+                            requireValue(top[i]),
+                        ], color, center);
+                }
+                break;
+            }
+            case "cylinder": {
+                const r = dim(s.radius, "radius"), h = dim(s.height, "height");
+                if (sidesOf(s) === DEFAULT_SIDES)
+                    m.cylinder(0, 0, 0, r, h, color);
+                else
+                    frustum(m, sidesOf(s), r, r, h, color);
+                break;
+            }
+            case "funnel": {
+                const b = dim(s.bottomRadius, "bottomRadius"), t = dim(s.topRadius, "topRadius"), h = dim(s.height, "height");
+                if (sidesOf(s) === DEFAULT_SIDES)
+                    m.funnel(0, 0, 0, b, t, h, color);
+                else
+                    frustum(m, sidesOf(s), b, t, h, color);
+                break;
+            }
+            case "sphere": {
+                const r = dim(s.radius, "radius");
+                ellipsoid(m, sidesOf(s, DEFAULT_SPHERE_SIDES), 2 * r, 2 * r, 2 * r, color);
+                break;
+            }
+            case "ellipsoid":
+                ellipsoid(m, sidesOf(s, DEFAULT_SPHERE_SIDES), dim(s.size.width, "size/width"), dim(s.size.height, "size/height"), dim(s.size.depth, "size/depth"), color);
+                break;
+            case "cone":
+                cone(m, sidesOf(s), dim(s.radius, "radius"), dim(s.height, "height"), color);
+                break;
+            case "wedge":
+                wedge(m, dim(s.size.width, "size/width"), dim(s.size.height, "size/height"), dim(s.size.depth, "size/depth"), color);
+                break;
+            case "lathe": {
+                const profile = s.profile.map((q, i) => [
+                    dim(q.radius, `profile/${i}/radius`, true),
+                    number(q.y, `${path}/shape/profile/${i}/y`),
+                ]);
+                profile.forEach(([r, y], i) => {
+                    if (i === 0)
+                        return;
+                    const [pr, py] = requireValue(profile[i - 1]);
+                    if (y === py && r === pr)
+                        stop("IMPOSSIBLE_BOUNDS", `${path}/shape/profile/${i}`, "Consecutive profile points must differ.", {
+                            received: [r, y],
+                        });
+                });
+                if (!profile.some(([r]) => r > 0))
+                    stop("IMPOSSIBLE_BOUNDS", `${path}/shape/profile`, "At least one profile radius must be positive.");
+                const heights = profile.map(([, y]) => y);
+                if (heights.some((y) => Math.abs(y) > 1e6))
+                    stop("IMPOSSIBLE_BOUNDS", `${path}/shape/profile`, "Profile heights must be within ±1000000.");
+                if (profileSelfIntersects(profile, orientProfile(profile).closed))
+                    stop("SELF_INTERSECTING_PROFILE", `${path}/shape/profile`, "Profile segments must not cross or touch. Walk the outline once; repeat the first point at the end only to close a ring.");
+                lathe(m, sidesOf(s), profile, color);
+                break;
+            }
+            case "extrude": {
+                const outline = s.outline.map((q, i) => [
+                    number(q.x, `${path}/shape/outline/${i}/x`),
+                    number(q.z, `${path}/shape/outline/${i}/z`),
+                ]);
+                if (outline.some(([x, z]) => Math.abs(x) > 1e6 || Math.abs(z) > 1e6))
+                    stop("IMPOSSIBLE_BOUNDS", `${path}/shape/outline`, "Outline coordinates must be within ±1000000.");
+                if (outlineSelfIntersects(outline))
+                    stop("SELF_INTERSECTING_OUTLINE", `${path}/shape/outline`, "Outline edges must not cross, touch or repeat a point. List the corners once, in order around the shape.");
+                if (Math.abs(outlineArea(outline)) < 1e-12)
+                    stop("IMPOSSIBLE_BOUNDS", `${path}/shape/outline`, "The outline must enclose a positive area.");
+                extrude(m, outline, dim(s.height, "height"), color);
+                break;
+            }
+            case "beam":
+            case "tube": {
+                const a = point(s.from, `${path}/shape/from`), b = point(s.to, `${path}/shape/to`);
+                if (Math.hypot(...sub(b, a)) < 1e-9)
+                    stop("IMPOSSIBLE_BOUNDS", `${path}/shape/to`, "Endpoints must be distinct.");
+                if (s.type === "beam")
+                    m.beam(a, b, dim(s.width, "width"), color);
+                else if (sidesOf(s) === DEFAULT_SIDES)
+                    m.tube(a, b, dim(s.radius, "radius"), color);
+                else {
+                    const r = dim(s.radius, "radius"), shaft = new MeshBuilder();
+                    frustum(shaft, sidesOf(s), r, r, Math.hypot(...sub(b, a)), color);
+                    alongSegment(shaft.mesh, a, b, m);
+                }
+                break;
+            }
+            case "coil": {
+                const r = dim(s.radius, "radius"), t = dim(s.thickness, "thickness");
+                if (sidesOf(s) === DEFAULT_SIDES)
+                    legacyCoil(m, r, t, color);
+                else
+                    coil(m, sidesOf(s), r, t, color);
+                break;
+            }
+        }
+        removeDegenerateTriangles(m.mesh);
+        if (rotation)
+            transformMesh(m.mesh, rotation);
+        // libm trig/hypot may differ by an ULP between architectures. The declarative
+        // contract fixes output precision; the compatibility builder preserves raw floats.
+        for (const values of [m.mesh.positions, m.mesh.normals, m.mesh.colors])
+            for (let i = 0; i < values.length; i++)
+                values[i] = Math.round(requireValue(values[i]) * 1e12) / 1e12;
+        const invalid = validateMesh(m.mesh);
+        if (invalid.length)
+            stop("INVALID_GEOMETRY", `${path}/shape`, invalid.join(", "));
+        return m.mesh;
+    };
+    const anchors = (bounds) => {
+        const c = bounds.min.map((v, i) => (v + requireValue(bounds.max[i])) / 2);
+        return {
+            center: c,
+            "top-center": [c[0], bounds.max[1], c[2]],
+            "bottom-center": [c[0], bounds.min[1], c[2]],
+            "left-center": [bounds.min[0], c[1], c[2]],
+            "right-center": [bounds.max[0], c[1], c[2]],
+            "front-center": [c[0], c[1], bounds.min[2]],
+            "back-center": [c[0], c[1], bounds.max[2]],
+        };
+    };
+    const anchor = (map, key, path, part) => has(map, key)
+        ? requireValue(map[key])
+        : stop("UNKNOWN_ANCHOR", path, "Choose an anchor exported by this part.", {
+            part,
+            received: key,
+            expected: Object.keys(map).sort(),
+        });
+    const target = (ref, path, sided = false) => {
+        const [id, suffix] = ref.split("/");
+        if (!id || !has(spec.parts, id))
+            return stop("UNKNOWN_REFERENCE", path, "Unknown target part.", { targetPart: ref });
+        const declared = requireValue(spec.parts[id]);
+        if (!active(id))
+            return stop("INACTIVE_REFERENCE", path, `Part ${id} exists only when slot ${declared.slot} selects ${declared.option}.`, {
+                targetPart: ref,
+                received: slots[requireValue(declared.slot)],
+                expected: [requireValue(declared.option)],
+            });
+        if (sided && suffix === undefined && declared.sides === "both")
+            ref = `${id}/left`;
+        const choices = build(id), selected = choices.find((v) => v.id === ref);
+        if (selected)
+            return selected;
+        return stop(suffix === undefined ? "AMBIGUOUS_TARGET" : "UNKNOWN_REFERENCE", path, declared.sides === "both"
+            ? `Reference a side explicitly, for example ${id}/left.`
+            : "Reference a stable instance ID, for example legs/0.", { targetPart: ref, expected: choices.map((v) => v.id) });
+    };
+    /** Turns applied to radial array instances, by instance ID; copied joints turn their axes with them. */
+    const instanceTurns = new Map();
+    /** Copy a local mesh with a rotation followed by a translation, at the declarative precision. */
+    const placeTurned = (mesh, turn, t) => {
+        const out = transformMesh(structuredClone(mesh), compose(moveBy(t), turn));
+        for (const values of [out.positions, out.normals])
+            for (let i = 0; i < values.length; i++)
+                values[i] = quantize(requireValue(values[i]));
+        return out;
+    };
+    /**
+     * Translations (and turns) for every array instance. `base` places the part as its placement
+     * describes, and `self` is its local selfAnchor, so `base + self` is the placement point.
+     */
+    const expandArray = (part, path, base, self) => {
+        const a = requireValue(part.array), ap = `${path}/array`;
+        if (a.type === "line" || a.type === "grid") {
+            const counts = a.type === "line" ? [a.count, 1, 1] : [a.count.x ?? 1, a.count.y ?? 1, a.count.z ?? 1], step = a.type === "line"
+                ? point(a.step, `${ap}/step`)
+                : ["x", "y", "z"].map((k) => {
+                    const v = a.spacing[k];
+                    return v === undefined ? 0 : number(v, `${ap}/spacing/${k}`);
+                });
+            if (a.type === "line" && step.every((v) => v === 0))
+                stop("IMPOSSIBLE_BOUNDS", `${ap}/step`, "A line step must be nonzero so instances do not coincide.");
+            if (a.type === "grid")
+                ["x", "y", "z"].forEach((k, axis) => {
+                    if (requireValue(counts[axis]) > 1 && step[axis] === 0)
+                        stop("IMPOSSIBLE_BOUNDS", `${ap}/spacing/${k}`, `Give a nonzero ${k} spacing for ${counts[axis]} instances.`);
+                });
+            const shift = counts.map((c) => (a.centered ? (c - 1) / 2 : 0)), offsets = [];
+            // Grid order matches corner repetition: X outermost, then Y, then Z.
+            for (let ix = 0; ix < counts[0]; ix++)
+                for (let iy = 0; iy < counts[1]; iy++)
+                    for (let iz = 0; iz < counts[2]; iz++) {
+                        const along = a.type === "line"
+                            ? [ix - requireValue(shift[0]), ix - requireValue(shift[0]), ix - requireValue(shift[0])]
+                            : [ix - requireValue(shift[0]), iy - requireValue(shift[1]), iz - requireValue(shift[2])];
+                        offsets.push([
+                            base[0] + step[0] * along[0],
+                            base[1] + step[1] * along[1],
+                            base[2] + step[2] * along[2],
+                        ]);
+                    }
+            return [offsets, offsets.map(() => null)];
+        }
+        const axis = a.axis ?? "y", radius = positive(a.radius, `${ap}/radius`, true), start = a.start === undefined ? 0 : number(a.start, `${ap}/start`), sweep = a.sweep === undefined ? 360 : number(a.sweep, `${ap}/sweep`);
+        if (!(Math.abs(sweep) > 0 && Math.abs(sweep) <= 360))
+            stop("IMPOSSIBLE_BOUNDS", `${ap}/sweep`, "Sweep must be nonzero degrees from −360 to 360.", {
+                received: sweep,
+            });
+        if (Math.abs(start) > 360)
+            stop("INVALID_ROTATION", `${ap}/start`, "Start is degrees from −360 to 360.", { received: start });
+        const full = Math.abs(sweep) === 360, reference = axis === "x" ? [0, 1, 0] : [1, 0, 0], center = add(base, self), offsets = [], turns = [];
+        for (let k = 0; k < a.count; k++) {
+            const turn = axisRotation(axis, start + (k * sweep) / (full ? a.count : a.count - 1)), out = applyPoint(turn, reference).map((v, i) => requireValue(center[i]) + radius * v);
+            if (a.orient === false) {
+                offsets.push(sub(out, self).map(quantize));
+                turns.push(null);
+            }
+            else {
+                // Turn the part about its selfAnchor, then move that anchor onto the circle.
+                offsets.push(sub(out, applyPoint(turn, self)).map(quantize));
+                turns.push(isIdentity(turn) ? null : turn);
+            }
+        }
+        return [offsets, turns];
+    };
+    const build = (id) => {
+        if (built.has(id))
+            return requireValue(built.get(id));
+        const path = `/parts/${pointer(id)}`, part = requireValue(spec.parts[id]);
+        if (visiting.has(id))
+            return stop("DEPENDENCY_CYCLE", `${path}/placement/target/part`, "Cyclic attachment dependency.", {
+                part: id,
+            });
+        visiting.add(id);
+        const p = part.placement, rotation = partRotation(part, path), mesh = localMesh(part, path, rotation), bounds = meshBounds(mesh), own = anchors(bounds);
+        for (const [name, v] of Object.entries(part.anchors ?? {})) {
+            if (has(own, name))
+                stop("CONFLICTING_ANCHOR", `${path}/anchors/${name}`, "Built-in anchors cannot be overridden.");
+            const local = point(v, `${path}/anchors/${name}`);
+            own[name] = rotation ? applyPoint(rotation, local).map(quantize) : local;
+        }
+        const self = anchor(own, p.selfAnchor, `${path}/placement/selfAnchor`, id), parent = group(part.parent), sided = v2 && part.sides === "both";
+        let offsets, binding = null;
+        // A bare copied joint on an arrayed part binds instance k to copy k (resolved per instance below).
+        const copied = v3 && part.joint !== undefined && !part.joint.includes("/") && copiesOf(part.joint) > 0;
+        if (v2 && part.joint !== undefined && !copied)
+            binding = bindJoint(part.joint, `${path}/joint`, sided ? "left" : null);
+        let when = {};
+        for (const [channel, values] of Object.entries(part.when ?? {}))
+            when[channel] = [...values];
+        if (p.type === "absolute")
+            offsets = [sub(add(parent, point(p.position, `${path}/placement/position`)), self)];
+        else {
+            const t = target(p.target.part, `${path}/placement/target/part`, sided);
+            // Attached and repeated parts follow their target's joint unless they declare their own.
+            if (v2 && part.joint === undefined)
+                binding = t.joint ?? null;
+            // ...and are visible only while their target is.
+            for (const [channel, values] of Object.entries(t.when ?? {})) {
+                const merged = when[channel] ? when[channel].filter((v) => values.includes(v)) : [...values];
+                if (!merged.length)
+                    stop("CONTRADICTORY_STATES", `${path}/when/${pointer(channel)}`, `This part would never be visible: its target ${t.id} is visible only in ${values.join(", ")}.`, { part: id, targetPart: t.id, received: when[channel], expected: values });
+                when[channel] = merged;
+            }
+            if (p.type === "attach")
+                offsets = [
+                    sub(add(anchor(t.anchors, p.target.anchor, `${path}/placement/target/anchor`, t.part), p.offset ? point(p.offset, `${path}/placement/offset`) : [0, 0, 0]), self),
+                ];
+            else {
+                const x = positive(p.edgeInset.x, `${path}/placement/edgeInset/x`, true), z = positive(p.edgeInset.z, `${path}/placement/edgeInset/z`, true);
+                const w = bounds.max[0] - bounds.min[0], d = bounds.max[2] - bounds.min[2];
+                if (t.bounds.max[0] - t.bounds.min[0] < 2 * x + 2 * w - 1e-10 ||
+                    t.bounds.max[2] - t.bounds.min[2] < 2 * z + 2 * d - 1e-10)
+                    stop("IMPOSSIBLE_BOUNDS", `${path}/placement/edgeInset`, "Target cannot contain four distinct supports with these insets and bounds.", { part: id, targetPart: t.part });
+                const y = (p.target.face === "top" ? t.bounds.max[1] : t.bounds.min[1]) - self[1];
+                offsets = [];
+                for (const sx of [-1, 1])
+                    for (const sz of [-1, 1])
+                        offsets.push([
+                            sx < 0 ? t.bounds.min[0] + x - bounds.min[0] : t.bounds.max[0] - x - bounds.max[0],
+                            y,
+                            sz < 0 ? t.bounds.min[2] + z - bounds.min[2] : t.bounds.max[2] - z - bounds.max[2],
+                        ]);
+            }
+        }
+        // Schema 0.3 arrays copy the placed part; a radial array may also turn each copy.
+        let turns = offsets.map(() => null);
+        if (v3 && part.array)
+            [offsets, turns] = expandArray(part, path, requireValue(offsets[0]), self);
+        if (copied) {
+            const copies = copiesOf(requireValue(part.joint));
+            if (!part.array || offsets.length !== copies)
+                stop("JOINT_ARRAY_MISMATCH", `${path}/joint`, `Joint ${part.joint} has ${copies} copies, one per instance of its pivot part; bind it from an array with ${copies} instances, or name one copy such as ${part.joint}/0.`, { part: id, received: offsets.length, expected: [String(copies)] });
+        }
+        instanceCount += offsets.length * (sided ? 2 : 1);
+        triangles += (mesh.indices.length / 3) * offsets.length * (sided ? 2 : 1);
+        if (instanceCount > limits.instances || triangles > limits.triangles)
+            stop("GEOMETRY_BUDGET", path, "Asset exceeds its instance or triangle budget.");
+        const instances = offsets.map((translation, i) => {
+            const turn = turns[i] ?? null;
+            if (turn)
+                instanceTurns.set(`${id}/${i}`, turn);
+            const m = turn ? placeTurned(mesh, turn, translation) : appendMesh(emptyMesh(), mesh, translation), b = meshBounds(m), a = Object.fromEntries(Object.entries(own).map(([k, v]) => [
+                k,
+                turn
+                    ? applyPoint(compose(moveBy(translation), turn), v).map(quantize)
+                    : add(v, translation),
+            ]));
+            if (m.positions.some((v) => !Number.isFinite(v)))
+                stop("NON_FINITE_GEOMETRY", path, "Resolved coordinates overflow.");
+            return {
+                id: p.type === "repeat" || (v3 && part.array) ? `${id}/${i}` : sided ? `${id}/left` : id,
+                part: id,
+                material: part.material,
+                translation,
+                bounds: b,
+                anchors: a,
+                mesh: m,
+                ...(v2 ? { joint: copied ? `${part.joint}/${i}` : binding } : {}),
+                ...(v2 && Object.keys(when).length ? { when: structuredClone(when) } : {}),
+            };
+        });
+        if (sided) {
+            const left = requireValue(instances[0]), center = (left.bounds.min[0] + left.bounds.max[0]) / 2;
+            if (!(center < -1e-9))
+                stop("SIDE_MISMATCH", `${path}/placement`, "Sided parts describe the character's left side, which is −X (characters face −Z). Place this part at X < 0.", { part: id, received: center });
+            instances.push(mirrorInstance(left, `${id}/right`));
+        }
+        visiting.delete(id);
+        built.set(id, instances);
+        return instances;
+    };
+    for (const id of Object.keys(spec.parts).sort())
+        if (active(id))
+            build(id);
+    const rest = Object.fromEntries(Object.entries(spec.states ?? {}).map(([k, v]) => [k, requireValue(v[0])]));
+    const visible = (i) => Object.entries(i.when ?? {}).every(([channel, values]) => values.includes(requireValue(rest[channel])));
+    const everything = [...built.values()].flat().sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)), instances = everything.filter(visible), alternates = everything.filter((i) => !visible(i)), layers = Object.create(null), all = emptyMesh();
+    let skeleton;
+    const limbs = [];
+    if (v2) {
+        const compiled = new Map(), stack = new Set();
+        const compileJoint = (ref) => {
+            if (compiled.has(ref))
+                return requireValue(compiled.get(ref));
+            const [id, suffix] = ref.split("/"), copy = suffix !== undefined && /^[0-9]+$/.test(suffix) ? Number(suffix) : null, side = copy === null ? suffix : null, joint = requireValue(requireValue(spec.joints)[id]), path = `/joints/${pointer(id)}`;
+            if (stack.has(ref))
+                return stop("DEPENDENCY_CYCLE", `${path}/parent`, "Cyclic joint hierarchy.");
+            stack.add(ref);
+            if (copy !== null && joint.sides === "both")
+                stop("UNSUPPORTED_COMBINATION", `${path}/sides`, "A joint copied per array instance cannot also be sided.");
+            let parent = null;
+            if (joint.parent !== undefined) {
+                const left = bindJoint(joint.parent, `${path}/parent`, side ? "left" : null, copy, copy === null ? null : copiesOf(id));
+                parent = side === "right" ? swapSide(left) : left;
+                compileJoint(parent);
+            }
+            let pivot, turn = null;
+            if (side === "right")
+                pivot = mirrorPoint(compileJoint(`${id}/left`).pivot);
+            else if ("position" in joint.pivot)
+                pivot = point(joint.pivot.position, `${path}/pivot/position`);
+            else {
+                const part = copy === null ? joint.pivot.part : `${joint.pivot.part}/${copy}`, t = target(part, `${path}/pivot/part`, side === "left");
+                pivot = anchor(t.anchors, joint.pivot.anchor, `${path}/pivot/anchor`, t.part);
+                if (copy !== null)
+                    turn = instanceTurns.get(t.id) ?? null;
+            }
+            // A pivot on the mirror plane is allowed (e.g. mouth corners turning about the mouth center).
+            if (side === "left" && pivot[0] > 1e-9)
+                stop("SIDE_MISMATCH", `${path}/pivot`, "Sided joints describe the character's left side, which is −X. Place the pivot at X ≤ 0.", { received: pivot[0] });
+            const result = {
+                id: ref,
+                joint: id,
+                ...(side ? { side } : {}),
+                ...(copy !== null ? { copy } : {}),
+                ...(joint.face ? { face: true } : {}),
+                parent,
+                pivot,
+                dofs: joint.dofs.map((d) => {
+                    // A copy of a radially oriented array turns its axes with its instance.
+                    const a = turn ? applyVector(turn, AXES[d.axis]).map(quantize) : AXES[d.axis];
+                    return {
+                        name: d.name,
+                        axis: side === "right" ? [a[0], neg(a[1]), neg(a[2])] : [a[0], a[1], a[2]],
+                        limits: [d.limits[0], d.limits[1]],
+                        ...(v3 && d.continuous ? { continuous: true } : {}),
+                    };
+                }),
+            };
+            stack.delete(ref);
+            compiled.set(ref, result);
+            return result;
+        };
+        for (const id of jointIds())
+            compileJoint(id);
+        // Limbs: chains a clip may solve. Sided limbs resolve bare sided references to the same side.
+        for (const id of Object.keys(spec.limbs ?? {}).sort()) {
+            const limb = requireValue(requireValue(spec.limbs)[id]), path = `/limbs/${pointer(id)}`;
+            for (const side of limb.sides === "both" ? ["left", "right"] : [null]) {
+                const swap = (ref) => (side === "right" ? swapSide(ref) : ref);
+                const dof = (r, rp) => {
+                    const joint = requireValue(compiled.get(swap(bindJoint(r.joint, `${rp}/joint`, side ? "left" : null))));
+                    if (!joint.dofs.some((d) => d.name === r.dof))
+                        stop("UNKNOWN_DOF", `${rp}/dof`, `Choose a degree of freedom exported by joint ${joint.joint}.`, {
+                            received: r.dof,
+                            expected: joint.dofs.map((d) => d.name),
+                        });
+                    return { joint: joint.id, dof: r.dof };
+                };
+                const leftEffector = target(limb.effector.part, `${path}/effector/part`, side !== null), effector = side === "right" ? swapSide(leftEffector.id) : leftEffector.id;
+                anchor(leftEffector.anchors, limb.effector.anchor, `${path}/effector/anchor`, leftEffector.part);
+                const reach = limb.reach.map((r, i) => dof(r, `${path}/reach/${i}`)), level = limb.level ? dof(limb.level, `${path}/level`) : null;
+                const bound = requireValue(everything.find((i) => i.id === effector)).joint ?? null, chain = [];
+                for (let j = bound; j !== null; j = requireValue(compiled.get(j)).parent)
+                    chain.push(j);
+                for (const [k, r] of [
+                    ...reach.map((r, i) => [`reach/${i}`, r]),
+                    ...(level ? [["level", level]] : []),
+                ])
+                    if (!chain.includes(r.joint))
+                        stop("LIMB_CHAIN", `${path}/${k}/joint`, `Joint ${r.joint} does not move effector ${effector}; choose the effector's joint or one of its ancestors.`, { received: r.joint, expected: chain });
+                limbs.push({
+                    id: side ? `${id}/${side}` : id,
+                    effector,
+                    anchor: limb.effector.anchor,
+                    reach,
+                    ...(level ? { level } : {}),
+                });
+            }
+        }
+        const depth = (j) => j.parent === null ? 0 : 1 + depth(requireValue(compiled.get(j.parent)));
+        const joints = [...compiled.values()].sort((a, b) => depth(a) - depth(b) || (a.id < b.id ? -1 : 1)), index = new Map(joints.map((j, i) => [j.id, i]));
+        for (const instance of everything)
+            instance.mesh.joints = new Array(instance.mesh.positions.length / 3).fill(instance.joint ? requireValue(index.get(instance.joint)) : -1);
+        skeleton = { joints };
+    }
+    for (const instance of instances) {
+        if (!has(layers, instance.material))
+            layers[instance.material] = emptyMesh();
+        appendMesh(requireValue(layers[instance.material]), instance.mesh);
+        appendMesh(all, instance.mesh);
+    }
+    return {
+        schema: v3 ? SCHEMA_V3 : v2 ? SCHEMA_V2 : SCHEMA,
+        units: spec.units,
+        sourceHash: identity === null ? sourceHash(spec) : sourceHash({ identity, spec }),
+        layers,
+        materials,
+        instances,
+        bounds: meshBounds(all),
+        groundPivot: spec.groundPivot ? point(spec.groundPivot, "/groundPivot") : [0, 0, 0],
+        // Budgets count every instance; the reported triangles are those visible in the rest states.
+        triangles: alternates.length ? all.indices.length / 3 : triangles,
+        ...(v2
+            ? { skeleton, identity, slots, states: structuredClone(spec.states ?? {}), alternates, limbs }
+            : {}),
+    };
+}
+export function compileAsset(input, options = {}) {
+    const diagnostics = schemaDiagnostics(input);
+    if (diagnostics.length)
+        throw new AssetCompileError(diagnostics);
+    try {
+        return resolve(input, options);
+    }
+    catch (error) {
+        if (error instanceof AssetCompileError) {
+            if (options.identity !== undefined)
+                throw new AssetCompileError(error.diagnostics.map((d) => ({ ...d, identity: options.identity })));
+            throw error;
+        }
+        throw new AssetCompileError([
+            {
+                code: "INVALID_SPEC",
+                path: "",
+                message: error instanceof Error ? error.message : "Invalid asset specification.",
+            },
+        ]);
+    }
+}
+/**
+ * Returns [] when the description compiles. For schema 0.2 without an explicit identity, the base
+ * description and every declared identity are compiled; diagnostics carry the identity they came from.
+ */
+export function validateAsset(input, options = {}) {
+    const attempt = (identity) => {
+        try {
+            compileAsset(input, identity === undefined ? options : { ...options, identity });
+            return [];
+        }
+        catch (error) {
+            if (error instanceof AssetCompileError)
+                return error.diagnostics;
+            throw error;
+        }
+    };
+    const base = attempt(options.identity);
+    if (options.identity !== undefined ||
+        !record(input) ||
+        (input.schema !== SCHEMA_V2 && input.schema !== SCHEMA_V3) ||
+        !record(input.identities) ||
+        schemaDiagnostics(input).length)
+        return base;
+    const all = [...base], seen = new Set(all.map((d) => JSON.stringify(d)));
+    for (const id of Object.keys(input.identities).sort())
+        for (const d of attempt(id)) {
+            const { identity: _identity, ...withoutIdentity } = d;
+            const key = JSON.stringify(withoutIdentity);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            all.push(d);
+        }
+    return all;
+}