lecodes-assets 0.1.2 → 0.2.0

package/dist/index.js

@@ -959,15 +959,18 @@ var init_toDocument = __esm(() => {
 var exports_rig = {};
 __export(exports_rig, {
   worldOf: () => worldOf,
+  sameSkeleton: () => sameSkeleton,
   rotateRig: () => rotateRig,
   rigFromFbx: () => rigFromFbx,
   rigFromDocument: () => rigFromDocument,
+  rebindClips: () => rebindClips,
   qslerp: () => qslerp,
   qrot: () => qrot,
   qnorm: () => qnorm,
   qmul: () => qmul,
   qinv: () => qinv,
   loadRig: () => loadRig,
+  hasSkin: () => hasSkin,
   checkUniformScale: () => checkUniformScale,
   bindVsRest: () => bindVsRest
 });
@@ -992,7 +995,7 @@ var qmul = (a, b) => [
   const th = Math.acos(d), s = Math.sin(th);
   const wa = Math.sin((1 - t) * th) / s, wb = Math.sin(t * th) / s;
   return [a[0] * wa + e[0] * wb, a[1] * wa + e[1] * wb, a[2] * wa + e[2] * wb, a[3] * wa + e[3] * wb];
-}, qrot = (q, v) => {
+}, sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]], scl = (a, k) => [a[0] * k, a[1] * k, a[2] * k], len = (v) => Math.hypot(v[0], v[1], v[2]), qrot = (q, v) => {
   const [x, y, z, w] = q;
   const tx = 2 * (y * v[2] - z * v[1]), ty = 2 * (z * v[0] - x * v[2]), tz = 2 * (x * v[1] - y * v[0]);
   return [
@@ -1085,16 +1088,31 @@ var qmul = (a, b) => [
   }
   const k = Math.sqrt(1 + i - a - e) * 2;
   return qnorm([(g + c) / k, (h + f) / k, k / 4, (b - d) / k]);
-}, buildBind = (parents, order, rest, ibmByNode) => {
+}, buildBind = (parents, order, rest, ibmByNode, spaceByNode) => {
   const world = new Array(parents.length);
   const fromSkin = new Array(parents.length).fill(false);
+  const restWorld = new Array(parents.length);
   for (const i of order) {
-    const ibm = ibmByNode.get(i);
-    if (ibm) {
-      world[i] = matInvRigid(ibm);
-      fromSkin[i] = true;
-    }
+    const local2 = matCompose(rest.t[i], rest.r[i], rest.s[i]);
+    restWorld[i] = parents[i] >= 0 ? matMul(restWorld[parents[i]], local2) : local2;
   }
+  let rawDist = 0, foldedDist = 0;
+  const raw = new Array(parents.length), folded = new Array(parents.length);
+  for (const i of order) {
+    const ibm = ibmByNode.get(i);
+    if (!ibm)
+      continue;
+    raw[i] = matInvRigid(ibm);
+    const space = spaceByNode.get(i);
+    folded[i] = space ? matMul(space, raw[i]) : raw[i];
+    fromSkin[i] = true;
+    rawDist += Math.hypot(raw[i][12] - restWorld[i][12], raw[i][13] - restWorld[i][13], raw[i][14] - restWorld[i][14]);
+    foldedDist += Math.hypot(folded[i][12] - restWorld[i][12], folded[i][13] - restWorld[i][13], folded[i][14] - restWorld[i][14]);
+  }
+  const useFolded = foldedDist <= rawDist;
+  for (const i of order)
+    if (fromSkin[i])
+      world[i] = useFolded ? folded[i] : raw[i];
   const accum = new Array(parents.length).fill(1);
   for (const i of order)
     accum[i] = (parents[i] >= 0 ? accum[parents[i]] : 1) * rest.s[i][0];
@@ -1138,9 +1156,19 @@ var qmul = (a, b) => [
     local.r[i] = qnorm(qmul(qconj(worldRot[p]), worldRot[i]));
   }
   return { worldRot, worldPos, fromSkin, local, scale: Math.abs(scale - 1) > 0.01 ? scale : 1 };
-}, finish = (label, names, parents, rest, makeClips, ibmByNode) => {
+}, restWorldOf = (parents, rest, node) => {
+  const chain = [];
+  for (let a = node;a >= 0; a = parents[a])
+    chain.unshift(a);
+  let m = null;
+  for (const i of chain) {
+    const local = matCompose(rest.t[i], rest.r[i], rest.s[i]);
+    m = m ? matMul(m, local) : local;
+  }
+  return m;
+}, finish = (label, names, parents, rest, makeClips, ibmByNode, spaceByNode = new Map) => {
   const order = buildOrder(parents);
-  const bind = buildBind(parents, order, rest, ibmByNode);
+  const bind = buildBind(parents, order, rest, ibmByNode, spaceByNode);
   const rig = {
     label,
     names,
@@ -1204,13 +1232,19 @@ var qmul = (a, b) => [
     s: scene.nodes.map((n) => [...n.s])
   };
   const ibmByNode = new Map;
-  for (const skin of scene.skins) {
+  const spaceByNode = new Map;
+  scene.skins.forEach((skin, si) => {
     const ibm = f32(scene, skin.ibm, skin.joints.length * 16);
+    const meshNode = scene.nodes.findIndex((n) => n.skin === si);
+    const space = meshNode >= 0 ? restWorldOf(parents, rest, meshNode) : null;
     skin.joints.forEach((node, j) => {
-      if (!ibmByNode.has(node))
-        ibmByNode.set(node, Array.from(ibm.subarray(j * 16, j * 16 + 16)));
+      if (ibmByNode.has(node))
+        return;
+      ibmByNode.set(node, Array.from(ibm.subarray(j * 16, j * 16 + 16)));
+      if (space)
+        spaceByNode.set(node, space);
     });
-  }
+  });
   const makeClips = (base) => scene.animations.filter((a) => a.tracks.length > 0).map((anim) => {
     const tracks = anim.tracks.map((tr) => {
       const n = tr.path === "rotation" ? 4 : 3;
@@ -1234,7 +1268,7 @@ var qmul = (a, b) => [
       }
     };
   });
-  return finish(path, names, parents, rest, makeClips, ibmByNode);
+  return finish(path, names, parents, rest, makeClips, ibmByNode, spaceByNode);
 }, clipsFromDocument = (doc, nodes, base) => {
   const idx = new Map(nodes.map((n, i) => [n, i]));
   return doc.getRoot().listAnimations().map((anim) => {
@@ -1284,18 +1318,127 @@ var qmul = (a, b) => [
     s: nodes.map((n) => [...n.getScale()])
   };
   const ibmByNode = new Map;
+  const spaceByNode = new Map;
   for (const skin of doc.getRoot().listSkins()) {
     const acc = skin.getInverseBindMatrices();
     if (!acc)
       continue;
+    const meshNode = nodes.findIndex((n) => n.getSkin() === skin);
+    const space = meshNode >= 0 ? restWorldOf(parents, rest, meshNode) : null;
     skin.listJoints().forEach((joint, j) => {
       const i = idx.get(joint);
-      if (i !== undefined && !ibmByNode.has(i))
-        ibmByNode.set(i, acc.getElement(j, []));
+      if (i === undefined || ibmByNode.has(i))
+        return;
+      ibmByNode.set(i, acc.getElement(j, []));
+      if (space)
+        spaceByNode.set(i, space);
     });
   }
-  return { ...finish(label, names, parents, rest, (base) => clipsFromDocument(doc, nodes, base), ibmByNode), doc, nodes };
-}, loadRig = async (path) => rigFromFbx(path, new Uint8Array(readFileSync3(path))), rotateRig = (rig, q) => {
+  return { ...finish(label, names, parents, rest, (base) => clipsFromDocument(doc, nodes, base), ibmByNode, spaceByNode), doc, nodes };
+}, loadRig = async (path) => rigFromFbx(path, new Uint8Array(readFileSync3(path))), hasSkin = (rig) => rig.bind.fromSkin.some(Boolean), shortBoneName = (n) => n.slice(n.search(/[^:|]*$/)), sameSkeleton = (rig, source) => {
+  const short = new Map;
+  rig.names.forEach((n, i) => {
+    const s = shortBoneName(n);
+    if (!short.has(s))
+      short.set(s, i);
+  });
+  const map = source.names.map((n) => rig.index.get(n) ?? short.get(shortBoneName(n)) ?? -1);
+  const share = map.filter((j) => j >= 0).length / Math.max(1, source.names.length);
+  let worstDeg = 0, worstBone = "";
+  source.names.forEach((_, i) => {
+    const j = map[i];
+    if (j < 0)
+      return;
+    const ps = source.parents[i], pt = rig.parents[j];
+    if (ps < 0 || pt < 0 || map[ps] !== pt)
+      return;
+    const a = rig.rest.t[j], b = source.rest.t[i];
+    const la = Math.hypot(...a), lb = Math.hypot(...b);
+    if (la < 0.05 || lb < 0.05)
+      return;
+    const deg = Math.acos(Math.max(-1, Math.min(1, (a[0] * b[0] + a[1] * b[1] + a[2] * b[2]) / (la * lb)))) * 180 / Math.PI;
+    if (deg > worstDeg) {
+      worstDeg = deg;
+      worstBone = source.names[i];
+    }
+  });
+  return { same: share >= 0.8 && worstDeg < 45, share, worstDeg, worstBone };
+}, rebindClips = (rig, source) => {
+  const short = new Map;
+  rig.names.forEach((n, i) => {
+    const s = shortBoneName(n);
+    if (!short.has(s))
+      short.set(s, i);
+  });
+  const map = source.names.map((n) => rig.index.get(n) ?? short.get(shortBoneName(n)) ?? -1);
+  const unbound = source.names.filter((_, i) => map[i] < 0);
+  const bound = map.filter((j) => j >= 0).length;
+  const base = rig.bind.local, srcRest = source.rest;
+  const animated = source.names.map(() => false);
+  for (const c of source.clips)
+    for (let k = 0;k <= 8; k++) {
+      const p = c.sample(k / 8 * c.duration);
+      p.t.forEach((t, i) => {
+        if (!animated[i] && len(sub(t, srcRest.t[i])) > 0.000001)
+          animated[i] = true;
+      });
+    }
+  const sampleAt = (c, time, scale2) => {
+    const p = c.sample(time);
+    const out = { t: base.t.map((v) => [...v]), r: base.r.map((q) => [...q]), s: base.s.map((v) => [...v]) };
+    map.forEach((j, i) => {
+      if (j < 0)
+        return;
+      out.r[j] = p.r[i];
+      if (animated[i])
+        out.t[j] = scl(p.t[i], scale2);
+    });
+    return out;
+  };
+  let sameLengths = true, num = 0, den = 0;
+  map.forEach((j, i) => {
+    if (j < 0 || animated[i] || source.parents[i] < 0 || rig.parents[j] < 0)
+      return;
+    const a = len(base.t[j]), b = len(srcRest.t[i]);
+    num += a;
+    den += b;
+    if (Math.abs(a - b) > 0.01 * Math.max(a, b, 0.01))
+      sameLengths = false;
+  });
+  let scale = 1;
+  if (!sameLengths && source.clips.length) {
+    const skinned = rig.bind.fromSkin.some(Boolean) ? rig.bind.worldPos.filter((_, i) => rig.bind.fromSkin[i]) : rig.bind.worldPos;
+    const ground = Math.min(...skinned.map((p) => p[1]));
+    const lowest = (s) => {
+      let lo = Infinity;
+      for (const c of source.clips)
+        for (let k = 0;k < 16; k++) {
+          const w = worldOf(rig, sampleAt(c, k / 15 * c.duration, s));
+          for (let i = 0;i < w.pos.length; i++)
+            if (rig.bind.fromSkin[i] || !rig.bind.fromSkin.some(Boolean))
+              lo = Math.min(lo, w.pos[i][1]);
+        }
+      return lo;
+    };
+    let a = 0.5, b = 2, fa = lowest(a) - ground, fb = lowest(b) - ground;
+    if (fa < 0 && fb > 0) {
+      for (let it = 0;it < 24; it++) {
+        const m = (a + b) / 2, fm = lowest(m) - ground;
+        if (fm < 0) {
+          a = m;
+          fa = fm;
+        } else {
+          b = m;
+          fb = fm;
+        }
+      }
+      scale = (a + b) / 2;
+    } else
+      scale = den > 0 && num > 0 ? num / den : 1;
+  }
+  const clips = source.clips.map((c) => ({ name: c.name, duration: c.duration, sample: (time) => sampleAt(c, time, scale) }));
+  return { rig: { ...rig, clips }, bound, total: source.names.length, unbound, scale };
+}, rotateRig = (rig, q) => {
   const roots = rig.parents.map((p, i) => p < 0 ? i : -1).filter((i) => i >= 0);
   const turn = (pose) => {
     const out2 = { t: pose.t.map((v) => [...v]), r: pose.r.map((v) => [...v]), s: pose.s };
@@ -1338,9 +1481,9 @@ var u322 = (b, o) => (b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]) >>
   let palette = null;
   let trns = null;
   while (o + 8 <= b.length) {
-    const len = u322(b, o);
+    const len2 = u322(b, o);
     const type = String.fromCharCode(b[o + 4], b[o + 5], b[o + 6], b[o + 7]);
-    const data = b.subarray(o + 8, o + 8 + len);
+    const data = b.subarray(o + 8, o + 8 + len2);
     if (type === "IHDR") {
       width = u322(data, 0);
       height = u322(data, 4);
@@ -1355,7 +1498,7 @@ var u322 = (b, o) => (b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]) >>
       idat.push(data);
     else if (type === "IEND")
       break;
-    o += 12 + len;
+    o += 12 + len2;
   }
   if (!width || !height || interlace !== 0 || depth !== 8 && depth !== 16)
     return null;
@@ -4046,12 +4189,12 @@ var init_lightmapUv = __esm(() => {
         var num2 = 0;
         for (var i2 = 0;i2 < iovcnt; i2++) {
           var ptr = HEAPU32[iov >> 2];
-          var len = HEAPU32[iov + 4 >> 2];
+          var len2 = HEAPU32[iov + 4 >> 2];
           iov += 8;
-          for (var j = 0;j < len; j++) {
+          for (var j = 0;j < len2; j++) {
             printChar(fd, HEAPU8[ptr + j]);
           }
-          num2 += len;
+          num2 += len2;
         }
         HEAPU32[pnum >> 2] = num2;
         return 0;
@@ -4311,6 +4454,193 @@ var init_lightmapUv2 = __esm(() => {
   init_lightmapUv();
 });
 
+// src/doctor/lod.ts
+import { simplifyPrimitive, weldPrimitive } from "@gltf-transform/functions";
+import { MeshoptSimplifier } from "meshoptimizer";
+function planLod(doc, opts) {
+  const ratios = (opts.lod ?? []).filter((r) => r > 0 && r < 1).sort((a, b) => b - a);
+  if (!ratios.length)
+    return null;
+  const nodes = [];
+  let existing = 0;
+  for (const node of doc.getRoot().listNodes()) {
+    const mesh = node.getMesh();
+    if (!mesh)
+      continue;
+    if (LOD_NAME.test(node.getName())) {
+      existing++;
+      continue;
+    }
+    const tris = meshTris(mesh);
+    if (tris < LOD_MIN_TRIS)
+      continue;
+    nodes.push({ node, name: node.getName() || mesh.getName() || `mesh${nodes.length}`, tris, skinned: !!node.getSkin() });
+  }
+  return { ratios, bones: !!opts.lodBones, nodes, existing };
+}
+async function applyLod(doc, plan) {
+  await MeshoptSimplifier.ready;
+  const result = { levels: plan.ratios.length, nodes: 0, tris: [], bones: [], skipped: [] };
+  for (const entry of plan.nodes) {
+    const { node } = entry;
+    const baseMesh = node.getMesh();
+    const parent = node.getParentNode();
+    const scenes = parent ? [] : doc.getRoot().listScenes().filter((s) => s.listChildren().includes(node));
+    const baseExtras = node.getExtras() ?? {};
+    const baseLecodes = baseExtras.lecodes ?? {};
+    node.setExtras({ ...baseExtras, lecodes: { ...baseLecodes, lod: { level: 0, levels: plan.ratios.length + 1, tris: entry.tris } } });
+    const levels = [entry.tris];
+    for (let i = 0;i < plan.ratios.length; i++) {
+      const level = i + 1;
+      const ratio = plan.ratios[i];
+      const mesh = doc.createMesh(`${baseMesh.getName() || entry.name}_LOD${level}`);
+      let tris = 0;
+      for (const prim of baseMesh.listPrimitives()) {
+        if (prim.getMode() !== 4)
+          continue;
+        let copy = clonePrimitive(doc, prim);
+        weldPrimitive(copy);
+        copy = simplifyPrimitive(copy, { simplifier: MeshoptSimplifier, ratio, error: 0.02, lockBorder: false });
+        tris += primTris(copy);
+        mesh.addPrimitive(copy);
+      }
+      if (tris > levels[levels.length - 1] * 0.85) {
+        for (const p of mesh.listPrimitives()) {
+          for (const sem of p.listSemantics())
+            p.getAttribute(sem)?.dispose();
+          p.getIndices()?.dispose();
+          p.dispose();
+        }
+        mesh.dispose();
+        result.skipped.push({ name: entry.name, level, tris });
+        break;
+      }
+      const lodNode = doc.createNode(`${node.getName() || entry.name}_LOD${level}`).setMesh(mesh).setTranslation(node.getTranslation()).setRotation(node.getRotation()).setScale(node.getScale());
+      if (node.getSkin())
+        lodNode.setSkin(node.getSkin());
+      lodNode.setExtras({ lecodes: { lod: { level, ratio, tris } } });
+      if (parent)
+        parent.addChild(lodNode);
+      else
+        for (const s of scenes)
+          s.addChild(lodNode);
+      levels.push(tris);
+      if (plan.bones && i === plan.ratios.length - 1 && node.getSkin()) {
+        const r = reduceSkinForLod(doc, lodNode);
+        if (r)
+          result.bones.push({ name: entry.name, ...r });
+      }
+    }
+    result.nodes++;
+    result.tris.push({ name: entry.name, levels });
+  }
+  return result;
+}
+var LOD_MIN_TRIS = 2000, LOD_JOINT_MASK, LOD_NAME, shortName3 = (s) => {
+  const p = Math.max(s.lastIndexOf(":"), s.lastIndexOf("|"));
+  return p < 0 ? s : s.slice(p + 1);
+}, primTris = (p) => {
+  if (p.getMode() !== 4)
+    return 0;
+  const idx = p.getIndices();
+  const n = idx ? idx.getCount() : p.getAttribute("POSITION")?.getCount() ?? 0;
+  return Math.floor(n / 3);
+}, meshTris = (m) => m.listPrimitives().reduce((s, p) => s + primTris(p), 0), clonePrimitive = (doc, prim) => {
+  const buffer = doc.getRoot().listBuffers()[0] ?? doc.createBuffer();
+  const cloneAcc = (a) => doc.createAccessor(a.getName(), buffer).setType(a.getType()).setNormalized(a.getNormalized()).setArray(a.getArray().slice());
+  const out = doc.createPrimitive().setMode(prim.getMode()).setMaterial(prim.getMaterial());
+  for (const sem of prim.listSemantics())
+    out.setAttribute(sem, cloneAcc(prim.getAttribute(sem)));
+  const idx = prim.getIndices();
+  if (idx)
+    out.setIndices(cloneAcc(idx));
+  return out;
+}, reduceSkinForLod = (doc, lodNode) => {
+  const skin = lodNode.getSkin();
+  const mesh = lodNode.getMesh();
+  if (!skin || !mesh)
+    return null;
+  const joints = skin.listJoints();
+  const removed = new Set;
+  joints.forEach((j, i) => {
+    if (LOD_JOINT_MASK.test(shortName3(j.getName())))
+      removed.add(i);
+  });
+  if (!removed.size)
+    return null;
+  const idxOf = new Map(joints.map((j, i) => [j, i]));
+  const remap = joints.map((j, i) => {
+    if (!removed.has(i))
+      return i;
+    for (let p = j.getParentNode();p; p = p.getParentNode()) {
+      const k = idxOf.get(p);
+      if (k !== undefined && !removed.has(k))
+        return k;
+    }
+    return i;
+  });
+  const kept = [...new Set(remap)].sort((a, b) => a - b);
+  const newIndex = new Map(kept.map((old, k) => [old, k]));
+  const buffer = doc.getRoot().listBuffers()[0] ?? doc.createBuffer();
+  const newSkin = doc.createSkin(`${skin.getName() || "skin"}_LOD`);
+  if (skin.getSkeleton())
+    newSkin.setSkeleton(skin.getSkeleton());
+  for (const i of kept)
+    newSkin.addJoint(joints[i]);
+  const ibm = skin.getInverseBindMatrices();
+  if (ibm) {
+    const src = ibm.getArray();
+    const out = new Float32Array(kept.length * 16);
+    kept.forEach((i, k) => out.set(src.subarray(i * 16, i * 16 + 16), k * 16));
+    newSkin.setInverseBindMatrices(doc.createAccessor(`${ibm.getName() || "ibm"}_LOD`, buffer).setType("MAT4").setArray(out));
+  }
+  const jv = [], wv = [];
+  for (const prim of mesh.listPrimitives()) {
+    const sets = [];
+    for (let s = 0;; s++) {
+      const j = prim.getAttribute(`JOINTS_${s}`), w = prim.getAttribute(`WEIGHTS_${s}`);
+      if (!j || !w)
+        break;
+      sets.push({ j, w });
+    }
+    if (!sets.length)
+      continue;
+    const count = sets[0].j.getCount();
+    const folded = new Map;
+    for (let v = 0;v < count; v++) {
+      folded.clear();
+      for (const { j, w } of sets) {
+        j.getElement(v, jv);
+        w.getElement(v, wv);
+        for (let k = 0;k < 4; k++) {
+          const weight = wv[k] ?? 0;
+          if (weight <= 0)
+            continue;
+          const target = newIndex.get(remap[jv[k]] ?? jv[k]) ?? 0;
+          folded.set(target, (folded.get(target) ?? 0) + weight);
+        }
+      }
+      const pairs = [...folded].sort((a, b) => b[1] - a[1]);
+      let n = 0;
+      for (const { j, w } of sets) {
+        for (let k = 0;k < 4; k++) {
+          const p = pairs[n++];
+          jv[k] = p ? p[0] : 0;
+          wv[k] = p ? p[1] : 0;
+        }
+        j.setElement(v, jv);
+        w.setElement(v, wv);
+      }
+    }
+  }
+  lodNode.setSkin(newSkin);
+  return { before: joints.length, after: kept.length };
+};
+var init_lod = __esm(() => {
+  LOD_JOINT_MASK = /finger|thumb|index|middle|ring|pinky|toe|twist|roll|leaf|_end$/i;
+  LOD_NAME = /_LOD\d+$/;
+});
+
 // src/doctor/doctor.ts
 var exports_doctor = {};
 __export(exports_doctor, {
@@ -4358,7 +4688,8 @@ async function analyzeDoc(doc, opts = {}) {
   const scaleInfo = measureScale(doc);
   const scalePlan = planScale(scaleInfo, opts);
   const dupNames = duplicateNodeNames(doc);
-  return { skinPlans, texPlans, ktx2Plans, metallicWarn, shadingPlan, lightmapPlan, scaleInfo, scalePlan, conflicts, target, dupNames };
+  const lodPlan = planLod(doc, opts);
+  return { skinPlans, texPlans, ktx2Plans, metallicWarn, shadingPlan, lightmapPlan, scaleInfo, scalePlan, lodPlan, conflicts, target, dupNames };
 }
 async function dumpTextures(doc, dir, log = console.log) {
   if (!existsSync8(dir))
@@ -4510,6 +4841,7 @@ async function applyPlan(doc, plan, opts = {}) {
   }
   const shading = applyShading(doc, plan.shadingPlan);
   const lightmapUv = plan.lightmapPlan.enabled ? await applyLightmapUv(doc, plan.lightmapPlan) : null;
+  const lod = plan.lodPlan ? await applyLod(doc, plan.lodPlan) : null;
   let ktx2Encoded = 0;
   if (opts.ktx2) {
     const toktx = opts.toktx ?? findToktx();
@@ -4533,7 +4865,7 @@ async function applyPlan(doc, plan, opts = {}) {
         ext.dispose();
     }
   }
-  return { metallicZeroed, ktx2Encoded, scaled: plan.scalePlan?.factor ?? 1, unlit: shading.unlit, emissiveCleared: shading.emissiveCleared, lightmapUv };
+  return { metallicZeroed, ktx2Encoded, scaled: plan.scalePlan?.factor ?? 1, unlit: shading.unlit, emissiveCleared: shading.emissiveCleared, lightmapUv, lod };
 }
 function outputFor(input, oVal, batch, ktx2) {
   const derived = input.replace(/\.glb$/i, ktx2 ? ".ktx2.glb" : ".fixed.glb");
@@ -4556,6 +4888,7 @@ var init_doctor = __esm(() => {
   init_normalizeScale();
   init_shading();
   init_lightmapUv2();
+  init_lod();
   init_mergeSkins();
   init_normalizeScale();
   EXT_BY_MIME = { "image/png": "png", "image/jpeg": "jpg", "image/webp": "webp", "image/ktx2": "ktx2" };
@@ -5001,7 +5334,26 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
   if (rootBone !== null && rootIdx < 0)
     warn(`target has no root bone "${rootBone}" — no root motion`);
   const donorRoot = rootIdx >= 0 ? byTarget.get(rootIdx) : undefined;
+  const rootTranslateOnly = rootIdx >= 0 && donorRoot !== undefined && pairs.some((p) => p.d !== rootIdx && p.s === donorRoot);
   const legs = opts.ik === "none" ? [] : detectLegs(target, turned, byTarget, target.bind.worldPos, opts.legs, warn);
+  const hum = opts.humanoid;
+  const humIdx = (av, k) => {
+    const n = av.bones[k];
+    return n === undefined ? undefined : target.index.get(n);
+  };
+  const hipsIdx = hum ? humIdx(hum.target, "Hips") ?? -1 : -1;
+  if (hum)
+    for (const leg of legs)
+      for (const s of ["Left", "Right"]) {
+        const foot = humIdx(hum.target, `${s}Foot`), toes = humIdx(hum.target, `${s}Toes`);
+        if (leg.effector === foot && toes !== undefined && byTarget.has(toes) && target.parents[toes] === foot) {
+          leg.contact = toes;
+          leg.donorContact = byTarget.get(toes);
+          const tf = len2(sub2(target.bind.worldPos[toes], target.bind.worldPos[foot])), df = len2(sub2(turned.bind.worldPos[leg.donorContact], turned.bind.worldPos[leg.donorEffector]));
+          leg.contactRatio = tf > 0 && df > 0 ? tf / df : 1;
+        }
+      }
+  const donorReach = (leg, pos) => add(scl2(sub2(pos[leg.donorEffector], pos[leg.donorHip]), leg.ratio), scl2(sub2(pos[leg.donorContact], pos[leg.donorEffector]), leg.contactRatio));
   const wanted = opts.clips?.length ? new Set(opts.clips) : null;
   const clips = turned.clips.filter((c) => !wanted || wanted.has(c.name));
   let donorGround = 0;
@@ -5013,7 +5365,7 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
       for (let f = 0;f < frames; f++) {
         const dw = worldOf(turned, clip.sample(f / (frames - 1) * clip.duration));
         for (const l of legs)
-          l.baseDonor = Math.min(l.baseDonor, dw.pos[l.donorEffector][1]);
+          l.baseDonor = Math.min(l.baseDonor, dw.pos[l.donorContact][1]);
       }
     }
     donorGround = Math.min(...legs.map((l) => l.baseDonor));
@@ -5038,8 +5390,8 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
         })());
         if (kid === undefined || !byTarget.has(kid) || !byTarget.has(i))
           continue;
-        const ut = unit(sub(target.bind.worldPos[kid], target.bind.worldPos[i]));
-        const us = unit(sub(turned.bind.worldPos[byTarget.get(kid)], turned.bind.worldPos[byTarget.get(i)]));
+        const ut = unit(sub2(target.bind.worldPos[kid], target.bind.worldPos[i]));
+        const us = unit(sub2(turned.bind.worldPos[byTarget.get(kid)], turned.bind.worldPos[byTarget.get(i)]));
         if (!ut || !us)
           continue;
         legDisagreement += Math.acos(Math.max(-1, Math.min(1, ut[0] * us[0] + ut[1] * us[1] + ut[2] * us[2]))) * DEG;
@@ -5048,15 +5400,54 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
     if (n)
       legDisagreement /= n;
   }
-  const donorRefMode = opts.donorRef ?? (legs.length && legDisagreement > 12 ? "auto" : "bind");
+  const donorRefMode = opts.donorRef ?? (opts.humanoid ? "bind" : legs.length && legDisagreement > 12 ? "auto" : "bind");
   const { rig: donor, from: donorRefFrom } = donorReference(turned, donorRefMode, fps);
   for (const l of legs)
-    l.baseDonor = Math.min(l.baseDonor, donor.bind.worldPos[l.donorEffector][1]);
+    l.baseDonor = opts.humanoid ? donor.bind.worldPos[l.donorContact][1] : Math.min(l.baseDonor, donor.bind.worldPos[l.donorContact][1]);
   if (legs.length)
     donorGround = Math.min(...legs.map((l) => l.baseDonor));
   for (const l of legs)
-    l.stanceDonor = sub(donor.bind.worldPos[l.donorEffector], donor.bind.worldPos[l.donorHip]);
+    l.stanceDonor = donorReach(l, donor.bind.worldPos);
   const policies = { ...opts.alignTo ?? {}, ...opts.alignBones ?? {} };
+  const forced = new Set;
+  if (hum?.target.transfer?.align)
+    for (const [k, v] of Object.entries(hum.target.transfer.align)) {
+      const n = hum.target.bones[k];
+      if (!n || n in policies)
+        continue;
+      const i = target.index.get(n);
+      if (i === undefined || !byTarget.has(i))
+        continue;
+      if (v === "keep")
+        policies[n] = "keep";
+      else
+        forced.add(i);
+    }
+  if (hum) {
+    const T = hum.target;
+    const set = (k, pol) => {
+      const n = T.bones[k];
+      if (n !== undefined && !(n in policies) && target.index.has(n) && byTarget.has(target.index.get(n)))
+        policies[n] = pol;
+    };
+    for (const k of ["Hips", "Spine", "Chest", "UpperChest", "Neck", "Head", "Jaw", "LeftEye", "RightEye"])
+      set(k, "keep");
+    const refTo = (k, ...tos) => {
+      const names = tos.map((t) => T.bones[t]).filter((n) => !!n);
+      set(k, names.length ? names : "direction");
+    };
+    for (const s of ["Left", "Right"]) {
+      refTo(`${s}Shoulder`, `${s}UpperArm`);
+      refTo(`${s}UpperArm`, `${s}LowerArm`);
+      refTo(`${s}LowerArm`, `${s}Hand`);
+      refTo(`${s}Hand`, `${s} Index Proximal`, `${s} Middle Proximal`, `${s} Ring Proximal`, `${s} Little Proximal`);
+      for (const f of ["Thumb", "Index", "Middle", "Ring", "Little"]) {
+        refTo(`${s} ${f} Proximal`, `${s} ${f} Intermediate`);
+        refTo(`${s} ${f} Intermediate`, `${s} ${f} Distal`);
+        set(`${s} ${f} Distal`, "direction");
+      }
+    }
+  }
   let stance = legs.length > 0;
   if (legs.length) {
     let lo = Infinity, hi = -Infinity;
@@ -5066,10 +5457,10 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
         hi = Math.max(hi, target.bind.worldPos[i][1]);
       }
     const height = hi - lo || 1;
-    const footYs = legs.map((l) => target.bind.worldPos[l.effector][1]);
+    const footYs = legs.map((l) => target.bind.worldPos[l.contact][1]);
     const lowestFoot = Math.min(...footYs);
     for (const leg of legs) {
-      const hipY = target.bind.worldPos[leg.chain[0]][1], footY = target.bind.worldPos[leg.effector][1];
+      const hipY = target.bind.worldPos[leg.chain[0]][1], footY = target.bind.worldPos[leg.contact][1];
       const L = leg.lengths.reduce((a, b) => a + b, 0);
       if ((hipY - footY) / L < 0.5)
         stance = false;
@@ -5090,61 +5481,166 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
         if (!(name in policies))
           policies[name] = "direction";
       }
-  const { ref: ref2, A, log: alignLog, kept } = alignReference(target, donor, byTarget, rootIdx, opts.align ?? "bone-direction", policies);
+  for (const i of forced)
+    if (policies[target.names[i]] === "keep")
+      policies[target.names[i]] = "direction";
+  const { ref: ref2, A, log: alignLog, kept, under: alignUnder } = alignReference(target, donor, byTarget, rootIdx, opts.align ?? "bone-direction", policies, hum ? 8 : 0, forced);
+  if (opts.ik === "legs+hands" && hum) {
+    const handNames = ["LeftHand", "RightHand"].map((k) => hum.target.bones[k]).filter((n) => !!n && byTarget.has(target.index.get(n)));
+    for (const h of detectLegs(target, turned, byTarget, target.bind.worldPos, handNames, warn, 2)) {
+      h.isFoot = false;
+      h.baseDonor = donor.bind.worldPos[h.donorContact][1];
+      h.stanceDonor = donorReach(h, donor.bind.worldPos);
+      legs.push(h);
+    }
+  }
   const bridges = findBridges(target, byTarget);
+  if (hum) {
+    const hands = new Set([humIdx(hum.target, "LeftHand"), humIdx(hum.target, "RightHand")].filter((i) => i !== undefined));
+    for (const b of bridges.values())
+      if (hands.has(b.above))
+        b.u = 0;
+  }
   for (const [i, b] of bridges) {
     const a = qslerp(A[b.above], A[b.below], b.u);
     A[i] = a;
     ref2[i] = qnorm(qmul(a, target.bind.worldRot[i]));
   }
+  const rollLog = [];
+  if (hum && (opts.align ?? "bone-direction") !== "none") {
+    const pt = posesFrom(target, ref2);
+    const { donor: D, target: T } = hum;
+    const dIdx = (k) => {
+      const n = D.bones[k];
+      return n === undefined ? undefined : donor.index.get(n);
+    };
+    const children2 = childrenOf(target);
+    for (const s of ["Left", "Right"]) {
+      const tLower = humIdx(T, `${s}LowerArm`), tHand = humIdx(T, `${s}Hand`), dLower = dIdx(`${s}LowerArm`), dHand = dIdx(`${s}Hand`);
+      if (tLower === undefined || tHand === undefined || dLower === undefined || dHand === undefined)
+        continue;
+      const axisT = unit(sub2(pt[tHand], pt[tLower])), axisD = unit(sub2(donor.bind.worldPos[dHand], donor.bind.worldPos[dLower]));
+      if (!axisT || !axisD)
+        continue;
+      const line = (av, pos, idx, hand) => {
+        const i = idx(`${s} Index Proximal`), l = idx(`${s} Little Proximal`), th = idx(`${s} Thumb Proximal`);
+        if (i !== undefined && l !== undefined)
+          return { v: sub2(pos[i], pos[l]), via: "knuckle line" };
+        if (th !== undefined)
+          return { v: sub2(pos[th], pos[hand]), via: "thumb base" };
+        return null;
+      };
+      const kt = line(T, pt, (k) => humIdx(T, k), tHand), kd = line(D, donor.bind.worldPos, dIdx, dHand);
+      if (!kt || !kd) {
+        warn(`${s.toLowerCase()} arm: no fingers on the ${kt ? "donor" : "target"} — palm roll not corrected`);
+        continue;
+      }
+      const perp = (v, ax) => {
+        const d = v[0] * ax[0] + v[1] * ax[1] + v[2] * ax[2];
+        return unit([v[0] - ax[0] * d, v[1] - ax[1] * d, v[2] - ax[2] * d]);
+      };
+      const a = perp(kt.v, axisD), b = perp(kd.v, axisD);
+      if (!a || !b)
+        continue;
+      const cross2 = [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+      const ang = Math.atan2(cross2[0] * axisD[0] + cross2[1] * axisD[1] + cross2[2] * axisD[2], a[0] * b[0] + a[1] * b[1] + a[2] * b[2]) + (hum.target.transfer?.roll?.[s] ?? 0) / DEG;
+      const deg = Math.abs(ang) * DEG;
+      if (deg < 1) {
+        rollLog.push({ side: s, degrees: 0, via: kt.via });
+        continue;
+      }
+      const R = qnorm([axisD[0] * Math.sin(ang / 2), axisD[1] * Math.sin(ang / 2), axisD[2] * Math.sin(ang / 2), Math.cos(ang / 2)]);
+      const stack = [tLower];
+      while (stack.length) {
+        const i = stack.pop();
+        ref2[i] = qnorm(qmul(R, ref2[i]));
+        A[i] = qnorm(qmul(ref2[i], qinv(target.bind.worldRot[i])));
+        stack.push(...children2[i]);
+      }
+      rollLog.push({ side: s, degrees: deg, via: `${kt.via} vs ${kd.via}` });
+    }
+  }
   const refPos = posesFrom(target, ref2);
   const skinned = target.bind.fromSkin.map((v, i) => v ? i : -1).filter((i) => i >= 0);
   const lowestBind = Math.min(...skinned.map((i) => target.bind.worldPos[i][1]));
+  const donorChildren = childrenOf(donor);
+  const donorSkinned = donor.bind.fromSkin.some(Boolean) ? donor.bind.fromSkin.map((v, i) => v ? i : -1).filter((i) => i >= 0) : donor.names.map((_, i) => i);
+  const donorLowestBind = Math.min(...donorSkinned.map((i) => donor.bind.worldPos[i][1]));
   const ground = legs.length ? { target: lowestBind, donor: donorGround } : null;
   const feet = legs.filter((l) => l.isFoot);
-  const lowestOf = feet.length ? feet.map((l) => l.effector) : skinned;
-  let groundOffset = lowestBind - Math.min(...lowestOf.map((i) => refPos[i][1]));
-  for (const leg of feet) {
-    const hipY = refPos[leg.chain[0]][1] + groundOffset;
-    const reach = 0.98 * leg.lengths.reduce((a, b) => a + b, 0);
-    if (hipY - lowestBind > reach)
-      groundOffset -= hipY - lowestBind - reach;
-  }
+  const restAbove = (leg) => stance ? target.bind.worldPos[leg.contact][1] - lowestBind : 0;
+  let groundOffset = feet.length ? lowestBind - Math.min(...feet.map((l) => refPos[l.contact][1] - restAbove(l))) : lowestBind - Math.min(...skinned.map((i) => refPos[i][1]));
+  if (!stance)
+    for (const leg of feet) {
+      const hipY = refPos[leg.chain[0]][1] + groundOffset;
+      const reach = 0.98 * leg.lengths.reduce((a, b) => a + b, 0);
+      const floor = lowestBind + restAbove(leg);
+      if (hipY - floor > reach)
+        groundOffset -= hipY - floor - reach;
+    }
   const refPosGrounded = refPos.map((p) => [p[0], p[1] + groundOffset, p[2]]);
   const localOff = target.names.map((_, i) => {
     const p = target.parents[i];
     if (p < 0)
       return [0, 0, 0];
-    return qrot(qinv(target.bind.worldRot[p]), sub(target.bind.worldPos[i], target.bind.worldPos[p]));
+    return qrot(qinv(target.bind.worldRot[p]), sub2(target.bind.worldPos[i], target.bind.worldPos[p]));
   });
   const children = childrenOf(target);
-  const placeLeg = (leg, goal, rot, pos) => {
+  const donorBend = (leg, dpos) => {
+    const hip = dpos[leg.donorHip], end = dpos[leg.donorEffector];
+    const axis = unit(sub2(end, hip));
+    if (!axis)
+      return null;
+    const acc = [0, 0, 0];
+    let n = 0;
+    for (let k = 1;k < leg.chain.length; k++) {
+      const d = byTarget.get(leg.chain[k]);
+      if (d === undefined)
+        continue;
+      const v = sub2(dpos[d], hip), t = v[0] * axis[0] + v[1] * axis[1] + v[2] * axis[2];
+      acc[0] += v[0] - axis[0] * t;
+      acc[1] += v[1] - axis[1] * t;
+      acc[2] += v[2] - axis[2] * t;
+      n++;
+    }
+    const dir = n ? unit(acc) : null;
+    return dir ? { dir, off: len2(acc) / n / donorLegLen(leg) } : null;
+  };
+  const placeLeg = (leg, goal, rot, pos, bend = null) => {
     const full = [...leg.chain, leg.effector];
     const hip = pos[leg.chain[0]];
     const pts = full.map((i) => [...pos[i]]);
     const total = leg.lengths.reduce((a, b) => a + b, 0);
-    const short = len(sub(goal, hip)) - total;
-    const axis = unit(sub(pts[pts.length - 1], hip));
+    const short = len2(sub2(goal, hip)) - total;
+    const axis = unit(sub2(pts[pts.length - 1], hip));
     if (axis && short < 0) {
-      let flat = true;
-      for (let k = 1;k < pts.length - 1 && flat; k++) {
-        const v = sub(pts[k], hip), d = v[0] * axis[0] + v[1] * axis[1] + v[2] * axis[2];
-        if (len([v[0] - axis[0] * d, v[1] - axis[1] * d, v[2] - axis[2] * d]) > 0.0001 * total)
-          flat = false;
-      }
-      if (flat) {
-        const hipTurn = qmul(rot[leg.chain[0]], qinv(target.bind.worldRot[leg.chain[0]]));
-        const nudge = leg.pole ? qrot(hipTurn, leg.pole) : [0, 0, 1];
-        const dist = len(sub(goal, hip));
-        const sag = Math.max(0.001 * total, 0.5 * Math.sqrt(Math.max(0, total * total - dist * dist)));
-        for (let k = 1;k < pts.length - 1; k++)
-          pts[k] = add(pts[k], scl(nudge, sag));
+      const hipTurn = qmul(rot[leg.chain[0]], qinv(target.bind.worldRot[leg.chain[0]]));
+      const pole = leg.pole ? qrot(hipTurn, leg.pole) : [0, 0, 1];
+      const acc = [0, 0, 0];
+      for (let k = 1;k < pts.length - 1; k++) {
+        const v = sub2(pts[k], hip), d = v[0] * axis[0] + v[1] * axis[1] + v[2] * axis[2];
+        acc[0] += v[0] - axis[0] * d;
+        acc[1] += v[1] - axis[1] * d;
+        acc[2] += v[2] - axis[2] * d;
+      }
+      const off = bend ? bend.off * total : len2(acc) / (pts.length - 2);
+      const cur = bend ? bend.dir : unit(acc);
+      const against = cur ? cur[0] * pole[0] + cur[1] * pole[1] + cur[2] * pole[2] < 0 : false;
+      const w = cur && !against ? Math.min(1, off / (BEND_TRUST * total)) : 0;
+      if (w < 1) {
+        const dir = unit(add(scl2(pole, 1 - w), scl2(cur ?? pole, w))) ?? pole;
+        const dist = len2(sub2(goal, hip));
+        const sag = Math.max(off, 0.001 * total, 0.5 * Math.sqrt(Math.max(0, total * total - dist * dist)));
+        for (let k = 1;k < pts.length - 1; k++) {
+          const v = sub2(pts[k], hip), d = v[0] * axis[0] + v[1] * axis[1] + v[2] * axis[2];
+          pts[k] = add(add(hip, scl2(axis, d)), scl2(dir, sag));
+        }
       }
     }
     fabrik(pts, leg.lengths, goal);
     for (let k = 0;k < leg.chain.length; k++) {
       const i = leg.chain[k], next = full[k + 1];
-      const cur = unit(qrot(rot[i], localOff[next])), want = unit(sub(pts[k + 1], pos[i]));
+      const cur = unit(qrot(rot[i], localOff[next])), want = unit(sub2(pts[k + 1], pos[i]));
       if (cur && want)
         rot[i] = qnorm(qmul(arc(cur, want), rot[i]));
       pos[next] = add(pos[i], qrot(rot[i], localOff[next]));
@@ -5160,17 +5656,70 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
     return short;
   };
   for (const leg of feet) {
-    const foot = refPosGrounded[leg.effector];
-    if (Math.abs(foot[1] - lowestBind) < 0.000001)
+    const c = refPosGrounded[leg.contact], floor = lowestBind + restAbove(leg);
+    if (Math.abs(c[1] - floor) < 0.000001)
       continue;
-    placeLeg(leg, [foot[0], lowestBind, foot[2]], ref2, refPosGrounded);
+    const e = refPosGrounded[leg.effector];
+    placeLeg(leg, [e[0], e[1] + floor - c[1], e[2]], ref2, refPosGrounded);
   }
   for (const leg of legs) {
-    leg.baseTarget = refPosGrounded[leg.effector][1];
-    leg.stanceTarget = sub(refPosGrounded[leg.effector], refPosGrounded[leg.chain[0]]);
+    leg.baseTarget = refPosGrounded[leg.contact][1];
+    leg.stanceTarget = sub2(refPosGrounded[leg.contact], refPosGrounded[leg.chain[0]]);
+    leg.refReach = len2(sub2(refPosGrounded[leg.effector], refPosGrounded[leg.chain[0]]));
   }
   for (const i of byTarget.keys())
     A[i] = qnorm(qmul(ref2[i], qinv(target.bind.worldRot[i])));
+  const twists = [];
+  const twistFraction = opts.twist === false ? 0 : opts.twist ?? 0.5;
+  if (hum && twistFraction > 0) {
+    const NEXT = {
+      LeftUpperArm: "LeftLowerArm",
+      LeftLowerArm: "LeftHand",
+      RightUpperArm: "RightLowerArm",
+      RightLowerArm: "RightHand",
+      LeftUpperLeg: "LeftLowerLeg",
+      LeftLowerLeg: "LeftFoot",
+      RightUpperLeg: "RightLowerLeg",
+      RightLowerLeg: "RightFoot"
+    };
+    for (const [name, of] of Object.entries(hum.target.twist)) {
+      const h = target.index.get(name), p = humIdx(hum.target, of), nxt = NEXT[of], c = nxt ? humIdx(hum.target, nxt) : undefined;
+      if (h === undefined || p === undefined || c === undefined || target.parents[h] !== p || !byTarget.has(p) || !byTarget.has(c))
+        continue;
+      let g = target.parents[p];
+      while (g >= 0 && !byTarget.has(g))
+        g = target.parents[g];
+      if (g < 0)
+        continue;
+      const axis = unit(sub2(target.bind.worldPos[c], target.bind.worldPos[p]));
+      if (!axis)
+        continue;
+      const along = sub2(target.bind.worldPos[h], target.bind.worldPos[p]);
+      const t = Math.max(0, Math.min(1, (along[0] * axis[0] + along[1] * axis[1] + along[2] * axis[2]) / len2(sub2(target.bind.worldPos[c], target.bind.worldPos[p]))));
+      twists.push({ bone: h, parent: p, grand: g, child: c, t, axisLocal: qrot(qinv(target.bind.worldRot[p]), axis), name, of });
+    }
+  }
+  const separateRoot = rootIdx >= 0 && hipsIdx >= 0 && hipsIdx !== rootIdx && donorRoot !== undefined;
+  const rootMotion = (opts.rootMotion ?? "auto") === "auto" ? separateRoot ? "root" : "hips" : opts.rootMotion;
+  const donorHipsForYaw = hum ? (() => {
+    const n = hum.donor.bones.Hips;
+    return n === undefined ? undefined : donor.index.get(n);
+  })() : undefined;
+  const rootRotation = (opts.rootRotation ?? "none") === "yaw" && rootTranslateOnly && donorHipsForYaw !== undefined ? "yaw" : "none";
+  if ((opts.rootRotation ?? "none") === "yaw" && rootRotation === "none")
+    warn(`rootRotation 'yaw' needs a target root above the hips mapped to the donor's hips${hum ? "" : " (humanoid avatars)"} — the root keeps its bind heading`);
+  const hipsHeading = (dwRot) => {
+    const q = qmul(dwRot[donorHipsForYaw], qinv(donor.bind.worldRot[donorHipsForYaw]));
+    const f = qrot(q, [0, 0, 1]);
+    return Math.atan2(f[0], f[2]);
+  };
+  const wrapRad = (a) => Math.atan2(Math.sin(a), Math.cos(a));
+  const donorHips = hum ? (() => {
+    const n = hum.donor.bones.Hips;
+    return n === undefined ? undefined : donor.index.get(n);
+  })() : undefined;
+  const donorBob = separateRoot && donorHips !== undefined && donorHips !== donorRoot && donor.parents[donorHips] >= 0;
+  const hipsParent = hipsIdx >= 0 ? target.parents[hipsIdx] : -1;
   let rootScaleFrom = "none";
   const rootScale = (() => {
     if (opts.rootScale !== undefined) {
@@ -5198,20 +5747,32 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
     legDisagreement,
     stance,
     align: alignLog,
+    underThreshold: alignUnder,
     kept,
     bridges: [...bridges.keys()].map((i) => target.names[i]),
     groundOffset,
     ground,
-    legs: legs.map((l) => ({ effector: l.name, donorEffector: donor.names[l.donorEffector], chain: l.chain.map((i) => target.names[i]), ratio: l.ratio, shortfall: 0 })),
+    legs: legs.map((l) => ({ effector: l.name, donorEffector: donor.names[l.donorEffector], contact: target.names[l.contact], chain: l.chain.map((i) => target.names[i]), ratio: l.ratio, shortfall: 0, isFoot: l.isFoot, planted: 0 })),
     clips: [],
     mapped: pairs.map((p) => ({ target: p.target, donor: p.donor })),
     unmappedTarget: target.names.filter((n, i) => !byTarget.has(i) && !bridges.has(i) && target.nodes[i].getMesh() === null),
     rootScale,
     rootScaleFrom,
-    root: rootIdx >= 0 && donorRoot !== undefined ? { target: target.names[rootIdx], donor: donor.names[donorRoot] } : null
+    root: rootIdx >= 0 && donorRoot !== undefined ? { target: target.names[rootIdx], donor: donor.names[donorRoot] } : null,
+    rootTranslateOnly,
+    roll: rollLog,
+    rootMotion,
+    rootRotation,
+    hipsBob: separateRoot ? donorBob ? "donor" : rootMotion === "hips" ? null : "root" : null,
+    twist: twists.map((t) => ({ bone: t.name, of: t.of, at: t.t }))
   };
-  const animated = new Set([...byTarget.keys(), ...bridges.keys()]);
+  const animated = new Set([...byTarget.keys(), ...bridges.keys(), ...twists.map((t) => t.bone)]);
   const rootRefPos = rootIdx >= 0 ? refPosGrounded[rootIdx] : null;
+  const plantOn = opts.plant !== false;
+  const donorLegLen = (l) => len2(sub2(donor.bind.worldPos[l.donorEffector], donor.bind.worldPos[l.donorHip])) || 1;
+  const PLANT_FADE = 4;
+  const driven = new Set([...byTarget.keys(), ...bridges.keys()]);
+  const hipsParentScale = hipsParent >= 0 ? restWorld.scale[hipsParent] : 1;
   for (const clip of clips) {
     const frames = Math.max(2, Math.round(clip.duration * fps) + 1);
     const channels = new Map;
@@ -5223,47 +5784,306 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
       }
       return c;
     };
+    const events = [];
+    const open = new Map;
+    const mark = (kind, bone, time, value, at) => {
+      const key = `${kind}:${bone}`;
+      const e = open.get(key);
+      if (e) {
+        e.to = time;
+        if (value !== undefined)
+          e.value = Math.max(e.value ?? 0, value);
+      } else {
+        const n = { kind, bone, from: time, to: time, ...value !== undefined ? { value } : {}, ...at ? { at } : {} };
+        open.set(key, n);
+        events.push(n);
+      }
+    };
+    const rootXZ = () => rootIdx >= 0 ? wpos[rootIdx] : hipsIdx >= 0 ? wpos[hipsIdx] : [0, 0, 0];
+    let rootFirst = [0, 0, 0], rootLast = [0, 0, 0];
+    const rootTrack = [];
+    const contactTrack = new Map;
     const wrot = new Array(target.names.length);
     const wpos = new Array(target.names.length);
     const delta = new Array(target.names.length);
-    for (let f = 0;f < frames; f++) {
-      const time = f / (frames - 1) * clip.duration;
-      const donorPose = clip.sample(time);
+    const timeOf = (f) => f / (frames - 1) * clip.duration;
+    const yaw0 = rootRotation === "yaw" ? hipsHeading(worldOf(donor, clip.sample(0)).rot) : 0;
+    const turn = rootRotation === "yaw" ? wrapRad(hipsHeading(worldOf(donor, clip.sample(clip.duration)).rot) - yaw0) * DEG : 0;
+    const frameFK = (f) => {
+      const donorPose = clip.sample(timeOf(f));
       const dw = worldOf(donor, donorPose);
       for (const i of byTarget.keys()) {
         const s = byTarget.get(i);
         delta[i] = qmul(dw.rot[s], qinv(donor.bind.worldRot[s]));
       }
+      if (rootTranslateOnly) {
+        if (rootRotation === "yaw") {
+          const y = wrapRad(hipsHeading(dw.rot) - yaw0);
+          delta[rootIdx] = [0, Math.sin(y / 2), 0, Math.cos(y / 2)];
+        } else
+          delta[rootIdx] = IDENT;
+      }
       for (const [i, b] of bridges)
         delta[i] = qslerp(delta[b.above], delta[b.below], b.u);
+      let bob = null;
+      if (donorBob && donorRoot !== undefined && donorHips !== undefined) {
+        const v = sub2(dw.pos[donorHips], dw.pos[donorRoot]);
+        const v0 = sub2(donor.bind.worldPos[donorHips], donor.bind.worldPos[donorRoot]);
+        const dRoot = qmul(dw.rot[donorRoot], qinv(donor.bind.worldRot[donorRoot]));
+        bob = scl2(sub2(v, qrot(dRoot, v0)), rootScale);
+      }
       for (const i of target.order) {
         const p = target.parents[i];
-        if (animated.has(i))
+        if (driven.has(i))
           wrot[i] = qnorm(qmul(delta[i], ref2[i]));
         else
           wrot[i] = p >= 0 ? qnorm(qmul(wrot[p], target.rest.r[i])) : qnorm(target.rest.r[i]);
         if (i === rootIdx && rootRefPos && donorRoot !== undefined) {
           const d = dw.pos[donorRoot], r = donor.bind.worldPos[donorRoot];
-          wpos[i] = add(rootRefPos, scl(sub(d, r), rootScale));
+          wpos[i] = add(rootRefPos, scl2(sub2(d, r), rootScale));
         } else if (p < 0)
           wpos[i] = target.rest.t[i];
         else
           wpos[i] = add(wpos[p], qrot(wrot[p], localOff[i]));
+        if (i === hipsIdx && bob)
+          wpos[i] = add(wpos[i], bob);
       }
+      return { dw };
+    };
+    const goalOf = (leg, dw) => {
+      const hip = wpos[leg.chain[0]];
+      const off = sub2(wpos[leg.contact], wpos[leg.effector]);
+      const a = sub2(donorReach(leg, dw.pos), off);
+      const c = [0, 1, 2].map((i) => leg.stanceTarget[i] - leg.stanceDonor[i]);
+      const R = 0.995 * leg.lengths.reduce((x, y) => x + y, 0);
+      let k = 1;
+      if (len2(add(a, c)) > R) {
+        const cc = c[0] * c[0] + c[1] * c[1] + c[2] * c[2], ac = a[0] * c[0] + a[1] * c[1] + a[2] * c[2], aa = a[0] * a[0] + a[1] * a[1] + a[2] * a[2] - R * R;
+        const disc = ac * ac - cc * aa;
+        k = cc > 0.000000000001 && disc >= 0 ? Math.max(0, Math.min(1, (-ac + Math.sqrt(disc)) / cc)) : 0;
+      }
+      let effector = [0, 1, 2].map((i) => hip[i] + a[i] + c[i] * k);
+      if (leg.isFoot && leg.refReach > 0) {
+        const ankle = add(scl2(sub2(dw.pos[leg.donorEffector], dw.pos[leg.donorHip]), leg.ratio), c);
+        const dir = unit(ankle);
+        const ext = len2(sub2(dw.pos[leg.donorEffector], dw.pos[leg.donorHip])) / donorLegLen(leg);
+        if (dir)
+          effector = add(hip, scl2(dir, Math.min(R / 0.995, ext * leg.refReach)));
+      }
+      return { effector, contact: add(effector, off) };
+    };
+    const spans = [];
+    if (plantOn && legs.some((l) => l.isFoot)) {
+      const feetIdx = legs.map((l, i) => l.isFoot ? i : -1).filter((i) => i >= 0);
+      const goals = feetIdx.map(() => new Array(frames));
+      const rel = feetIdx.map(() => new Array(frames));
+      const still = feetIdx.map(() => new Array(frames).fill(false));
+      let prev = null;
+      for (let f = 0;f < frames; f++) {
+        const { dw } = frameFK(f);
+        feetIdx.forEach((li, k) => {
+          const leg = legs[li], L = donorLegLen(leg), dFoot = dw.pos[leg.donorContact];
+          goals[k][f] = goalOf(leg, dw).contact;
+          rel[k][f] = sub2(dFoot, dw.pos[leg.donorHip]);
+          const speed = prev ? len2(sub2(dFoot, prev[k])) * fps : Infinity;
+          still[k][f] = speed < 0.15 * L && dFoot[1] - leg.baseDonor < 0.06 * L;
+        });
+        prev = feetIdx.map((li) => dw.pos[legs[li].donorContact]);
+      }
+      feetIdx.forEach((li, k) => {
+        const s = still[k];
+        const L = donorLegLen(legs[li]);
+        const cyclic = len2(sub2(rel[k][0], rel[k][frames - 1])) < 0.02 && s[frames - 1];
+        if (cyclic)
+          s[0] = true;
+        const runs = [];
+        for (let i = 0;i < frames; i++) {
+          if (!s[i])
+            continue;
+          const last = runs[runs.length - 1];
+          if (last && last.start + last.length === i)
+            last.length++;
+          else
+            runs.push({ start: i, length: 1 });
+        }
+        const travel2 = sub2(goals[k][frames - 1], goals[k][0]);
+        const head = runs[0], tail = runs[runs.length - 1];
+        const seam = cyclic && runs.length >= 2 && head.start === 0 && tail.start + tail.length === frames;
+        const meanOf = (list) => {
+          const acc = [0, 0, 0];
+          let n = 0;
+          for (const r of list)
+            for (let i = r.start;i < r.start + r.length; i++) {
+              const g = add(goals[k][i], r.shift);
+              acc[0] += g[0];
+              acc[1] += g[1];
+              acc[2] += g[2];
+              n++;
+            }
+          return { anchor: scl2(acc, 1 / Math.max(1, n)), n };
+        };
+        const fits = (r, anchor) => {
+          let worst = 0;
+          for (let i = r.start;i < r.start + r.length; i++)
+            worst = Math.max(worst, Math.hypot(goals[k][i][0] - anchor[0], goals[k][i][2] - anchor[2]));
+          return worst <= 0.05 * L;
+        };
+        for (const r of runs) {
+          if (seam && (r === head || r === tail))
+            continue;
+          if (r.length < 3)
+            continue;
+          const { anchor } = meanOf([{ ...r, shift: [0, 0, 0] }]);
+          if (fits(r, anchor))
+            spans.push({ leg: li, start: r.start, length: r.length, anchor });
+        }
+        if (seam && head.length + tail.length >= 3) {
+          const { anchor } = meanOf([{ ...head, shift: [0, 0, 0] }, { ...tail, shift: scl2(travel2, -1) }]);
+          const tailAnchor = add(anchor, travel2);
+          if (fits(head, anchor) && fits(tail, tailAnchor)) {
+            spans.push({ leg: li, start: head.start, length: head.length, anchor, openStart: true });
+            spans.push({ leg: li, start: tail.start, length: tail.length, anchor: tailAnchor, openEnd: true });
+          }
+        }
+      });
+    }
+    const plantAt = (li, f) => {
+      for (const s of spans) {
+        if (s.leg !== li)
+          continue;
+        const n = f - s.start;
+        if (n < 0 || n >= s.length)
+          continue;
+        const w = Math.min(1, s.openStart ? 1 : (n + 1) / PLANT_FADE, s.openEnd ? 1 : (s.length - n) / PLANT_FADE);
+        return { anchor: s.anchor, w };
+      }
+      return null;
+    };
+    for (const s of spans)
+      report.legs[s.leg].planted += s.length;
+    for (let f = 0;f < frames; f++) {
+      const time = timeOf(f);
+      const { dw } = frameFK(f);
+      const active = new Set;
+      if (f === 0)
+        rootFirst = [...rootXZ()];
+      if (f === frames - 1)
+        rootLast = [...rootXZ()];
       if (legs.length) {
         for (const [li, leg] of legs.entries()) {
-          const dHip = dw.pos[leg.donorHip], dFoot = dw.pos[leg.donorEffector];
-          const hip = wpos[leg.chain[0]];
-          const goal = [
-            hip[0] + leg.stanceTarget[0] + (dFoot[0] - dHip[0] - leg.stanceDonor[0]) * leg.ratio,
-            leg.baseTarget + (dFoot[1] - leg.baseDonor) * leg.ratio,
-            hip[2] + leg.stanceTarget[2] + (dFoot[2] - dHip[2] - leg.stanceDonor[2]) * leg.ratio
-          ];
-          const short = placeLeg(leg, goal, wrot, wpos);
+          const g = goalOf(leg, dw), goal = g.effector;
+          const pl = plantAt(li, f);
+          if (pl) {
+            goal[0] += (pl.anchor[0] - g.contact[0]) * pl.w;
+            goal[2] += (pl.anchor[2] - g.contact[2]) * pl.w;
+          }
+          const slack = len2(sub2(scl2(sub2(dw.pos[leg.donorContact], dw.pos[leg.donorEffector]), leg.contactRatio), sub2(wpos[leg.contact], wpos[leg.effector])));
+          const short = placeLeg(leg, goal, wrot, wpos, donorBend(leg, dw.pos)) - slack;
+          if (pl) {
+            const held = target.names[leg.contact];
+            const r = rootXZ(), c = wpos[leg.contact];
+            mark("plant", held, time, undefined, [c[0] - r[0], c[1], c[2] - r[2]]);
+            active.add(`plant:${held}`);
+          }
           if (short > report.legs[li].shortfall)
             report.legs[li].shortfall = short;
+          if (short > 0.005) {
+            mark("reach", leg.name, time, short);
+            active.add(`reach:${leg.name}`);
+          }
+          if (leg.isFoot) {
+            const deepest = () => {
+              let worst = { bone: -1, dip: 0 };
+              const below = [...children[leg.effector]];
+              while (below.length) {
+                const c = below.pop();
+                const dip = lowestBind - wpos[c][1];
+                if (dip > worst.dip)
+                  worst = { bone: c, dip };
+                below.push(...children[c]);
+              }
+              return worst;
+            };
+            const d = deepest();
+            let donorDip = 0;
+            {
+              const stack = [...donorChildren[leg.donorEffector]];
+              let low = Infinity;
+              while (stack.length) {
+                const c = stack.pop();
+                low = Math.min(low, dw.pos[c][1]);
+                stack.push(...donorChildren[c]);
+              }
+              if (low < Infinity)
+                donorDip = Math.max(0, donorLowestBind - low) * leg.ratio;
+            }
+            d.dip -= donorDip;
+            if (d.dip > 0.002) {
+              const v = sub2(wpos[d.bone], wpos[leg.effector]), r = len2(v);
+              const axis = unit(cross(v, [0, 1, 0]));
+              if (axis && r > 0.0001) {
+                const want = Math.min(1, (v[1] + d.dip) / r), have = v[1] / r;
+                let ang = Math.asin(want) - Math.asin(Math.max(-1, Math.min(1, have)));
+                ang = Math.max(-FOOT_PITCH_CAP, Math.min(FOOT_PITCH_CAP, ang));
+                const tryPitch = (a) => {
+                  const q2 = axisAngle(axis, a);
+                  const p = qrot(q2, v);
+                  return p[1] - v[1];
+                };
+                if (tryPitch(ang) < tryPitch(-ang))
+                  ang = -ang;
+                const q = axisAngle(axis, ang);
+                const stack = [leg.effector];
+                while (stack.length) {
+                  const i = stack.pop();
+                  wrot[i] = qnorm(qmul(q, wrot[i]));
+                  for (const c of children[i]) {
+                    wpos[c] = add(wpos[i], qrot(wrot[i], localOff[c]));
+                    stack.push(c);
+                  }
+                }
+              }
+            }
+            const left = deepest();
+            if (left.dip > 0.01) {
+              mark("below", target.names[left.bone], time, left.dip);
+              active.add(`below:${target.names[left.bone]}`);
+            }
+          }
+        }
+      }
+      for (const k of [...open.keys()])
+        if (!active.has(k))
+          open.delete(k);
+      for (const tw of twists) {
+        const aRef = qrot(ref2[tw.parent], tw.axisLocal);
+        const dP = qmul(wrot[tw.parent], qinv(ref2[tw.parent])), dG = qmul(wrot[tw.grand], qinv(ref2[tw.grand])), dC = qmul(wrot[tw.child], qinv(ref2[tw.child]));
+        const twistIn = twistAbout(qmul(qinv(dG), dP), aRef), twistOut = twistAbout(qmul(qinv(dP), dC), aRef);
+        const ang = twistFraction * (tw.t * twistOut - (1 - tw.t) * twistIn);
+        const aNow = qrot(wrot[tw.parent], tw.axisLocal);
+        wrot[tw.bone] = qnorm(qmul(axisAngle(aNow, ang), qmul(wrot[tw.parent], target.rest.r[tw.bone])));
+        const stack = [tw.bone];
+        while (stack.length) {
+          const i = stack.pop();
+          for (const c of children[i]) {
+            if (!driven.has(c))
+              wrot[c] = qnorm(qmul(wrot[i], target.rest.r[c]));
+            wpos[c] = add(wpos[i], qrot(wrot[i], localOff[c]));
+            stack.push(c);
+          }
         }
       }
+      rootTrack.push([...rootXZ()]);
+      for (const [li, leg] of legs.entries()) {
+        if (!leg.isFoot)
+          continue;
+        let tr = contactTrack.get(li);
+        if (!tr) {
+          tr = [];
+          contactTrack.set(li, tr);
+        }
+        tr.push([...wpos[leg.contact]]);
+      }
       for (const i of animated) {
         const p = target.parents[i];
         const local = p >= 0 ? qnorm(qmul(qinv(wrot[p]), wrot[i])) : wrot[i];
@@ -5274,9 +6094,28 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
         }
       }
       if (rootIdx >= 0 && rootRefPos && donorRoot !== undefined) {
-        const rel = sub(wpos[rootIdx], parentPos);
+        const travel2 = sub2(wpos[rootIdx], rootRefPos);
+        let strip = [0, 0, 0], keep = [0, 0, 0];
+        if (separateRoot) {
+          if (rootMotion === "root") {
+            strip = [0, travel2[1], 0];
+            keep = strip;
+          } else if (rootMotion === "none") {
+            strip = travel2;
+            keep = [0, travel2[1], 0];
+          } else {
+            strip = travel2;
+            keep = travel2;
+          }
+        } else if (rootMotion === "none")
+          strip = [travel2[0], 0, travel2[2]];
+        const rel = sub2(sub2(wpos[rootIdx], strip), parentPos);
         const [x, y, z] = qrot(qinv(parentRot), rel);
         (chan(rootIdx).pos ??= []).push([x / parentScale, y / parentScale, z / parentScale]);
+        if (separateRoot && hipsParent >= 0) {
+          const [hx, hy, hz] = qrot(qinv(wrot[hipsParent]), add(sub2(wpos[hipsIdx], wpos[hipsParent]), keep));
+          (chan(hipsIdx).pos ??= []).push([hx / hipsParentScale, hy / hipsParentScale, hz / hipsParentScale]);
+        }
       }
     }
     for (const c of channels.values())
@@ -5296,7 +6135,54 @@ function retarget(target, donorIn, map, rootBone, opts = {}) {
         keys += c.times.length;
       }
     }
-    report.clips.push({ name: anim.getName(), duration: clip.duration, frames, keys });
+    const sideOf = (li) => {
+      const n = `${legs[li].name} ${target.names[legs[li].contact]}`;
+      if (/left|(^|[_.\s])l([_.\s]|$)/i.test(n))
+        return "l";
+      if (/right|(^|[_.\s])r([_.\s]|$)/i.test(n))
+        return "r";
+      return null;
+    };
+    const contacts = { feet: { l: null, r: null }, l: [], r: [], first: null };
+    const dtF = frames > 1 ? clip.duration / (frames - 1) : 1;
+    for (const [li, leg] of legs.entries()) {
+      if (!leg.isFoot)
+        continue;
+      const side = sideOf(li);
+      const tr = contactTrack.get(li);
+      if (!side || !tr || tr.length < 2)
+        continue;
+      contacts.feet[side] = target.names[leg.contact];
+      const n = tr.length;
+      const sp = tr.map((_, k2) => {
+        const a = tr[Math.max(0, k2 - 1)], b = tr[Math.min(n - 1, k2 + 1)];
+        const dt = (Math.min(n - 1, k2 + 1) - Math.max(0, k2 - 1)) * dtF;
+        return Math.hypot(b[0] - a[0], b[2] - a[2]) / (dt || dtF);
+      });
+      const hs = tr.map((p) => p[1]);
+      const lo = Math.min(...sp), hi = Math.max(...sp), hLo = Math.min(...hs), hHi = Math.max(...hs);
+      const still = hi - lo < 0.05;
+      const down2 = tr.map((_, k2) => still || sp[k2] < lo + 0.2 * (hi - lo) && hs[k2] < hLo + 0.5 * (hHi - hLo));
+      let k = 0;
+      while (k < n) {
+        if (!down2[k]) {
+          k++;
+          continue;
+        }
+        const start = k;
+        while (k < n && down2[k])
+          k++;
+        if (k - start < 2 && !still)
+          continue;
+        const r = rootTrack[start], c = tr[start];
+        contacts[side].push({ from: start * dtF, to: (k - 1) * dtF, at: [c[0] - r[0], c[1], c[2] - r[2]] });
+      }
+    }
+    const down = (side) => contacts[side].some((s) => s.from <= 0.000001);
+    contacts.first = down("l") && down("r") ? "both" : down("l") ? "l" : down("r") ? "r" : null;
+    const travel = [rootLast[0] - rootFirst[0], rootLast[2] - rootFirst[2]];
+    anim.setExtras({ ...anim.getExtras(), lecodes: { contacts, travel } });
+    report.clips.push({ name: anim.getName(), duration: clip.duration, frames, keys, events, turn, contacts, travel });
   }
   return report;
 }
@@ -5313,9 +6199,9 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
       hi[i] = Math.max(hi[i], p[i]);
     }
   const fwd = head && tail ? [head[0] - tail[0], 0, head[2] - tail[2]] : [0, 0, 1];
-  const len = Math.hypot(...fwd) || 1;
+  const len2 = Math.hypot(...fwd) || 1;
   return {
-    forward: [fwd[0] / len, fwd[1] / len, fwd[2] / len],
+    forward: [fwd[0] / len2, fwd[1] / len2, fwd[2] / len2],
     up: [0, 1, 0],
     height: hi[1] - lo[1],
     length: Math.max(hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2])
@@ -5357,8 +6243,8 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
     ch.rot = keepR;
   if (keepP)
     ch.pos = keepP;
-}, sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]], add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]], scl = (a, k) => [a[0] * k, a[1] * k, a[2] * k], len = (v) => Math.hypot(v[0], v[1], v[2]), unit = (v) => {
-  const l = len(v);
+}, sub2 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]], add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]], scl2 = (a, k) => [a[0] * k, a[1] * k, a[2] * k], len2 = (v) => Math.hypot(v[0], v[1], v[2]), unit = (v) => {
+  const l = len2(v);
   return l > 0.000000000001 ? [v[0] / l, v[1] / l, v[2] / l] : null;
 }, arc = (from, to) => {
   const d = from[0] * to[0] + from[1] * to[1] + from[2] * to[2];
@@ -5379,15 +6265,16 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
       children[p].push(i);
   });
   return children;
-}, alignReference = (target, donor, byTarget, rootIdx, align, policies) => {
+}, alignReference = (target, donor, byTarget, rootIdx, align, policies, minDeg = 0, force = new Set) => {
   const ref2 = target.bind.worldRot.map((q) => [...q]);
   const A = target.names.map(() => IDENT);
   const log = [];
+  const under = [];
   const kept = [];
   if (align === "none") {
     for (const i of byTarget.keys())
       kept.push(target.names[i]);
-    return { ref: ref2, A, log, kept };
+    return { ref: ref2, A, log, kept, under };
   }
   const children = childrenOf(target);
   const mappedChildCount = (i) => {
@@ -5440,7 +6327,7 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
     const acc = [0, 0, 0];
     let n = 0;
     for (const to of tos) {
-      const u = unit(sub(to, from));
+      const u = unit(sub2(to, from));
       if (!u)
         continue;
       acc[0] += u[0];
@@ -5474,15 +6361,24 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
     } else if (children[i].length) {
       const donorKids = donor.parents.map((p, k) => [p, k]).filter(([p]) => p === s).map(([, k]) => k);
       if (donorKids.length) {
-        ut = unit(sub(target.bind.worldPos[children[i][0]], target.bind.worldPos[i]));
-        us = unit(sub(donor.bind.worldPos[donorKids[0]], donor.bind.worldPos[s]));
+        ut = unit(sub2(target.bind.worldPos[children[i][0]], target.bind.worldPos[i]));
+        us = unit(sub2(donor.bind.worldPos[donorKids[0]], donor.bind.worldPos[s]));
         via = `${target.names[children[i][0]]} (unmapped child)`;
       }
     }
     let a;
-    if (ut && us)
+    if (ut && us) {
       a = arc(ut, us);
-    else {
+      const off = 2 * Math.acos(Math.min(1, Math.abs(a[3]))) * DEG;
+      if (minDeg > 0 && off < minDeg && !force.has(i)) {
+        if (off > 0.5)
+          under.push({ bone: target.names[i], degrees: off, via });
+        a = IDENT;
+        kept.push(target.names[i]);
+        A[i] = a;
+        continue;
+      }
+    } else {
       a = A[target.parents[i]] ?? IDENT;
       via = "inherited from parent";
     }
@@ -5493,7 +6389,8 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
       log.push({ bone: target.names[i], degrees: deg, via });
   }
   log.sort((a, b) => b.degrees - a.degrees);
-  return { ref: ref2, A, log, kept };
+  under.sort((a, b) => b.degrees - a.degrees);
+  return { ref: ref2, A, log, kept, under };
 }, findBridges = (target, byTarget) => {
   const children = childrenOf(target);
   const subtreeSize = new Array(target.names.length).fill(1);
@@ -5534,7 +6431,7 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
     out.set(i, { above: a, below: b.idx, u: up / (up + b.depth) });
   }
   return out;
-}, detectLegs = (target, donor, byTarget, refPos, explicit, warn) => {
+}, BEND_TRUST = 0.05, FOOT_PITCH_CAP, cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]], detectLegs = (target, donor, byTarget, refPos, explicit, warn, maxAbove = 4) => {
   const children = childrenOf(target);
   const mappedKids = (i) => {
     const out = [];
@@ -5607,11 +6504,11 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
     const path = [];
     for (let b = target.parents[e];b >= 0 && b !== target.parents[hipMapped]; b = target.parents[b])
       path.unshift(b);
-    const chain = path.slice(Math.max(0, path.length - 4));
+    const chain = path.slice(Math.max(0, path.length - maxAbove));
     const legFull = [...chain, e];
     const lengths = [];
     for (let j = 1;j < legFull.length; j++)
-      lengths.push(len(sub(target.bind.worldPos[legFull[j]], target.bind.worldPos[legFull[j - 1]])));
+      lengths.push(len2(sub2(target.bind.worldPos[legFull[j]], target.bind.worldPos[legFull[j - 1]])));
     let hipRef = chain[0];
     while (hipRef >= 0 && !byTarget.has(hipRef))
       hipRef = target.parents[hipRef];
@@ -5623,7 +6520,7 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
         dlen = 0;
         break;
       }
-      dlen += len(sub(donor.bind.worldPos[b], donor.bind.worldPos[p]));
+      dlen += len2(sub2(donor.bind.worldPos[b], donor.bind.worldPos[p]));
     }
     const dfull = [donorHip, donorEffector];
     const tlen = lengths.reduce((a, b) => a + b, 0);
@@ -5632,17 +6529,17 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
     let pole = null;
     {
       const hip = target.bind.worldPos[legFull[0]], foot = target.bind.worldPos[legFull[legFull.length - 1]];
-      const axis = unit(sub(foot, hip));
+      const axis = unit(sub2(foot, hip));
       if (axis) {
         const acc = [0, 0, 0];
         for (let j = 1;j < legFull.length - 1; j++) {
-          const v = sub(target.bind.worldPos[legFull[j]], hip);
+          const v = sub2(target.bind.worldPos[legFull[j]], hip);
           const d = v[0] * axis[0] + v[1] * axis[1] + v[2] * axis[2];
           acc[0] += v[0] - axis[0] * d;
           acc[1] += v[1] - axis[1] * d;
           acc[2] += v[2] - axis[2] * d;
         }
-        if (len(acc) > 0.001 * tlen)
+        if (len2(acc) > 0.001 * tlen)
           pole = unit(acc);
       }
     }
@@ -5651,6 +6548,9 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
       effector: e,
       donorHip: dfull[0],
       donorEffector: dfull[dfull.length - 1],
+      contact: e,
+      donorContact: dfull[dfull.length - 1],
+      contactRatio: 1,
       lengths,
       pole,
       ratio: tlen / dlen,
@@ -5659,34 +6559,42 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
       baseTarget: 0,
       baseDonor: 0,
       stanceTarget: [0, 0, 0],
-      stanceDonor: [0, 0, 0]
+      stanceDonor: [0, 0, 0],
+      refReach: 0
     });
   }
   return legs;
+}, twistAbout = (q, a) => {
+  const d = q[0] * a[0] + q[1] * a[1] + q[2] * a[2];
+  const ang = 2 * Math.atan2(d, q[3]);
+  return ang > Math.PI ? ang - 2 * Math.PI : ang < -Math.PI ? ang + 2 * Math.PI : ang;
+}, axisAngle = (a, ang) => {
+  const s = Math.sin(ang / 2);
+  return [a[0] * s, a[1] * s, a[2] * s, Math.cos(ang / 2)];
 }, fabrik = (p, seg, goal, iterations = 48) => {
   const n = p.length;
   const root = p[0];
   const total = seg.reduce((a, b) => a + b, 0);
-  const toGoal = sub(goal, root);
-  const dist = len(toGoal);
+  const toGoal = sub2(goal, root);
+  const dist = len2(toGoal);
   if (dist >= total * 0.9995) {
     const d = unit(toGoal) ?? [0, -1, 0];
     for (let i = 1;i < n; i++)
-      p[i] = add(p[i - 1], scl(d, seg[i - 1] * 0.9995));
+      p[i] = add(p[i - 1], scl2(d, seg[i - 1] * 0.9995));
     return;
   }
   for (let it = 0;it < iterations; it++) {
     p[n - 1] = goal;
     for (let i = n - 2;i >= 0; i--) {
-      const d = unit(sub(p[i], p[i + 1])) ?? [0, 1, 0];
-      p[i] = add(p[i + 1], scl(d, seg[i]));
+      const d = unit(sub2(p[i], p[i + 1])) ?? [0, 1, 0];
+      p[i] = add(p[i + 1], scl2(d, seg[i]));
     }
     p[0] = root;
     for (let i = 1;i < n; i++) {
-      const d = unit(sub(p[i], p[i - 1])) ?? [0, -1, 0];
-      p[i] = add(p[i - 1], scl(d, seg[i - 1]));
+      const d = unit(sub2(p[i], p[i - 1])) ?? [0, -1, 0];
+      p[i] = add(p[i - 1], scl2(d, seg[i - 1]));
     }
-    if (len(sub(p[n - 1], goal)) < total * 0.000001)
+    if (len2(sub2(p[n - 1], goal)) < total * 0.000001)
       break;
   }
 }, donorReference = (donor, ref2, fps) => {
@@ -5732,7 +6640,7 @@ var DEG, IDENT, analyzeFacing = (rig, boneNames) => {
       pos[i] = target.bind.worldPos[i];
       continue;
     }
-    const off = sub(target.bind.worldPos[i], target.bind.worldPos[p]);
+    const off = sub2(target.bind.worldPos[i], target.bind.worldPos[p]);
     const local = qrot(qinv(target.bind.worldRot[p]), off);
     pos[i] = add(pos[p], qrot(worldRot[p], local));
   }
@@ -5747,6 +6655,7 @@ var init_retarget = __esm(() => {
   init_rig();
   DEG = 180 / Math.PI;
   IDENT = [0, 0, 0, 1];
+  FOOT_PITCH_CAP = 20 * Math.PI / 180;
 });
 
 // src/retarget/unityAnim.ts
@@ -5854,9 +6763,9 @@ function attachUnityClips(rig, clips) {
       }
       return res;
     };
-    const rot = bind(uc.rotation, 4), pos = bind(uc.position, 3), scl2 = bind(uc.scale, 3);
+    const rot = bind(uc.rotation, 4), pos = bind(uc.position, 3), scl3 = bind(uc.scale, 3);
     const total = uc.rotation.length + uc.position.length + uc.scale.length;
-    const bound = rot.length + pos.length + scl2.length;
+    const bound = rot.length + pos.length + scl3.length;
     const unbound = [...uc.rotation, ...uc.position, ...uc.scale].filter((c) => !rig.index.has(c.bone)).map((c) => c.bone);
     report.push({ name: uc.name, bound, total, unbound: [...new Set(unbound)] });
     const base = rig.bind.local;
@@ -5869,7 +6778,7 @@ function attachUnityClips(rig, clips) {
           pose.r[node] = qnorm(sample(c, time, 4));
         for (const { node, c } of pos)
           pose.t[node] = sample(c, time, 3);
-        for (const { node, c } of scl2)
+        for (const { node, c } of scl3)
           pose.s[node] = sample(c, time, 3);
         return pose;
       }
@@ -5906,6 +6815,625 @@ var init_unityAnim = __esm(() => {
   };
 });
 
+// src/retarget/humanoid.ts
+var exports_humanoid = {};
+__export(exports_humanoid, {
+  parseUnityAvatar: () => parseUnityAvatar,
+  mapAvatars: () => mapAvatars,
+  isHumanBone: () => isHumanBone,
+  isBiped: () => isBiped,
+  describeHumanoidMap: () => describeHumanoidMap,
+  describeBiped: () => describeBiped,
+  classifyBiped: () => classifyBiped,
+  avatarToFile: () => avatarToFile,
+  avatarFromUnity: () => avatarFromUnity,
+  avatarFromRig: () => avatarFromRig,
+  avatarFromFile: () => avatarFromFile,
+  avatarFromBiped: () => avatarFromBiped,
+  SIDES: () => SIDES,
+  PHALANGES: () => PHALANGES,
+  HUMAN_BONES: () => HUMAN_BONES,
+  FINGERS: () => FINGERS
+});
+var SIDES, FINGERS, PHALANGES, BODY, LIMB, HUMAN_BONES, HUMAN_SET, isHumanBone = (s) => HUMAN_SET.has(s), parseUnityAvatar = (yaml) => {
+  const bones = {};
+  const unknown = [];
+  const unq = (s) => s.trim().replace(/^'(.*)'$/, "$1").replace(/^"(.*)"$/, "$1");
+  const re = /boneName:\s*([^\n]+)\n\s*humanName:\s*([^\n]+)/g;
+  for (let m = re.exec(yaml);m; m = re.exec(yaml)) {
+    const bone = unq(m[1]), human = unq(m[2]);
+    if (isHumanBone(human))
+      bones[human] = bone;
+    else
+      unknown.push(human);
+  }
+  const rm = /rootMotionBoneName:\s*([^\n]*)/.exec(yaml);
+  const rootMotionBone = rm && unq(rm[1]) ? unq(rm[1]) : null;
+  return { bones, rootMotionBone, unknown };
+}, sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]], dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2], len3 = (v) => Math.hypot(v[0], v[1], v[2]), norm = (v) => {
+  const l = len3(v) || 1;
+  return [v[0] / l, v[1] / l, v[2] / l];
+}, cross2 = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]], angleDeg = (a, b) => Math.acos(Math.max(-1, Math.min(1, dot(norm(a), norm(b))))) * 180 / Math.PI, TOKEN, classifyBiped = (rig) => {
+  const notes = [];
+  const N = rig.names.length;
+  const pos = rig.bind.worldPos;
+  const skinned = (i) => rig.bind.fromSkin[i];
+  const children = rig.names.map(() => []);
+  rig.parents.forEach((p, i) => {
+    if (p >= 0)
+      children[p].push(i);
+  });
+  const skids = (i) => {
+    const out = [];
+    const q = [...children[i]];
+    while (q.length) {
+      const c = q.shift();
+      if (skinned(c))
+        out.push(c);
+      else
+        q.push(...children[c]);
+    }
+    return out;
+  };
+  const sparent = (i) => {
+    let p = rig.parents[i];
+    while (p >= 0 && !skinned(p))
+      p = rig.parents[p];
+    return p;
+  };
+  const joints = rig.order.filter(skinned);
+  if (joints.length < 12)
+    throw new Error(`${rig.label}: ${joints.length} skinned joints — not a humanoid`);
+  const subtree = (i) => {
+    const out = [];
+    const q = [i];
+    while (q.length) {
+      const j = q.shift();
+      out.push(j);
+      q.push(...skids(j));
+    }
+    return out;
+  };
+  const minY = (i) => Math.min(...subtree(i).map((j) => pos[j][1]));
+  const maxY = (i) => Math.max(...subtree(i).map((j) => pos[j][1]));
+  const extent = (i) => {
+    const s = subtree(i);
+    let e = 0;
+    for (const j of s)
+      e = Math.max(e, len3(sub3(pos[j], pos[i])));
+    return e;
+  };
+  let lo = Infinity, hi = -Infinity;
+  for (const i of joints) {
+    lo = Math.min(lo, pos[i][1]);
+    hi = Math.max(hi, pos[i][1]);
+  }
+  const height = hi - lo || 1, ground = lo;
+  const up = [0, 1, 0];
+  const horiz = (v) => [v[0], 0, v[2]];
+  const descend = (from) => {
+    const chain = [from];
+    for (let guard = 0;guard < 64; guard++) {
+      const ks = skids(chain[chain.length - 1]);
+      if (!ks.length)
+        break;
+      chain.push(ks.sort((a, b) => minY(a) - minY(b))[0]);
+    }
+    return chain;
+  };
+  let hips = -1;
+  let legChains = [];
+  for (const h2 of joints) {
+    const cands = skids(h2).map((c) => descend(c)).filter((ch) => ch.length >= 3 && minY(ch[0]) < ground + 0.12 * height && len3(horiz(sub3(pos[ch[0]], pos[h2]))) > 0.02 * height);
+    let best = null, bestScore = -Infinity;
+    for (let a = 0;a < cands.length; a++)
+      for (let b = a + 1;b < cands.length; b++) {
+        const oa = horiz(sub3(pos[cands[a][0]], pos[h2])), ob = horiz(sub3(pos[cands[b][0]], pos[h2]));
+        if (dot(oa, ob) >= 0)
+          continue;
+        const score = cands[a].length + cands[b].length + len3(sub3(oa, ob)) / height * 10;
+        if (score > bestScore) {
+          bestScore = score;
+          best = [cands[a], cands[b]];
+        }
+      }
+    if (!best)
+      continue;
+    if (hips < 0 || pos[h2][1] < pos[hips][1]) {
+      hips = h2;
+      legChains = best;
+    }
+  }
+  if (hips < 0)
+    throw new Error(`${rig.label}: no pelvis with two legs reaching the ground — not a biped`);
+  const legJoints = new Set(legChains.flat());
+  const centreX = pos[hips];
+  const handScore = (i) => {
+    if (legJoints.has(i) || i === hips)
+      return -1;
+    const ks = skids(i).filter((c) => subtree(c).length <= 6 && extent(c) < 0.12 * height);
+    if (ks.length < 3)
+      return -1;
+    const lat = len3(horiz(sub3(pos[i], centreX)));
+    return lat > 0.12 * height ? lat : -1;
+  };
+  const handCands = joints.filter((i) => handScore(i) > 0);
+  const ancestors = (i) => {
+    const out = [];
+    for (let a = i;a >= 0; a = sparent(a))
+      out.push(a);
+    return out;
+  };
+  const lca = (list) => {
+    let common = ancestors(list[0]);
+    for (const i of list.slice(1)) {
+      const set = new Set(ancestors(i));
+      common = common.filter((a) => set.has(a));
+    }
+    return common[0];
+  };
+  const footOf = (chain) => {
+    const last = chain[chain.length - 1];
+    if (chain.length >= 5) {
+      const ball = chain[chain.length - 2], ankle = chain[chain.length - 3];
+      const endSite = /(_end|end|nub|tip)$/i.test(rig.names[last]) && children[last].length === 0;
+      if ((endSite || pos[ball][1] - ground < 0.03 * height) && pos[ball][1] - ground < 0.06 * height && pos[ankle][1] - ground < 0.14 * height)
+        return { foot: ankle, toes: ball };
+    }
+    if (chain.length >= 4 && pos[last][1] - ground < 0.06 * height && pos[chain[chain.length - 2]][1] - ground < 0.14 * height)
+      return { foot: chain[chain.length - 2], toes: last };
+    return { foot: last, toes: null };
+  };
+  let forward = [0, 0, 1];
+  {
+    const dirs = legChains.map(footOf).filter((f) => f.toes !== null).map((f) => horiz(sub3(pos[f.toes], pos[f.foot])));
+    if (dirs.length)
+      forward = norm(dirs.reduce((a, d) => [a[0] + d[0], 0, a[2] + d[2]], [0, 0, 0]));
+    else
+      notes.push("no toe bones — facing assumed +Z");
+  }
+  let lateral = norm(cross2(up, forward));
+  const latOf = (i) => dot(sub3(pos[i], pos[hips]), lateral);
+  const handOn = (sign) => {
+    const side = handCands.filter((i) => Math.sign(latOf(i)) === sign).sort((a, b) => Math.abs(latOf(b)) - Math.abs(latOf(a)));
+    if (side.length)
+      return side[0];
+    const leaves = joints.filter((i) => !legJoints.has(i) && skids(i).length === 0 && Math.sign(latOf(i)) === sign && Math.abs(latOf(i)) > 0.15 * height && pos[i][1] > pos[hips][1]).sort((a, b) => Math.abs(latOf(b)) - Math.abs(latOf(a)));
+    if (leaves.length) {
+      notes.push(`no finger chains on the ${sign > 0 ? "left" : "right"} — hand = furthest lateral joint ${rig.names[leaves[0]]}`);
+      return leaves[0];
+    }
+    return null;
+  };
+  const handL = handOn(1), handR = handOn(-1);
+  if (handL === null || handR === null)
+    throw new Error(`${rig.label}: ${handL === null ? "left" : "right"} hand not found — not a biped`);
+  const upTo = (from, stop) => {
+    const out = [];
+    for (let a = from;a >= 0 && !stop(a); a = sparent(a))
+      out.unshift(a);
+    return out;
+  };
+  const chest = lca([handL, handR]);
+  if (chest === hips || !ancestors(chest).includes(hips))
+    throw new Error(`${rig.label}: arms meet at ${rig.names[chest]}, not above the pelvis — not a biped`);
+  const spine = upTo(chest, (j) => j === hips);
+  const spineSet = new Set(spine);
+  const armOf = (hand, side) => {
+    const path2 = upTo(hand, (j) => spineSet.has(j));
+    const attach = sparent(path2[0]);
+    const links = path2.slice(0, -1);
+    if (links.length < 2)
+      notes.push(`${side} arm has ${links.length} link(s) between ${rig.names[attach]} and the hand — check the map`);
+    const lower = links[links.length - 1], upper = links[links.length - 2] ?? lower;
+    const shoulder = links.length >= 3 ? links[0] : null;
+    const extra = links.length > 3 ? links.slice(1, -2) : [];
+    return { side, attach, shoulder, extra, upper, lower, hand, fingers: {}, metacarpals: [] };
+  };
+  const arms = [armOf(handL, "Left"), armOf(handR, "Right")];
+  const armJoints = new Set(arms.flatMap((a) => [a.shoulder ?? -1, ...a.extra, a.upper, a.lower, a.hand].filter((i) => i >= 0)));
+  const centred = (i) => Math.abs(latOf(i)) < 0.05 * height;
+  const path = [];
+  {
+    let cur = chest;
+    for (let guard = 0;guard < 64; guard++) {
+      const ks = skids(cur).filter((c) => !armJoints.has(c) && !legJoints.has(c) && centred(c) && pos[c][1] > pos[cur][1] - 0.01 * height);
+      if (!ks.length)
+        break;
+      cur = ks.sort((a, b) => maxY(b) - maxY(a))[0];
+      path.push(cur);
+    }
+  }
+  if (!path.length)
+    throw new Error(`${rig.label}: nothing above ${rig.names[chest]} — no neck/head`);
+  let h = path.length - 1;
+  while (h > 0 && skids(path[h]).length < 2)
+    h--;
+  if (skids(path[h]).length < 2)
+    h = path.length - 1;
+  const named = path.findIndex((i) => TOKEN.head.test(rig.names[i]));
+  if (named >= 0 && named !== h) {
+    notes.push(`head: shape picked ${rig.names[path[h]]}, name says ${rig.names[path[named]]} — using the name`);
+    h = named;
+  }
+  const head = path[h];
+  const neck = path.slice(0, h);
+  let eyes = null, jaw = null;
+  {
+    const kids = skids(head);
+    const pair = kids.filter((c) => Math.abs(latOf(c) - latOf(head)) > 0.01 * height);
+    const fwdOf = (c) => dot(sub3(pos[c], pos[head]), forward);
+    let best = -Infinity;
+    for (const a of pair)
+      for (const b of pair) {
+        if (latOf(a) - latOf(head) <= 0 || latOf(b) - latOf(head) >= 0)
+          continue;
+        if (Math.abs(pos[a][1] - pos[b][1]) > 0.03 * height)
+          continue;
+        const score = fwdOf(a) + fwdOf(b) + (TOKEN.eye.test(rig.names[a]) && TOKEN.eye.test(rig.names[b]) ? height : 0);
+        if (score > best) {
+          best = score;
+          eyes = [a, b];
+        }
+      }
+    if (eyes && best < 0.005 * height)
+      eyes = null;
+    const eyeSet = new Set(eyes ?? []);
+    const byName = kids.find((c) => !eyeSet.has(c) && TOKEN.jaw.test(rig.names[c]));
+    const j = byName ?? kids.filter((c) => !eyeSet.has(c) && Math.abs(latOf(c) - latOf(head)) < 0.03 * height && fwdOf(c) > 0.01 * height && pos[c][1] < pos[head][1] + 0.03 * height).sort((a, b) => pos[a][1] - pos[b][1])[0];
+    if (j !== undefined)
+      jaw = j;
+  }
+  const legs = legChains.map((chain) => {
+    const { foot, toes } = footOf(chain);
+    const body = chain.slice(0, chain.indexOf(foot));
+    const side = latOf(chain[0]) > 0 ? "Left" : "Right";
+    if (body.length < 2) {
+      notes.push(`${side} leg has ${body.length} link(s) above the foot — check the map`);
+      return { side, upper: body[0] ?? foot, extra: [], lower: body[body.length - 1] ?? foot, foot, toes, chain };
+    }
+    return { side, upper: body[0], extra: body.slice(1, -1), lower: body[body.length - 1], foot, toes, chain };
+  }).sort((a, b) => (a.side === "Left" ? 0 : 1) - (b.side === "Left" ? 0 : 1));
+  if (legs[0].side === legs[1].side)
+    notes.push("both legs on the same side — facing is wrong");
+  const rootAbove = ancestors(hips).slice(1);
+  const root = rootAbove.length ? rootAbove[rootAbove.length - 1] : null;
+  const fingerChain = (from) => {
+    const chain = [from];
+    for (let guard = 0;guard < 8; guard++) {
+      const cur = chain[chain.length - 1];
+      const ks = skids(cur);
+      if (ks.length) {
+        chain.push(ks.sort((a, b) => extent(b) - extent(a))[0]);
+        continue;
+      }
+      const raw = children[cur].filter((c) => !skinned(c));
+      if (chain.length < 3 && raw.length === 1 && !/end|nub|tip|leaf/i.test(rig.names[raw[0]]))
+        chain.push(raw[0]);
+      break;
+    }
+    return chain;
+  };
+  for (const arm of arms) {
+    let chains = skids(arm.hand).filter((c) => subtree(c).length <= 6 && extent(c) < 0.12 * height).map(fingerChain);
+    if (!chains.length)
+      continue;
+    const FINGER_TOKENS = ["thumb", "index", "middle", "ring", "little"];
+    const nameOf = (c) => FINGER_TOKENS.find((t) => c.some((i) => TOKEN[t].test(rig.names[i])));
+    const named2 = chains.map(nameOf);
+    const namedSet = new Set(named2.filter(Boolean));
+    let useNames = false;
+    if (namedSet.size === 5 && named2.filter(Boolean).length === 5) {
+      chains = chains.filter((_, k) => named2[k]);
+      useNames = true;
+    } else if (chains.length > 5) {
+      chains = [...chains].sort((a, b) => b.length - a.length || extent(b[0]) - extent(a[0])).slice(0, 5);
+    }
+    const meta = [];
+    const phal = chains.map((c) => c.length >= 4 ? (meta.push(c[0]), c.slice(1, 4)) : c.slice(0, 3));
+    arm.metacarpals = meta;
+    const byName = chains.map(nameOf);
+    const assigned = {};
+    if (useNames) {
+      byName.forEach((t, k) => {
+        assigned[t.charAt(0).toUpperCase() + t.slice(1)] = phal[k];
+      });
+    } else {
+      const order = phal.map((c, k) => ({ k, d: len3(sub3(pos[c[0]], pos[arm.hand])) })).sort((a, b) => a.d - b.d);
+      const thumb = order[0].k;
+      const rest = phal.map((_, k) => k).filter((k) => k !== thumb);
+      const mean = rest.reduce((a, k) => [a[0] + pos[phal[k][0]][0], a[1] + pos[phal[k][0]][1], a[2] + pos[phal[k][0]][2]], [0, 0, 0]).map((v) => v / (rest.length || 1));
+      const axis = norm(sub3(pos[phal[thumb][0]], mean));
+      rest.sort((a, b) => dot(sub3(pos[phal[b][0]], mean), axis) - dot(sub3(pos[phal[a][0]], mean), axis));
+      assigned.Thumb = phal[thumb];
+      const names = ["Index", "Middle", "Ring", "Little"];
+      rest.slice(0, 4).forEach((k, n) => {
+        assigned[names[n]] = phal[k];
+      });
+      if (phal.length !== 5)
+        notes.push(`${arm.side} hand has ${phal.length} finger chains — identities by position`);
+      else
+        notes.push(`${arm.side} fingers identified by position (no finger names)`);
+    }
+    arm.fingers = assigned;
+  }
+  const twist = [];
+  const limbLinks = [];
+  for (const l of legs) {
+    const seq = [l.upper, ...l.extra, l.lower, l.foot];
+    for (let k = 0;k + 1 < seq.length; k++)
+      limbLinks.push([seq[k], seq[k + 1]]);
+  }
+  for (const a of arms) {
+    const seq = [...a.shoulder !== null ? [a.shoulder] : [], ...a.extra, a.upper, a.lower, a.hand];
+    for (let k = 0;k + 1 < seq.length; k++)
+      limbLinks.push([seq[k], seq[k + 1]]);
+  }
+  const structural = new Set([hips, ...spine, ...neck, head, ...jaw !== null ? [jaw] : [], ...eyes ?? [], ...legs.flatMap((l) => l.chain), ...armJoints, ...arms.flatMap((a) => [...a.metacarpals, ...Object.values(a.fingers).flat()]), ...root !== null ? [root] : []]);
+  for (const [b, c] of limbLinks) {
+    const dir = sub3(pos[c], pos[b]);
+    for (const t of skids(b)) {
+      if (structural.has(t) || subtree(t).length > 2)
+        continue;
+      const d = sub3(pos[t], pos[b]);
+      const onAxis = len3(d) < 0.000001 || angleDeg(d, dir) < 25;
+      if (onAxis && (TOKEN.twist.test(rig.names[t]) || subtree(t).length === 1)) {
+        twist.push({ bone: t, of: b });
+        structural.add(t);
+      }
+    }
+  }
+  const helpers = joints.filter((i) => !structural.has(i));
+  if (eyes) {
+    const eyeFwd = horiz(sub3([(pos[eyes[0]][0] + pos[eyes[1]][0]) / 2, 0, (pos[eyes[0]][2] + pos[eyes[1]][2]) / 2], pos[head]));
+    if (len3(eyeFwd) > 0.005 * height && angleDeg(eyeFwd, forward) > 90)
+      notes.push("eyes look the other way than the toes point — check facing");
+  }
+  lateral = norm(cross2(up, forward));
+  return { root, hips, forward, lateral, up, height, ground, spine, chest, neck, head, jaw, eyes, legs, arms, twist, helpers, notes };
+}, isBiped = (rig) => {
+  try {
+    classifyBiped(rig);
+    return true;
+  } catch {
+    return false;
+  }
+}, avatarFromBiped = (rig, b) => {
+  const n = (i) => rig.names[i];
+  const bones = {};
+  const bridged = [];
+  bones.Hips = n(b.hips);
+  const s = b.spine;
+  if (s.length === 1)
+    bones.Spine = n(s[0]);
+  else if (s.length === 2) {
+    bones.Spine = n(s[0]);
+    bones.Chest = n(s[1]);
+  } else if (s.length === 3) {
+    bones.Spine = n(s[0]);
+    bones.Chest = n(s[1]);
+    bones.UpperChest = n(s[2]);
+  } else if (s.length > 3) {
+    const pos = rig.bind.worldPos;
+    let acc = 0;
+    const arc2 = s.map((i, k) => acc += len3(sub3(pos[i], pos[k ? s[k - 1] : b.hips])));
+    const mid = arc2.slice(1, -1).map((v, k) => ({ k: k + 1, d: Math.abs(v - acc / 2) })).sort((a, c) => a.d - c.d)[0].k;
+    bones.Spine = n(s[0]);
+    bones.Chest = n(s[mid]);
+    bones.UpperChest = n(s[s.length - 1]);
+    s.forEach((i, k) => {
+      if (k !== 0 && k !== mid && k !== s.length - 1)
+        bridged.push(n(i));
+    });
+  }
+  if (b.neck.length) {
+    bones.Neck = n(b.neck[0]);
+    bridged.push(...b.neck.slice(1).map(n));
+  }
+  bones.Head = n(b.head);
+  if (b.jaw !== null)
+    bones.Jaw = n(b.jaw);
+  if (b.eyes) {
+    bones.LeftEye = n(b.eyes[0]);
+    bones.RightEye = n(b.eyes[1]);
+  }
+  for (const l of b.legs) {
+    bones[`${l.side}UpperLeg`] = n(l.upper);
+    bones[`${l.side}LowerLeg`] = n(l.lower);
+    bones[`${l.side}Foot`] = n(l.foot);
+    if (l.toes !== null)
+      bones[`${l.side}Toes`] = n(l.toes);
+    bridged.push(...l.extra.map(n));
+  }
+  for (const a of b.arms) {
+    if (a.shoulder !== null)
+      bones[`${a.side}Shoulder`] = n(a.shoulder);
+    bones[`${a.side}UpperArm`] = n(a.upper);
+    bones[`${a.side}LowerArm`] = n(a.lower);
+    bones[`${a.side}Hand`] = n(a.hand);
+    bridged.push(...a.extra.map(n), ...a.metacarpals.map(n));
+    for (const f of FINGERS) {
+      const chain = a.fingers[f];
+      if (!chain)
+        continue;
+      chain.forEach((i, k) => {
+        if (k < 3)
+          bones[`${a.side} ${f} ${PHALANGES[k]}`] = n(i);
+      });
+    }
+  }
+  const byIndex = new Map;
+  for (const [k, v] of Object.entries(bones))
+    byIndex.set(rig.index.get(v), k);
+  const twist = {};
+  for (const t of b.twist) {
+    const of = byIndex.get(t.of);
+    if (of)
+      twist[n(t.bone)] = of;
+  }
+  return { root: b.root !== null ? n(b.root) : n(b.hips), bones, twist, bridged, notes: [...b.notes] };
+}, avatarFromRig = (rig) => avatarFromBiped(rig, classifyBiped(rig)), avatarFromUnity = (rig, unity) => {
+  const notes = [];
+  const bones = {};
+  for (const [k, v] of Object.entries(unity.bones)) {
+    if (rig.index.has(v))
+      bones[k] = v;
+    else
+      notes.push(`.meta maps ${k} to '${v}', which the rig does not have — dropped`);
+  }
+  if (unity.unknown.length)
+    notes.push(`.meta human names not in the canon: ${unity.unknown.join(", ")}`);
+  if (!bones.Hips)
+    throw new Error(`${rig.label}: the .meta avatar has no Hips`);
+  let shape = null;
+  try {
+    shape = classifyBiped(rig);
+  } catch (e) {
+    notes.push(`shape classification failed (${e.message}) — no twist helpers, root = skinned ancestor of Hips`);
+  }
+  const hips = rig.index.get(bones.Hips);
+  let root = bones.Hips;
+  if (unity.rootMotionBone && rig.index.has(unity.rootMotionBone))
+    root = unity.rootMotionBone;
+  else {
+    let top = -1;
+    for (let a = rig.parents[hips];a >= 0; a = rig.parents[a])
+      if (rig.bind.fromSkin[a])
+        top = a;
+    if (top >= 0)
+      root = rig.names[top];
+  }
+  const twist = {};
+  if (shape) {
+    const byIndex = new Map;
+    for (const [k, v] of Object.entries(bones))
+      byIndex.set(rig.index.get(v), k);
+    for (const t of shape.twist) {
+      const of = byIndex.get(t.of);
+      if (of)
+        twist[rig.names[t.bone]] = of;
+    }
+  }
+  return { root, bones, twist, bridged: [], notes };
+}, avatarFromFile = (rig, file) => {
+  const bones = {};
+  const notes = [];
+  for (const [k, v] of Object.entries(file.bones)) {
+    if (!isHumanBone(k)) {
+      notes.push(`'${k}' is not a canonical humanoid bone — ignored`);
+      continue;
+    }
+    if (!rig.index.has(v)) {
+      notes.push(`${k} → '${v}': the rig has no such bone — dropped`);
+      continue;
+    }
+    bones[k] = v;
+  }
+  if (!bones.Hips)
+    throw new Error(`${rig.label}: avatar has no Hips`);
+  const twist = {};
+  for (const [t, of] of Object.entries(file.twist ?? {}))
+    if (isHumanBone(of) && rig.index.has(t))
+      twist[t] = of;
+  let transfer;
+  if (file.transfer && typeof file.transfer === "object") {
+    transfer = { ...file.transfer };
+    if (transfer.align) {
+      const align = {};
+      for (const [k, v] of Object.entries(transfer.align)) {
+        if (!isHumanBone(k)) {
+          notes.push(`transfer.align: '${k}' is not a canonical bone — ignored`);
+          continue;
+        }
+        if (v === "keep" || v === "align")
+          align[k] = v;
+      }
+      transfer.align = align;
+    }
+  }
+  return { root: file.root && rig.index.has(file.root) ? file.root : bones.Hips, bones, twist, bridged: [], notes, ...transfer ? { transfer } : {} };
+}, avatarToFile = (a) => ({ root: a.root, bones: { ...a.bones }, twist: Object.keys(a.twist).length ? { ...a.twist } : undefined, ...a.transfer && Object.keys(a.transfer).length ? { transfer: { ...a.transfer } } : {} }), mapAvatars = (target, donor) => {
+  const map = {};
+  const shared = [], targetOnly = [], donorOnly = [];
+  for (const k of HUMAN_BONES) {
+    const t = target.bones[k], d = donor.bones[k];
+    if (t && d) {
+      map[t] = d;
+      shared.push(k);
+    } else if (t)
+      targetOnly.push(k);
+    else if (d)
+      donorOnly.push(k);
+  }
+  map[target.root] = donor.root;
+  if (target.root !== target.bones.Hips && donor.root === donor.bones.Hips)
+    map[target.bones.Hips] = donor.bones.Hips;
+  const legs = SIDES.map((s) => target.bones[`${s}Foot`]).filter((x) => !!x);
+  return { map, root: target.root, legs, shared, targetOnly, donorOnly };
+}, describeBiped = (rig, b) => {
+  const n = (i) => i === null ? "-" : rig.names[i];
+  const fingers = b.arms.map((a) => Object.keys(a.fingers).length).join("/");
+  return `hips ${n(b.hips)}${b.root !== null ? ` (root ${n(b.root)})` : ""} · spine ${b.spine.length} · neck ${b.neck.length} · head ${n(b.head)} · jaw ${n(b.jaw)} · eyes ${b.eyes ? `${n(b.eyes[0])}/${n(b.eyes[1])}` : "-"} · arms ${b.arms.map((a) => `${a.side[0]}:${(a.shoulder !== null ? 1 : 0) + 2 + a.extra.length}`).join(" ")} · fingers ${fingers} · legs ${b.legs.map((l) => `${l.side[0]}:${2 + l.extra.length}${l.toes !== null ? "+toes" : ""}`).join(" ")} · twist ${b.twist.length} · helpers ${b.helpers.length} · facing [${b.forward.map((x) => x.toFixed(2)).join(",")}]`;
+}, describeHumanoidMap = (target, donor, hm) => {
+  const lines = [];
+  const pair = (k) => `${target.bones[k]}←${donor.bones[k]}`;
+  const group = (label, keys) => {
+    const have = keys.filter((k) => hm.shared.includes(k));
+    if (have.length)
+      lines.push(`  ${label}: ${have.map(pair).join(", ")}`);
+  };
+  lines.push(`  root: ${target.root}←${donor.root}`);
+  group("torso", ["Hips", "Spine", "Chest", "UpperChest", "Neck", "Head", "Jaw", "LeftEye", "RightEye"]);
+  for (const s of SIDES)
+    group(`${s.toLowerCase()} arm`, [`${s}Shoulder`, `${s}UpperArm`, `${s}LowerArm`, `${s}Hand`]);
+  for (const s of SIDES)
+    group(`${s.toLowerCase()} leg`, [`${s}UpperLeg`, `${s}LowerLeg`, `${s}Foot`, `${s}Toes`]);
+  for (const s of SIDES) {
+    const fs = FINGERS.filter((f) => hm.shared.includes(`${s} ${f} Proximal`));
+    if (fs.length)
+      lines.push(`  ${s.toLowerCase()} fingers: ${fs.map((f) => `${f.toLowerCase()} ×${PHALANGES.filter((p) => hm.shared.includes(`${s} ${f} ${p}`)).length}`).join(", ")}`);
+  }
+  if (hm.targetOnly.length)
+    lines.push(`  target only (kept at bind): ${hm.targetOnly.join(", ")}`);
+  if (hm.donorOnly.length)
+    lines.push(`  donor only (dropped): ${hm.donorOnly.join(", ")}`);
+  const tw = Object.entries(target.twist);
+  if (tw.length)
+    lines.push(`  target twist helpers: ${tw.map(([b, of]) => `${b}→${of}`).join(", ")}`);
+  if (target.bridged.length)
+    lines.push(`  target bridged: ${target.bridged.join(", ")}`);
+  for (const n of target.notes)
+    lines.push(`  ⚠ target: ${n}`);
+  for (const n of donor.notes)
+    lines.push(`  ⚠ donor: ${n}`);
+  return lines;
+};
+var init_humanoid = __esm(() => {
+  SIDES = ["Left", "Right"];
+  FINGERS = ["Thumb", "Index", "Middle", "Ring", "Little"];
+  PHALANGES = ["Proximal", "Intermediate", "Distal"];
+  BODY = ["Hips", "Spine", "Chest", "UpperChest", "Neck", "Head", "Jaw", "LeftEye", "RightEye"];
+  LIMB = ["Shoulder", "UpperArm", "LowerArm", "Hand", "UpperLeg", "LowerLeg", "Foot", "Toes"];
+  HUMAN_BONES = [
+    ...BODY,
+    ...SIDES.flatMap((s) => LIMB.map((l) => `${s}${l}`)),
+    ...SIDES.flatMap((s) => FINGERS.flatMap((f) => PHALANGES.map((p) => `${s} ${f} ${p}`)))
+  ];
+  HUMAN_SET = new Set(HUMAN_BONES);
+  TOKEN = {
+    head: /head/i,
+    neck: /neck/i,
+    jaw: /jaw/i,
+    eye: /eye(?!.*(brow|lash|lid))/i,
+    thumb: /thumb/i,
+    index: /index/i,
+    middle: /middle/i,
+    ring: /ring(?!.*(ear|fore))/i,
+    little: /pinky|little/i,
+    twist: /twist|roll/i
+  };
+});
+
 // src/retarget/automap.ts
 var exports_automap = {};
 __export(exports_automap, {
@@ -5913,7 +7441,7 @@ __export(exports_automap, {
   classify: () => classify,
   autoMap: () => autoMap
 });
-var sub2 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]], dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2], len2 = (v) => Math.hypot(v[0], v[1], v[2]), classify = (rig) => {
+var sub4 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]], dot2 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2], len4 = (v) => Math.hypot(v[0], v[1], v[2]), classify = (rig) => {
   const notes = [];
   const skinned = (i) => rig.bind.fromSkin[i];
   const pos = rig.bind.worldPos;
@@ -5963,12 +7491,12 @@ var sub2 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]], dot = (a, b) => a[
   const theta = 0.5 * Math.atan2(2 * sxz, sxx - szz);
   let forward = [Math.cos(theta), 0, Math.sin(theta)];
   const top = [...joints].sort((a, b) => pos[b][1] - pos[a][1]).slice(0, Math.max(1, Math.ceil(joints.length * 0.1)));
-  const topProj = top.reduce((a, i) => a + dot(sub2(pos[i], [cx, 0, cz]), forward), 0) / top.length;
+  const topProj = top.reduce((a, i) => a + dot2(sub4(pos[i], [cx, 0, cz]), forward), 0) / top.length;
   if (topProj < 0)
     forward = [-forward[0], 0, -forward[2]];
   const lateral = [forward[2], 0, -forward[0]];
-  const fwd = (i) => dot(sub2(pos[i], pos[root]), forward);
-  const lat = (i) => dot(sub2(pos[i], pos[root]), lateral);
+  const fwd = (i) => dot2(sub4(pos[i], pos[root]), forward);
+  const lat = (i) => dot2(sub4(pos[i], pos[root]), lateral);
   const centre = (i) => Math.abs(lat(i)) < 0.03 * size;
   const legs = [];
   {
@@ -6113,7 +7641,7 @@ var sub2 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]], dot = (a, b) => a[
     const out = [];
     let acc = 0, prev = anchor;
     for (const c of chain) {
-      acc += len2(sub2(rig.bind.worldPos[c], rig.bind.worldPos[prev]));
+      acc += len4(sub4(rig.bind.worldPos[c], rig.bind.worldPos[prev]));
       out.push(acc);
       prev = c;
     }
@@ -6559,16 +8087,16 @@ var matMul2 = (a, b) => {
     lowfront: { r: [1, 0, 0], u: [0, 0.87, -0.5], d: [0, 0.5, -0.87] }
   };
   const B = bases[VIEW] ?? bases.side;
-  const dot2 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
   const corners = [];
   for (let i = 0;i < 8; i++)
     corners.push([i & 1 ? hi[0] : lo[0], i & 2 ? hi[1] : lo[1], i & 4 ? hi[2] : lo[2]]);
-  const ru = corners.map((c) => [dot2(B.r, c), dot2(B.u, c)]);
+  const ru = corners.map((c) => [dot3(B.r, c), dot3(B.u, c)]);
   const rlo = [Math.min(...ru.map((p) => p[0])), Math.min(...ru.map((p) => p[1]))];
   const rhi = [Math.max(...ru.map((p) => p[0])), Math.max(...ru.map((p) => p[1]))];
   const k = (CELL - 2 * PAD) / Math.max(rhi[0] - rlo[0], rhi[1] - rlo[1], 0.000000001);
-  const sx = (ox, q) => ox + PAD + (dot2(B.r, q) - rlo[0]) * k + (CELL - 2 * PAD - (rhi[0] - rlo[0]) * k) / 2;
-  const sy = (q) => HEAD + CELL - PAD - (dot2(B.u, q) - rlo[1]) * k;
+  const sx = (ox, q) => ox + PAD + (dot3(B.r, q) - rlo[0]) * k + (CELL - 2 * PAD - (rhi[0] - rlo[0]) * k) / 2;
+  const sy = (q) => HEAD + CELL - PAD - (dot3(B.u, q) - rlo[1]) * k;
   const W = CELL * NF, H = CELL + HEAD;
   const img = new Uint8Array(W * H * 4);
   for (let i = 0;i < W * H; i++) {
@@ -6594,7 +8122,7 @@ var matMul2 = (a, b) => {
         const nl = Math.hypot(nx, ny, nz) || 1;
         const shade = 0.22 + 0.78 * Math.abs(nx / nl * light[0] + ny / nl * light[1] + nz / nl * light[2]);
         const col = [Math.round(base[0] * shade), Math.round(base[1] * shade), Math.round(base[2] * shade)];
-        const sp = p.map((q) => [sx(ox, q), sy(q), -dot2(B.d, q)]);
+        const sp = p.map((q) => [sx(ox, q), sy(q), -dot3(B.d, q)]);
         const minX = Math.max(ox, Math.floor(Math.min(sp[0][0], sp[1][0], sp[2][0]))), maxX = Math.min(ox + CELL - 1, Math.ceil(Math.max(sp[0][0], sp[1][0], sp[2][0])));
         const minY = Math.max(HEAD, Math.floor(Math.min(sp[0][1], sp[1][1], sp[2][1]))), maxY = Math.min(H - 1, Math.ceil(Math.max(sp[0][1], sp[1][1], sp[2][1])));
         const d = (sp[1][0] - sp[0][0]) * (sp[2][1] - sp[0][1]) - (sp[2][0] - sp[0][0]) * (sp[1][1] - sp[0][1]);
@@ -6665,8 +8193,146 @@ var init_filmstrip = __esm(() => {
   };
 });
 
+// src/terrainPack.ts
+var exports_terrainPack = {};
+__export(exports_terrainPack, {
+  resolveTerrainLayer: () => resolveTerrainLayer,
+  packTerrainTextures: () => packTerrainTextures
+});
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readdirSync as readdirSync5, readFileSync as readFileSync11, statSync as statSync6, unlinkSync } from "node:fs";
+import { basename as basename6, extname as extname4, join as join9, resolve as resolve5 } from "node:path";
+import { spawnSync as spawnSync4 } from "node:child_process";
+var IMAGE_EXT, resolveTerrainLayer = (input, normal, name) => {
+  const p = resolve5(input);
+  if (!existsSync10(p))
+    throw new Error(`not found: ${input}`);
+  if (statSync6(p).isDirectory()) {
+    const files = readdirSync5(p).filter((f) => IMAGE_EXT.test(f));
+    const albedo = files.find((f) => /albedo/i.test(f) && !/smooth/i.test(f)) ?? files.find((f) => /albedo|basecolor|base_color|diffuse|_d\./i.test(f));
+    if (!albedo)
+      throw new Error(`${input}: no albedo image (a file named *Albedo* / *BaseColor* / *Diffuse*)`);
+    const nrm2 = normal ?? files.find((f) => /normal|_n\./i.test(f) && !/normalmap_?dx/i.test(f));
+    return { name: name ?? cleanName(basename6(p)), albedo: join9(p, albedo), normal: nrm2 ? normal ? resolve5(normal) : join9(p, nrm2) : undefined };
+  }
+  if (!IMAGE_EXT.test(p))
+    throw new Error(`${input}: not an image (png/jpg/webp/tiff/tga/bmp)`);
+  let nrm = normal ? resolve5(normal) : undefined;
+  if (!nrm) {
+    const stem = p.slice(0, -extname4(p).length);
+    for (const cand of [stem.replace(/albedo/i, "Normal"), stem.replace(/albedo/i, "normal"), `${stem}_Normal`, `${stem}_normal`, stem.replace(/_?(basecolor|diffuse|_d)$/i, "_Normal")]) {
+      if (cand === stem)
+        continue;
+      const hit = [".png", ".jpg", ".jpeg", ".tga", ".webp", ".tif", ".tiff", ".bmp"].map((e) => cand + e).find((f) => existsSync10(f));
+      if (hit) {
+        nrm = hit;
+        break;
+      }
+    }
+  }
+  return { name: name ?? cleanName(basename6(p, extname4(p)).replace(/[_-]?(albedo|basecolor|base_color|diffuse)$/i, "")), albedo: p, normal: nrm };
+}, cleanName = (s) => s.trim().replace(/\s+/g, "_").replace(/[^A-Za-z0-9_-]/g, "").toLowerCase() || "layer", loadRgba = async (path, size) => {
+  const sharp3 = (await import("sharp")).default;
+  let bytes2 = new Uint8Array(readFileSync11(path));
+  const mime = sniffMime(bytes2, path);
+  if (mime === "image/x-tga" || mime === "image/bmp") {
+    const rgba = mime === "image/x-tga" ? decodeTga(bytes2) : decodeBmp(bytes2);
+    if (!rgba)
+      throw new Error(`${path}: could not decode the ${mime === "image/bmp" ? "BMP" : "TGA"}`);
+    bytes2 = encodePng(rgba);
+  }
+  const img = sharp3(Buffer.from(bytes2));
+  const meta = await img.metadata();
+  const { data, info } = await img.resize(size, size, { fit: "fill", kernel: "lanczos3" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  return { data, width: info.width, height: info.height, sourceSize: [meta.width ?? 0, meta.height ?? 0] };
+}, encodeKtx2 = (toktx, png, ktx2, srgb, quality) => {
+  const args = ["--t2", "--encode", "uastc", "--uastc_quality", String(quality), "--zcmp", "18", "--genmipmap", "--assign_oetf", srgb ? "srgb" : "linear", ktx2, png];
+  const p = spawnSync4(toktx, args, { encoding: "utf8" });
+  if (p.status !== 0)
+    throw new Error(`toktx failed (${p.status ?? p.error?.message ?? "?"}) on ${basename6(png)}:
+${(p.stderr || p.stdout || "").trim()}`);
+}, packTerrainTextures = async (layers, opts) => {
+  if (layers.length === 0)
+    throw new Error("no layers");
+  if (layers.length > 4)
+    throw new Error(`${layers.length} layers — a terrain material takes at most four`);
+  const size = opts.size ?? 1024;
+  if (!(size >= 16 && size <= 8192) || (size & size - 1) !== 0)
+    throw new Error(`--size wants a power of two in 16..8192, got ${size}`);
+  const log = opts.log ?? (() => {});
+  const sharp3 = (await import("sharp")).default;
+  const toktx = opts.png ? null : findToktx();
+  if (toktx && !checkToktx(toktx)) {
+    throw new Error("KTX-Software's toktx is needed for KTX2 output — install it (https://github.com/KhronosGroup/KTX-Software/releases, on PATH or KTX_TOKTX=<path>) or pass --png");
+  }
+  const seen = new Set;
+  for (const l of layers) {
+    if (seen.has(l.name))
+      throw new Error(`two layers named "${l.name}" — pass --names`);
+    seen.add(l.name);
+  }
+  mkdirSync4(opts.outDir, { recursive: true });
+  const ext = opts.png ? ".png" : ".ktx2";
+  const writeImage = async (raw, channels, out, srgb) => {
+    let pipe = sharp3(raw.data, { raw: { width: raw.width, height: raw.height, channels: 4 } });
+    if (channels === 3)
+      pipe = pipe.removeAlpha();
+    const png = opts.png ? out : out.slice(0, -ext.length) + ".png";
+    await pipe.png({ compressionLevel: opts.png ? 9 : 1 }).toFile(png);
+    if (toktx) {
+      encodeKtx2(toktx, png, out, srgb, opts.quality ?? 1);
+      unlinkSync(png);
+    }
+  };
+  const result = { layers: [], normals: [], snippet: "" };
+  const normalRaws = [];
+  for (const l of layers) {
+    const alb = await loadRgba(l.albedo, size);
+    const file = join9(opts.outDir, l.name + ext);
+    await writeImage(alb, 3, file, true);
+    let nrm = null;
+    if (l.normal) {
+      if (!existsSync10(l.normal))
+        throw new Error(`${l.name}: normal map not found: ${l.normal}`);
+      nrm = await loadRgba(l.normal, size);
+    }
+    normalRaws.push(nrm);
+    result.layers.push({ name: l.name, file, albedo: l.albedo, normal: l.normal ?? null, sourceSize: alb.sourceSize });
+    log(`   ${l.name.padEnd(16)} ${alb.sourceSize[0]}×${alb.sourceSize[1]} → ${size}²  ${nrm ? `+ normal ${nrm.sourceSize[0]}×${nrm.sourceSize[1]}` : "(flat normal)"}`);
+  }
+  const packCount = layers.length > 2 ? 2 : 1;
+  for (let k = 0;k < packCount; k++) {
+    const a = normalRaws[k * 2] ?? null, b = normalRaws[k * 2 + 1] ?? null;
+    const n = size * size;
+    const out = Buffer.alloc(n * 4);
+    for (let i = 0;i < n; i++) {
+      const o = i * 4;
+      out[o] = a ? a.data[o] : 128;
+      out[o + 1] = a ? opts.flipY ? 255 - a.data[o + 1] : a.data[o + 1] : 128;
+      out[o + 2] = b ? b.data[o] : 128;
+      out[o + 3] = b ? opts.flipY ? 255 - b.data[o + 1] : b.data[o + 1] : 128;
+    }
+    const file = join9(opts.outDir, `normals${k * 2}${k * 2 + 1}${ext}`);
+    await writeImage({ data: out, width: size, height: size }, 4, file, false);
+    result.normals.push(file);
+    log(`   normals${k * 2}${k * 2 + 1}${"".padEnd(7)} ${a ? layers[k * 2].name : "flat"} + ${b ? layers[k * 2 + 1].name : layers[k * 2 + 1] ? "flat" : "—"}`);
+  }
+  const rel = (f) => "./" + basename6(f);
+  result.snippet = [
+    "layers: [",
+    ...result.layers.map((l, i) => `  { albedo: asset('${rel(l.file)}'), tiling: 4${normalRaws[i] ? ", normalScale: 1" : ""} },`),
+    `], normals: [ ${result.normals.map((f) => `asset('${rel(f)}')`).join(", ")} ]`
+  ].join(`
+`);
+  return result;
+};
+var init_terrainPack = __esm(() => {
+  init_resolveImage();
+  init_transcodeKtx2();
+  IMAGE_EXT = /\.(png|jpe?g|webp|tiff?|tga|bmp)$/i;
+});
+
 // src/cli.ts
-import { existsSync as existsSync10, statSync as statSync6, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync11, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync11, statSync as statSync7, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, readFileSync as readFileSync12, readdirSync as readdirSync6 } from "node:fs";
 
 // src/sky/index.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
@@ -6951,7 +8617,7 @@ var formatSkyReport = (r, name = "SKY") => {
 };
 
 // src/cli.ts
-import { basename as basename6, dirname as dirname7, extname as extname4, join as join9 } from "node:path";
+import { basename as basename7, dirname as dirname7, extname as extname5, join as join10, resolve as resolve6 } from "node:path";
 var USAGE = `lecodes-assets — FBX → GLB converter + GLB doctor (docs/animation-plan.md §2.9)
 
   convert <model.fbx|.glb> [options]        FBX (or an existing GLB) → LeCodes-ready GLB
@@ -6991,16 +8657,35 @@ var USAGE = `lecodes-assets — FBX → GLB converter + GLB doctor (docs/animati
                                               "align": { bone: "keep" | "direction" | [ refBones ] },
                                               "legs": [ footBones ] }   (align/legs optional)
       --skeletons                           print both bone lists and exit (to write that map)
-      --auto-map [out.json] | --map auto    derive the map from the two skeletons' SHAPE (quadrupeds:
-                                            spine/neck/head/tail/legs/ears/jaw) — write it, or use it directly
+      --auto-map [out.json] | --map auto    derive the map from the two skeletons' SHAPE — write it, or use it
+                                            directly. Quadrupeds: spine/neck/head/tail/legs/ears/jaw chains.
+                                            Humanoids: both rigs' AVATARS (see \`avatar\`) joined on the canon
+      --avatar <a.avatar.json|model.meta>   the target's avatar instead of deriving it (a Unity .meta works)
+      --donor-avatar <…>                    the donor's
+      --donor-rig <model.fbx|.glb>          the rig a skeleton-only clip file (mocap packs: nodes + curves,
+                                            no mesh) was animated on — its clips bind to it by bone name
       --clips a b …                         only these donor clips        --keep-clips  keep the target's own
       --align none|bone-direction           posture alignment (default bone-direction)
-      --ik none|legs                        foot placement against the ground (default legs)
+      --ik none|legs|hands                  foot placement against the ground (default legs); hands = the
+                                            hands as effectors too (clips where they meet or hold)
+      --root-motion auto|hips|root|none     where the travel lands: a root above the hips takes the horizontal
+                                            travel, the hips the bob (auto/root); all on the hips; none = in place
+      --no-plant                            no foot planting (a standing foot is otherwise held where it landed)
+      --twist N|off                         twist helpers' share of their limb's axial turn (default 0.5)
       --donor-ref bind|auto|<clip>          pose the donor's motion is measured from (auto = mean of its idle/walk)
       --fps N  --root-scale N  --prefix s   sampling rate / root-motion scale / clip name prefix
       --clip-names n1 n2 …                  rename the produced clips, positionally
       --anim a.anim b.anim …                Unity AnimationClip assets to use as the donor's clips
                                             (for packs shipping an empty FBX rig + .anim files)
+  avatar <model.fbx|.glb> [--meta model.fbx.meta] [-o model.avatar.json]
+                                            a humanoid rig's AVATAR: its bones named in the Unity/VRM canon
+                                            (Hips, Spine…, LeftUpperArm…, Left Thumb Proximal…), read off the
+                                            skeleton's shape — hips = the joint two ground-reaching chains hang
+                                            from, hands = the lateral joints fanning into fingers, head = the
+                                            last branch above the arms; twist/roll helpers recorded, not mapped.
+                                            --meta checks the result against Unity's own humanoid map (and
+                                            imports it verbatim when you trust it more: -o with --meta writes
+                                            Unity's). The file is what \`retarget --avatar\` reads
   sky <env.exr|.hdr>                        equirectangular HDR → the TWO cubemaps a scene needs
       -o dir                                where they land (default: beside the input)
       --size N                              edge of the DRAWN sky cubemap (default 512)
@@ -7016,6 +8701,19 @@ var USAGE = `lecodes-assets — FBX → GLB converter + GLB doctor (docs/animati
                                             can be aimed to match instead of by eye.
                                             Needs filament's cmgen (LECODES_CMGEN / ~/.lecodes/cmgen).
 
+  terrain-pack <layer> [<layer> …]          a terrain's splat layers (≤ 4) → <name>.ktx2 per layer + the PACKED
+                                            normal maps normals01.ktx2 / normals23.ktx2 (layer XY pairs in
+                                            RG/BA — terrain.mat has nine samplers, so normals ship two per
+                                            texture). A layer = an albedo file (its normal guessed from the
+                                            name, or --normals) or a FOLDER holding *Albedo* + *Normal*
+                                            (Unity terrain packs). Prints the Terrain.create fragment
+      -o dir                                where they land (default: ./terrain)
+      --normals n0 n1 …                     normal map per layer, positionally ("-" = none)
+      --names a b …                         layer names → file names (default: from the inputs)
+      --size N                              output edge (1024)          --quality N   UASTC quality 0–4 (1)
+      --png                                 PNGs instead of KTX2 (no toktx needed)
+      --flip-y                              DirectX-style normal maps (green inverted)
+
   probe <file.fbx|.glb>                     skeleton, clips (+ per-clip root motion / first-frame-vs-rest),
                                             meshes, materials, textures, bind sanity, world size, duplicate names
       --filmstrip [out.png]                 (GLB) CPU-skinned PNG strip of every clip — the fastest "does it play
@@ -7034,8 +8732,12 @@ var USAGE = `lecodes-assets — FBX → GLB converter + GLB doctor (docs/animati
          [--unlit]                          flat base colour, no lighting (KHR_materials_unlit) — for stylised assets
          [--lightmap-uv]                    add a lightmap UV set (TEXCOORD_1, xatlas) — what \`lecodes lightmap bake\`
                                             samples; skinned meshes are skipped. --lightmap-padding N (4),
-                                            --lightmap-iterations N (1, more = better charts, slower)`;
-var MULTI = new Set(["--clips", "--clip-names", "--rename", "--anim", "--only", "--keep", "--merge-skins"]);
+                                            --lightmap-iterations N (1, more = better charts, slower)
+         [--lod 0.5,0.2] [--lod-bones]     add mesh LOD levels (<name>_LOD1... siblings at these triangle
+                                            ratios, same skin; >= 2000-tri meshes only) - creator-gl shows one
+                                            by screen size (docs/lod-plan.md); --lod-bones folds fingers /
+                                            toes / twists onto their parents in the last level's skin`;
+var MULTI = new Set(["--clips", "--clip-names", "--rename", "--anim", "--only", "--keep", "--merge-skins", "--normals", "--names"]);
 var SINGLE = new Set([
   "-o",
   "--max-size",
@@ -7054,6 +8756,12 @@ var SINGLE = new Set([
   "--prefix",
   "--unity-mats",
   "--unity-index",
+  "--avatar",
+  "--donor-avatar",
+  "--meta",
+  "--root-motion",
+  "--twist",
+  "--donor-rig",
   "--split",
   "--list-nodes",
   "--filmstrip",
@@ -7071,7 +8779,9 @@ var SINGLE = new Set([
   "--name",
   "--ibl-name",
   "--lightmap-padding",
-  "--lightmap-iterations"
+  "--lightmap-iterations",
+  "--quality",
+  "--lod"
 ]);
 var isValue = (s) => !s.startsWith("-") || /^-(\d|\.\d)/.test(s);
 var parse = (argv) => {
@@ -7104,7 +8814,7 @@ var cmdConvert = async (p) => {
     log(USAGE);
     return 2;
   }
-  if (!existsSync10(input)) {
+  if (!existsSync11(input)) {
     console.error(`✗ not found: ${input}`);
     return 1;
   }
@@ -7123,7 +8833,7 @@ var cmdConvert = async (p) => {
   log(`\uD83D\uDD04 ${input}${clips.length ? ` + ${clips.length} clip file(s)` : ""}`);
   let doc;
   let report = { clips: [] };
-  if (extname4(input).toLowerCase() === ".fbx") {
+  if (extname5(input).toLowerCase() === ".fbx") {
     const r = await convertFbx2(input, {
       clips,
       clipNames,
@@ -7145,8 +8855,8 @@ var cmdConvert = async (p) => {
   } else {
     doc = await makeIO3().read(input);
     for (let i = 0;i < clips.length; i++) {
-      const cs = await readFbx2(new Uint8Array(readFileSync11(clips[i])));
-      report.clips.push(...mergeClipScene2(doc, cs, basename6(clips[i]), clipNames?.[i], rename, warn));
+      const cs = await readFbx2(new Uint8Array(readFileSync12(clips[i])));
+      report.clips.push(...mergeClipScene2(doc, cs, basename7(clips[i]), clipNames?.[i], rename, warn));
     }
   }
   for (const c of report.clips)
@@ -7157,12 +8867,12 @@ var cmdConvert = async (p) => {
     const { convertFbx: convertFbx3 } = await Promise.resolve().then(() => (init_convert(), exports_convert));
     const donors = [];
     for (const f of mergeFiles) {
-      if (!existsSync10(f)) {
+      if (!existsSync11(f)) {
         console.error(`✗ not found: ${f}`);
         return 1;
       }
-      const d = extname4(f).toLowerCase() === ".fbx" ? (await convertFbx3(f, { dropModelClips: true, warn, unity: p.flags.has("--no-unity") ? false : p.values.get("--unity-mats")?.[0] ?? true, unityIndex: p.values.get("--unity-index")?.[0] })).doc : await makeIO3().read(f);
-      donors.push({ doc: d, label: basename6(f) });
+      const d = extname5(f).toLowerCase() === ".fbx" ? (await convertFbx3(f, { dropModelClips: true, warn, unity: p.flags.has("--no-unity") ? false : p.values.get("--unity-mats")?.[0] ?? true, unityIndex: p.values.get("--unity-index")?.[0] })).doc : await makeIO3().read(f);
+      donors.push({ doc: d, label: basename7(f) });
     }
     const mr = await mergeSkins2(doc, donors, warn);
     for (const d of mr.donors)
@@ -7207,32 +8917,42 @@ var cmdConvert = async (p) => {
       log(`   baked scale ×${+res.scaled.toPrecision(6)}`);
     if (res.lightmapUv)
       log(`   lightmap UV: ${res.lightmapUv.charts} charts over ${res.lightmapUv.primitives} primitive(s) (xatlas ${res.lightmapUv.width}×${res.lightmapUv.height}); vertices ${res.lightmapUv.verticesBefore} → ${res.lightmapUv.verticesAfter}`);
-  }
-  const out = p.values.get("-o")?.[0] ?? join9(dirname7(input), basename6(input, extname4(input)) + ".glb");
+    if (res.lod) {
+      for (const t of res.lod.tris)
+        log(`   lod: ${t.name} ${t.levels.join(" / ")} tris`);
+      for (const b of res.lod.bones)
+        log(`   lod bones: ${b.name} last level ${b.before} → ${b.after} joints`);
+      for (const k of res.lod.skipped)
+        log(`   lod: ${k.name} level ${k.level} dropped — the simplifier reached only ${k.tris} tris (seams / hard surfaces; try a smaller ratio)`);
+      if (!res.lod.nodes)
+        log(`   lod: no mesh with >= 2000 triangles (or the _LOD nodes are already there)`);
+    }
+  }
+  const out = p.values.get("-o")?.[0] ?? join10(dirname7(input), basename7(input, extname5(input)) + ".glb");
   const { validateGlb: validateGlb2, formatReport: formatReport2 } = await Promise.resolve().then(() => (init_validateGlb(), exports_validateGlb));
   const { probeDocument: probeDocument2 } = await Promise.resolve().then(() => (init_probe(), exports_probe));
   if (p.values.has("--split")) {
     const { splitDoc: splitDoc2, fileStem: fileStem2 } = await Promise.resolve().then(() => (init_props(), exports_props));
-    const dir2 = p.values.get("--split")?.[0] ?? (p.values.has("-o") ? out.replace(/\.glb$/i, "") : join9(dirname7(input), basename6(input, extname4(input))));
-    if (!existsSync10(dir2))
-      mkdirSync4(dir2, { recursive: true });
+    const dir2 = p.values.get("--split")?.[0] ?? (p.values.has("-o") ? out.replace(/\.glb$/i, "") : join10(dirname7(input), basename7(input, extname5(input))));
+    if (!existsSync11(dir2))
+      mkdirSync5(dir2, { recursive: true });
     const parts = await splitDoc2(doc, { ground: !p.flags.has("--no-ground") });
     let total = 0;
     for (const part of parts) {
-      const f = join9(dir2, fileStem2(part.name) + ".glb");
+      const f = join10(dir2, fileStem2(part.name) + ".glb");
       const glb2 = await writeGlb2(part.doc);
       writeFileSync4(f, glb2);
       total += glb2.byteLength;
       const v = validateGlb2(glb2);
-      log(`   ${v.ok ? "✅" : "✗"} ${basename6(f).padEnd(40)} ${part.size.map((x) => x.toFixed(2)).join("×")} m  ${(glb2.byteLength / 1024).toFixed(0)} KB`);
+      log(`   ${v.ok ? "✅" : "✗"} ${basename7(f).padEnd(40)} ${part.size.map((x) => x.toFixed(2)).join("×")} m  ${(glb2.byteLength / 1024).toFixed(0)} KB`);
     }
     log(`\uD83D\uDCBE wrote ${parts.length} file(s) → ${dir2}  (${(total / 1024 / 1024).toFixed(2)} MB, ${((performance.now() - t0) / 1000).toFixed(1)}s)`);
     return 0;
   }
   const glb = await writeGlb2(doc);
   const dir = dirname7(out);
-  if (dir && !existsSync10(dir))
-    mkdirSync4(dir, { recursive: true });
+  if (dir && !existsSync11(dir))
+    mkdirSync5(dir, { recursive: true });
   writeFileSync4(out, glb);
   log(formatReport2(validateGlb2(glb), out));
   log(probeDocument2(doc, out).split(`
@@ -7257,6 +8977,7 @@ var real = (p, key) => {
 var scaleOpts = (p) => ({ scale: real(p, "--scale"), scaleTo: real(p, "--scale-to"), fixScale: p.flags.has("--fix-scale") });
 var shadingOpts = (p) => ({ unlit: p.flags.has("--unlit"), fixEmissive: p.flags.has("--fix-emissive") });
 var lightmapOpts = (p) => ({ lightmapUv: p.flags.has("--lightmap-uv"), lightmapPadding: num2(p, "--lightmap-padding"), lightmapIterations: num2(p, "--lightmap-iterations") });
+var lodOpts = (p) => ({ lod: (p.values.get("--lod") ?? []).flatMap((v) => v.split(",")).map(Number).filter((n) => n > 0 && n < 1), lodBones: p.flags.has("--lod-bones") });
 var cmdRetarget = async (p) => {
   const input = p.positionals[0];
   const donorPath = p.values.get("--from")?.[0];
@@ -7265,27 +8986,41 @@ var cmdRetarget = async (p) => {
     return 2;
   }
   for (const f of [input, donorPath])
-    if (!existsSync10(f)) {
+    if (!existsSync11(f)) {
       console.error(`✗ not found: ${f}`);
       return 1;
     }
-  const { loadRig: loadRig2, rigFromDocument: rigFromDocument2, checkUniformScale: checkUniformScale2 } = await Promise.resolve().then(() => (init_rig(), exports_rig));
+  const { loadRig: loadRig2, rigFromDocument: rigFromDocument2, checkUniformScale: checkUniformScale2, hasSkin: hasSkin2, rebindClips: rebindClips2 } = await Promise.resolve().then(() => (init_rig(), exports_rig));
   const { retarget: retarget2, bindAccessors: bindAccessors2, analyzeFacing: analyzeFacing2, facingMismatch: facingMismatch2 } = await Promise.resolve().then(() => (init_retarget(), exports_retarget));
   const { makeIO: makeIO3, writeGlb: writeGlb2 } = await Promise.resolve().then(() => (init_convert(), exports_convert));
   const { probeDocument: probeDocument2 } = await Promise.resolve().then(() => (init_probe(), exports_probe));
   const doc = await makeIO3().read(input);
-  const target = rigFromDocument2(doc, basename6(input));
-  let donor = donorPath.toLowerCase().endsWith(".fbx") ? await loadRig2(donorPath) : rigFromDocument2(await makeIO3().read(donorPath), basename6(donorPath));
+  const target = rigFromDocument2(doc, basename7(input));
+  const loadAny = async (path) => path.toLowerCase().endsWith(".fbx") ? loadRig2(path) : rigFromDocument2(await makeIO3().read(path), basename7(path));
+  let donor = await loadAny(donorPath);
+  const donorRigPath = p.values.get("--donor-rig")?.[0];
+  if (donorRigPath) {
+    if (!existsSync11(donorRigPath)) {
+      console.error(`✗ not found: ${donorRigPath}`);
+      return 1;
+    }
+    const r = rebindClips2(await loadAny(donorRigPath), donor);
+    log(`   \uD83D\uDCCE ${basename7(donorPath)}: ${r.bound}/${r.total} bones bound to ${basename7(donorRigPath)} by name${Math.abs(r.scale - 1) > 0.01 ? ` · the clip's skeleton is ×${(1 / r.scale).toFixed(2)} the rig's size (rotations taken, lengths the rig's)` : ""}${r.unbound.length ? ` (no bone: ${r.unbound.slice(0, 3).join(", ")}${r.unbound.length > 3 ? ` +${r.unbound.length - 3}` : ""})` : ""}`);
+    donor = r.rig;
+  } else if (!hasSkin2(donor) && !p.flags.has("--skeletons")) {
+    console.error(`✗ ${basename7(donorPath)} carries no skin (a clip-only file) — name the rig it was animated on: --donor-rig <model.fbx|.glb>`);
+    return 2;
+  }
   const animFiles = p.values.get("--anim") ?? [];
   if (animFiles.length) {
     const { parseUnityAnim: parseUnityAnim2, attachUnityClips: attachUnityClips2 } = await Promise.resolve().then(() => (init_unityAnim(), exports_unityAnim));
     const parsed = [];
     for (const f of animFiles) {
-      if (!existsSync10(f)) {
+      if (!existsSync11(f)) {
         console.error(`✗ not found: ${f}`);
         return 1;
       }
-      parsed.push(parseUnityAnim2(readFileSync11(f, "utf8"), basename6(f).replace(/\.anim$/i, "")));
+      parsed.push(parseUnityAnim2(readFileSync12(f, "utf8"), basename7(f).replace(/\.anim$/i, "")));
     }
     const { clips: attached, report } = attachUnityClips2(donor, parsed);
     donor = { ...donor, clips: [...donor.clips, ...attached] };
@@ -7309,31 +9044,76 @@ var cmdRetarget = async (p) => {
     };
     const a = col(target), b = col(donor);
     log(`
-${`TARGET ${basename6(input)} (${target.names.length})`.padEnd(46)}DONOR ${basename6(donorPath)} (${donor.names.length})`);
+${`TARGET ${basename7(input)} (${target.names.length})`.padEnd(46)}DONOR ${basename7(donorPath)} (${donor.names.length})`);
     log(`${"(* = bound by a skin)".padEnd(46)}(* = bound by a skin)`);
     for (let i = 0;i < Math.max(a.length, b.length); i++)
       log(`${(a[i] ?? "").slice(0, 44).padEnd(46)}${b[i] ?? ""}`);
     log(`
 donor clips: ${donor.clips.map((c) => `"${c.name}" ${c.duration.toFixed(2)}s`).join(", ") || "none"}`);
+    const { classifyBiped: classifyBiped3, describeBiped: describeBiped3 } = await Promise.resolve().then(() => (init_humanoid(), exports_humanoid));
+    for (const [label, rig] of [["target", target], ["donor", donor]]) {
+      try {
+        log(`${label} reads as a humanoid: ${describeBiped3(rig, classifyBiped3(rig))}`);
+      } catch {}
+    }
     return 0;
   }
+  const { avatarFromRig: avatarFromRig2, avatarFromUnity: avatarFromUnity2, avatarFromFile: avatarFromFile2, parseUnityAvatar: parseUnityAvatar2, mapAvatars: mapAvatars2, describeHumanoidMap: describeHumanoidMap2, describeBiped: describeBiped2, classifyBiped: classifyBiped2, isBiped: isBiped2 } = await Promise.resolve().then(() => (init_humanoid(), exports_humanoid));
+  const loadAvatar = (rig, file) => {
+    if (!file)
+      return isBiped2(rig) ? avatarFromRig2(rig) : null;
+    if (!existsSync11(file))
+      throw new Error(`not found: ${file}`);
+    const text = readFileSync12(file, "utf8");
+    return /\.meta$/i.test(file) ? avatarFromUnity2(rig, parseUnityAvatar2(text)) : avatarFromFile2(rig, JSON.parse(text));
+  };
+  let humanoid;
   const mapPath = p.values.get("--map")?.[0];
   const autoOut = p.values.get("--auto-map");
   let spec;
-  if (autoOut !== undefined || mapPath === "auto") {
-    const { autoMap: autoMap2, describeSkeleton: describeSkeleton2 } = await Promise.resolve().then(() => exports_automap);
-    const am = autoMap2(target, donor);
-    log(`\uD83E\uDDED auto-map ${basename6(input)} ← ${basename6(donorPath)}`);
-    log(`   target: ${describeSkeleton2(target, am.target)}`);
-    log(`   donor:  ${describeSkeleton2(donor, am.donor)}`);
-    for (const l of am.lines)
-      log(l);
-    spec = { _comment: `auto-mapped ${basename6(input)} ← ${basename6(donorPath)} by skeleton shape — review before trusting`, root: am.root, bones: am.map, legs: am.legs };
+  const avatarFile = p.values.get("--avatar")?.[0], donorAvatarFile = p.values.get("--donor-avatar")?.[0];
+  if (autoOut !== undefined || mapPath === "auto" || avatarFile || donorAvatarFile) {
+    let tAv, dAv;
+    try {
+      tAv = loadAvatar(target, avatarFile);
+      dAv = loadAvatar(donor, donorAvatarFile);
+    } catch (e) {
+      console.error(`✗ ${e.message}`);
+      return 1;
+    }
+    if (tAv && dAv) {
+      const hm = mapAvatars2(tAv, dAv);
+      log(`\uD83E\uDDED humanoid map ${basename7(input)} ← ${basename7(donorPath)}`);
+      for (const [label, rig, file] of [["target", target, avatarFile], ["donor", donor, donorAvatarFile]]) {
+        try {
+          log(`   ${label}: ${file ? `avatar from ${basename7(file)} · ` : ""}${describeBiped2(rig, classifyBiped2(rig))}`);
+        } catch {
+          log(`   ${label}: avatar from ${basename7(file ?? "?")} (shape did not classify)`);
+        }
+      }
+      for (const l of describeHumanoidMap2(tAv, dAv, hm))
+        log(l);
+      humanoid = { target: tAv, donor: dAv };
+      const { avatarToFile: avatarToFile2 } = await Promise.resolve().then(() => (init_humanoid(), exports_humanoid));
+      spec = { _comment: `humanoid map ${basename7(input)} ← ${basename7(donorPath)} — target and donor avatars joined on the Unity/VRM canon; review before trusting`, root: hm.root, bones: hm.map, legs: hm.legs, twist: tAv.twist, avatars: { target: avatarToFile2(tAv), donor: avatarToFile2(dAv) } };
+    } else if (tAv || dAv) {
+      console.error(`✗ ${tAv ? "the donor" : "the target"} does not read as a humanoid while ${tAv ? "the target" : "the donor"} does — a biped↔quadruped retarget needs a hand-written map`);
+      return 1;
+    } else {
+      const { autoMap: autoMap2, describeSkeleton: describeSkeleton2 } = await Promise.resolve().then(() => exports_automap);
+      const am = autoMap2(target, donor);
+      log(`\uD83E\uDDED auto-map ${basename7(input)} ← ${basename7(donorPath)}`);
+      log(`   target: ${describeSkeleton2(target, am.target)}`);
+      log(`   donor:  ${describeSkeleton2(donor, am.donor)}`);
+      for (const l of am.lines)
+        log(l);
+      spec = { _comment: `auto-mapped ${basename7(input)} ← ${basename7(donorPath)} by skeleton shape — review before trusting`, root: am.root, bones: am.map, legs: am.legs };
+    }
     if (autoOut !== undefined) {
-      const out2 = autoOut[0] ?? input.replace(/\.glb$/i, "") + "-from-" + basename6(donorPath).replace(/\.[^.]+$/, "") + ".map.json";
+      const out2 = autoOut[0] ?? input.replace(/\.glb$/i, "") + "-from-" + basename7(donorPath).replace(/\.[^.]+$/, "") + ".map.json";
       writeFileSync4(out2, JSON.stringify(spec, null, 2) + `
 `);
-      log(`\uD83D\uDCBE wrote ${out2}  (${Object.keys(am.map).length} bones) — edit it, then: retarget … --map ${basename6(out2)}`);
+      log(`\uD83D\uDCBE wrote ${out2}  (${Object.keys(spec.bones).length} bones) — edit it, then: retarget … --map ${basename7(out2)}`);
       return 0;
     }
   } else {
@@ -7341,27 +9121,41 @@ donor clips: ${donor.clips.map((c) => `"${c.name}" ${c.duration.toFixed(2)}s`).j
       console.error("✗ --map <map.json> is required (--map auto / --auto-map [out.json] to derive one from the skeletons, --skeletons to list them)");
       return 2;
     }
-    if (!existsSync10(mapPath)) {
+    if (!existsSync11(mapPath)) {
       console.error(`✗ not found: ${mapPath}`);
       return 1;
     }
-    spec = JSON.parse(readFileSync11(mapPath, "utf8"));
+    spec = JSON.parse(readFileSync12(mapPath, "utf8"));
     if (!spec.bones) {
       console.error(`✗ ${mapPath} has no "bones" object`);
       return 2;
     }
+    if (spec.avatars) {
+      try {
+        humanoid = { target: avatarFromFile2(target, spec.avatars.target), donor: avatarFromFile2(donor, spec.avatars.donor) };
+      } catch (e) {
+        log(`   ⚠ ${basename7(mapPath)} carries avatars that do not fit these rigs (${e.message}) — plain map`);
+      }
+    }
   }
   checkUniformScale2(target);
   checkUniformScale2(donor);
   const t0 = performance.now();
-  log(`\uD83D\uDD01 ${basename6(input)} ← ${basename6(donorPath)}`);
+  log(`\uD83D\uDD01 ${basename7(input)} ← ${basename7(donorPath)}`);
   let donorYawDeg = 0;
   {
     let fa = null, da = null;
     try {
       const { classify: classify2 } = await Promise.resolve().then(() => exports_automap);
-      fa = classify2(target);
-      da = classify2(donor);
+      const facingOf = (rig) => {
+        try {
+          return classifyBiped2(rig);
+        } catch {
+          return classify2(rig);
+        }
+      };
+      fa = facingOf(target);
+      da = facingOf(donor);
     } catch {
       const spine = Object.entries(spec.bones);
       const headPair = spine.find(([t]) => /head/i.test(t)), tailPair = spine.find(([t]) => /tail|root|hip|pelvis/i.test(t));
@@ -7388,6 +9182,27 @@ donor clips: ${donor.clips.map((c) => `"${c.name}" ${c.duration.toFixed(2)}s`).j
   const prefix = p.values.get("--prefix")?.[0] ?? "";
   const names = p.values.get("--clip-names");
   let produced = 0;
+  const tr = humanoid?.target.transfer;
+  if (tr && Object.keys(tr).length) {
+    const parts = [];
+    if (tr.rootMotion)
+      parts.push(`root motion ${tr.rootMotion}`);
+    if (tr.plant !== undefined)
+      parts.push(tr.plant ? "plant" : "no plant");
+    if (tr.hands)
+      parts.push("hands IK");
+    if (tr.twist !== undefined)
+      parts.push(`twist ${tr.twist}`);
+    for (const s of ["Left", "Right"])
+      if (tr.roll?.[s])
+        parts.push(`${s[0]} roll ${tr.roll[s] > 0 ? "+" : ""}${tr.roll[s]}°`);
+    const keep = Object.entries(tr.align ?? {}).filter(([, v]) => v === "keep").map(([k]) => k), al = Object.entries(tr.align ?? {}).filter(([, v]) => v === "align").map(([k]) => k);
+    if (keep.length)
+      parts.push(`keep ${keep.join(", ")}`);
+    if (al.length)
+      parts.push(`align ${al.join(", ")}`);
+    log(`   avatar transfer: ${parts.join(" · ")}`);
+  }
   const rep = retarget2(target, donor, spec.bones, spec.root ?? null, {
     align: p.values.get("--align")?.[0] ?? "bone-direction",
     alignTo: spec.alignTo,
@@ -7397,35 +9212,51 @@ donor clips: ${donor.clips.map((c) => `"${c.name}" ${c.duration.toFixed(2)}s`).j
       const v = p.values.get("--donor-ref")?.[0];
       return v === undefined ? spec.donorRef : v === "bind" || v === "auto" ? v : { clip: v };
     })(),
-    ik: p.values.get("--ik")?.[0] === "none" || spec.ik === false ? "none" : "legs",
+    ik: p.values.get("--ik")?.[0] === "none" || spec.ik === false ? "none" : p.values.get("--ik")?.[0] === "hands" || p.values.get("--ik") === undefined && tr?.hands ? "legs+hands" : "legs",
+    rootMotion: p.values.get("--root-motion")?.[0] ?? tr?.rootMotion ?? "auto",
+    rootRotation: p.values.get("--root-rotation")?.[0] ?? "none",
+    plant: p.flags.has("--no-plant") ? false : tr?.plant ?? true,
+    twist: (() => {
+      const v = p.values.get("--twist")?.[0];
+      return v === undefined ? tr?.twist !== undefined ? tr.twist > 0 ? tr.twist : false : 0.5 : v === "off" ? false : Number(v);
+    })(),
     legs: spec.legs,
     fps: num2(p, "--fps"),
     rootScale: real(p, "--root-scale"),
     clips: p.values.get("--clips"),
     rename: names?.length || prefix ? (n) => prefix + (names?.[produced++] ?? n) : undefined,
+    humanoid,
     warn: (w) => log(`   ⚠ ${w}`)
   });
+  if (humanoid)
+    log(`   humanoid: torso/legs keep, arms + fingers aligned (≥ 8°)${rep.roll.length ? ` · palm roll ${rep.roll.map((r) => `${r.side[0]} ${r.degrees.toFixed(0)}° (${r.via})`).join(", ")}` : ""}${rep.rootTranslateOnly ? " · root takes the hips' travel only" : ""}`);
   if (rep.bindGap.donor.worst > 0.001)
     log(`   ℹ donor's node pose sits ${rep.bindGap.donor.worst.toFixed(3)}m from its bind pose (worst: ${rep.bindGap.donor.bone}) — anchoring on the bind pose`);
-  log(`   ${rep.mapped.length} bones mapped · ${rep.align.length} direction-aligned (worst ${rep.align[0]?.degrees.toFixed(0) ?? 0}° on ${rep.align[0]?.bone ?? "-"}) · ${rep.kept.length} keep bind (${rep.kept.join(", ") || "-"})`);
+  log(`   ${rep.mapped.length} bones mapped · ${rep.align.length} direction-aligned (worst ${rep.align[0]?.degrees.toFixed(0) ?? 0}° on ${rep.align[0]?.bone ?? "-"})${rep.underThreshold.length ? ` · ${rep.underThreshold.length} under 8° kept (worst ${rep.underThreshold[0].degrees.toFixed(0)}° on ${rep.underThreshold[0].bone})` : ""} · ${rep.kept.length} keep bind (${rep.kept.join(", ") || "-"})`);
   log(`   donor reference: ${rep.donorRef} (leg directions ${rep.legDisagreement.toFixed(0)}° apart between the binds) · target binds ${rep.stance ? "in a stance — legs keep it" : "posed — legs aligned to the donor"}`);
   log(`   root ${rep.root ? `${rep.root.target}←${rep.root.donor} ×${+rep.rootScale.toPrecision(3)} (from ${rep.rootScaleFrom})` : "none"}${rep.ground ? ` · ground target ${rep.ground.target.toFixed(3)}m / donor ${rep.ground.donor.toFixed(3)}m` : ""}`);
   if (rep.legs.length)
     for (const l of rep.legs)
-      log(`   \uD83E\uDDB6 ${l.effector.padEnd(14)} ← ${l.donorEffector.padEnd(12)} chain ${l.chain.join("→")}  ×${l.ratio.toFixed(3)}${l.shortfall > 0.0001 ? `  ⚠ out of reach by up to ${(l.shortfall * 1000).toFixed(0)}mm` : ""}`);
+      log(`   ${l.isFoot ? "\uD83E\uDDB6" : "✋"} ${l.effector.padEnd(14)} ← ${l.donorEffector.padEnd(12)} chain ${l.chain.join("→")}${l.contact !== l.effector ? `  contact ${l.contact}` : ""}  ×${l.ratio.toFixed(3)}${l.planted ? `  planted ${l.planted} frames` : ""}${l.shortfall > 0.0001 ? `  ⚠ out of reach by up to ${(l.shortfall * 1000).toFixed(0)}mm` : ""}`);
   else if (p.values.get("--ik")?.[0] !== "none" && spec.ik !== false)
     log(`   ℹ no leg chains detected — feet follow FK only (name them in the map: "legs": [ … ])`);
+  if (rep.root)
+    log(`   root motion: ${rep.rootMotion}${rep.hipsBob ? ` · hips carry the ${rep.hipsBob === "donor" ? "donor's own bob" : "vertical bob"}` : ""}`);
+  if (rep.twist.length)
+    log(`   twist helpers: ${rep.twist.map((t) => `${t.bone} (${(t.at * 100).toFixed(0)}% of ${t.of})`).join(", ")}`);
   if (rep.bridges.length)
     log(`   bridged (interpolated between mapped bones): ${rep.bridges.join(", ")}`);
   if (rep.unmappedTarget.length)
     log(`   unmapped (left at rest): ${rep.unmappedTarget.join(", ")}`);
-  for (const c of rep.clips)
-    log(`   \uD83C\uDF9E  ${c.name.padEnd(22)} ${c.duration.toFixed(2)}s  ${c.frames} frames → ${c.keys} keys`);
+  for (const c of rep.clips) {
+    const reach = c.events.filter((e) => e.kind === "reach"), below = c.events.filter((e) => e.kind === "below");
+    log(`   \uD83C\uDF9E  ${c.name.padEnd(22)} ${c.duration.toFixed(2)}s  ${c.frames} frames → ${c.keys} keys${reach.length ? `  ⚠ ${reach.length}× out of reach (${(Math.max(...reach.map((e) => e.value ?? 0)) * 1000).toFixed(0)} mm)` : ""}${below.length ? `  ⚠ ${below.length}× toe under the ground (${(Math.max(...below.map((e) => e.value ?? 0)) * 1000).toFixed(0)} mm)` : ""}`);
+  }
   bindAccessors2(doc);
   const out = p.values.get("-o")?.[0] ?? input.replace(/\.glb$/i, ".retargeted.glb");
   const dir = dirname7(out);
-  if (dir && !existsSync10(dir))
-    mkdirSync4(dir, { recursive: true });
+  if (dir && !existsSync11(dir))
+    mkdirSync5(dir, { recursive: true });
   const glb = await writeGlb2(doc);
   writeFileSync4(out, glb);
   const { validateGlb: validateGlb2, formatReport: formatReport2 } = await Promise.resolve().then(() => (init_validateGlb(), exports_validateGlb));
@@ -7436,22 +9267,103 @@ donor clips: ${donor.clips.map((c) => `"${c.name}" ${c.duration.toFixed(2)}s`).j
   log(`\uD83D\uDCBE wrote ${out}  (${(glb.byteLength / 1024 / 1024).toFixed(2)} MB, ${((performance.now() - t0) / 1000).toFixed(1)}s)`);
   return 0;
 };
+var cmdAvatar = async (p) => {
+  const input = p.positionals[0];
+  if (!input) {
+    log(USAGE);
+    return 2;
+  }
+  if (!existsSync11(input)) {
+    console.error(`✗ not found: ${input}`);
+    return 1;
+  }
+  const { loadRig: loadRig2, rigFromDocument: rigFromDocument2 } = await Promise.resolve().then(() => (init_rig(), exports_rig));
+  const { classifyBiped: classifyBiped2, avatarFromBiped: avatarFromBiped2, avatarFromUnity: avatarFromUnity2, avatarToFile: avatarToFile2, parseUnityAvatar: parseUnityAvatar2, describeBiped: describeBiped2, HUMAN_BONES: HUMAN_BONES2 } = await Promise.resolve().then(() => (init_humanoid(), exports_humanoid));
+  const { makeIO: makeIO3 } = await Promise.resolve().then(() => (init_convert(), exports_convert));
+  const rig = /\.fbx$/i.test(input) ? await loadRig2(input) : rigFromDocument2(await makeIO3().read(input), basename7(input));
+  let shape = null;
+  try {
+    const b = classifyBiped2(rig);
+    shape = avatarFromBiped2(rig, b);
+    log(`\uD83E\uDDCD ${basename7(input)}: ${describeBiped2(rig, b)}`);
+    const groups = [
+      ["torso", ["Hips", "Spine", "Chest", "UpperChest", "Neck", "Head", "Jaw", "LeftEye", "RightEye"]],
+      ["left arm", ["LeftShoulder", "LeftUpperArm", "LeftLowerArm", "LeftHand"]],
+      ["right arm", ["RightShoulder", "RightUpperArm", "RightLowerArm", "RightHand"]],
+      ["left leg", ["LeftUpperLeg", "LeftLowerLeg", "LeftFoot", "LeftToes"]],
+      ["right leg", ["RightUpperLeg", "RightLowerLeg", "RightFoot", "RightToes"]]
+    ];
+    const av = shape;
+    for (const [g, keys] of groups)
+      log(`   ${g}: ${keys.filter((k) => av.bones[k]).map((k) => `${k}=${av.bones[k]}`).join(" ")}`);
+    const fingers = HUMAN_BONES2.filter((k) => k.includes(" ") && shape.bones[k]);
+    if (fingers.length)
+      log(`   fingers: ${fingers.length} phalanges (${fingers.filter((k) => k.endsWith("Proximal")).map((k) => shape.bones[k]).join(", ")})`);
+    if (Object.keys(shape.twist).length)
+      log(`   twist helpers: ${Object.entries(shape.twist).map(([t, of]) => `${t}→${of}`).join(", ")}`);
+    if (shape.bridged.length)
+      log(`   bridged: ${shape.bridged.join(", ")}`);
+    if (b.helpers.length)
+      log(`   not part of the body (${b.helpers.length}): ${b.helpers.map((i) => rig.names[i]).slice(0, 16).join(", ")}${b.helpers.length > 16 ? " …" : ""}`);
+    for (const n of shape.notes)
+      log(`   ⚠ ${n}`);
+  } catch (e) {
+    log(`✗ ${basename7(input)} does not read as a humanoid: ${e.message}`);
+  }
+  const metaPath = p.values.get("--meta")?.[0];
+  let unity = null;
+  if (metaPath) {
+    if (!existsSync11(metaPath)) {
+      console.error(`✗ not found: ${metaPath}`);
+      return 1;
+    }
+    unity = avatarFromUnity2(rig, parseUnityAvatar2(readFileSync12(metaPath, "utf8")));
+    for (const n of unity.notes)
+      log(`   ⚠ .meta: ${n}`);
+    if (shape) {
+      let agree = 0;
+      const differ = [];
+      for (const k of HUMAN_BONES2) {
+        const a = shape.bones[k], m = unity.bones[k];
+        if (a === m) {
+          if (a)
+            agree++;
+          continue;
+        }
+        differ.push(`${k}: shape=${a ?? "-"} .meta=${m ?? "-"}`);
+      }
+      log(`   vs ${basename7(metaPath)}: ${agree} bones agree${differ.length ? `, ${differ.length} differ:` : ""}`);
+      for (const d of differ)
+        log(`      ${d}`);
+    }
+  }
+  const chosen = unity ?? shape;
+  if (!chosen)
+    return 1;
+  const out = p.values.get("-o")?.[0];
+  if (out) {
+    writeFileSync4(out, JSON.stringify(avatarToFile2(chosen), null, 2) + `
+`);
+    log(`\uD83D\uDCBE wrote ${out}  (${Object.keys(chosen.bones).length} bones, ${unity ? "Unity's map" : "from shape"}) — retarget … --avatar ${basename7(out)}`);
+  }
+  return 0;
+};
 var cmdUnpack = async (p) => {
   const pkg = p.positionals[0];
   if (!pkg) {
     log(USAGE);
     return 2;
   }
-  if (!existsSync10(pkg)) {
+  if (!existsSync11(pkg)) {
     console.error(`✗ not found: ${pkg}`);
     return 1;
   }
   const { indexUnityPackage: indexUnityPackage2, writeUnityIndex: writeUnityIndex2, readUnityIndex: readUnityIndex2, extractUnityPackage: extractUnityPackage2, INDEX_NAME: INDEX_NAME2 } = await Promise.resolve().then(() => (init_unpack(), exports_unpack));
-  const outDir = p.values.get("-o")?.[0] ?? join9(dirname7(pkg), basename6(pkg, extname4(pkg)));
+  const outDir = p.values.get("-o")?.[0] ?? join10(dirname7(pkg), basename7(pkg, extname5(pkg)));
   const t0 = performance.now();
-  const indexFile = join9(outDir, INDEX_NAME2);
+  const indexFile = join10(outDir, INDEX_NAME2);
   let index;
-  if (existsSync10(indexFile)) {
+  if (existsSync11(indexFile)) {
     index = readUnityIndex2(indexFile);
     log(`\uD83D\uDCC7 ${index.size} assets (cached ${indexFile})`);
   } else {
@@ -7480,14 +9392,14 @@ var cmdProbe = async (p) => {
     log(USAGE);
     return 2;
   }
-  if (!existsSync10(input)) {
+  if (!existsSync11(input)) {
     console.error(`✗ not found: ${input}`);
     return 1;
   }
   const { probeFile: probeFile2 } = await Promise.resolve().then(() => (init_probe(), exports_probe));
   log(await probeFile2(input));
   if (p.values.has("--filmstrip")) {
-    if (extname4(input).toLowerCase() === ".fbx") {
+    if (extname5(input).toLowerCase() === ".fbx") {
       console.error("✗ --filmstrip wants a GLB (convert first)");
       return 2;
     }
@@ -7518,7 +9430,7 @@ var cmdScene = async (p) => {
     log(USAGE);
     return 2;
   }
-  if (!existsSync10(input)) {
+  if (!existsSync11(input)) {
     console.error(`✗ not found: ${input}`);
     return 1;
   }
@@ -7552,8 +9464,8 @@ var cmdScene = async (p) => {
     log(`   ${l}`);
   const out = p.values.get("-o")?.[0] ?? input.replace(/\.unity$/i, "") + ".level.json";
   const dir = dirname7(out);
-  if (dir && !existsSync10(dir))
-    mkdirSync4(dir, { recursive: true });
+  if (dir && !existsSync11(dir))
+    mkdirSync5(dir, { recursive: true });
   writeFileSync4(out, JSON.stringify(r, null, 1) + `
 `);
   log(`\uD83D\uDCBE wrote ${out}  (${r.instances.length} instances, ${((performance.now() - t0) / 1000).toFixed(1)}s) — frame: ${r.frame}`);
@@ -7566,8 +9478,8 @@ var resolveInputs = (args) => {
       out.push(f);
   };
   const walk = (dir, recursive, pattern) => {
-    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-      const p = join9(dir, entry.name).replace(/\\/g, "/");
+    for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+      const p = join10(dir, entry.name).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         if (recursive)
           walk(p, true, pattern);
@@ -7585,9 +9497,9 @@ var resolveInputs = (args) => {
       if (recursive)
         segs.pop();
       const dir = segs.join("/") || ".";
-      if (existsSync10(dir))
+      if (existsSync11(dir))
         walk(dir, recursive, toRegex(last));
-    } else if (existsSync10(a) && statSync6(a).isDirectory()) {
+    } else if (existsSync11(a) && statSync7(a).isDirectory()) {
       walk(a.replace(/\/+$/, ""), false, /\.glb$/i);
     } else
       out.push(a);
@@ -7608,12 +9520,13 @@ var cmdDoctor = async (p) => {
   const sh = shadingOpts(p);
   const sc = scaleOpts(p);
   const lmo = lightmapOpts(p);
+  const lod = lodOpts(p);
   const wantsScale = sc.fixScale || sc.scale !== undefined || sc.scaleTo !== undefined;
-  const doFix = p.flags.has("--fix") || useKtx2 || fixMetallic || wantsScale || sh.unlit || sh.fixEmissive || lmo.lightmapUv;
+  const doFix = p.flags.has("--fix") || useKtx2 || fixMetallic || wantsScale || sh.unlit || sh.fixEmissive || lmo.lightmapUv || lod.lod.length > 0;
   const dumpMode = p.values.has("--dump");
   const dumpVal = p.values.get("--dump")?.[0] ?? null;
   const oVal = p.values.get("-o")?.[0] ?? null;
-  const opts = { ktx2: useKtx2, ktx2Hq: p.flags.has("--ktx2-hq"), ktx2Uastc: p.flags.has("--ktx2-uastc"), maxSize: num2(p, "--max-size"), target: num2(p, "--target"), ...sc, ...sh, ...lmo };
+  const opts = { ktx2: useKtx2, ktx2Hq: p.flags.has("--ktx2-hq"), ktx2Uastc: p.flags.has("--ktx2-uastc"), maxSize: num2(p, "--max-size"), target: num2(p, "--target"), ...sc, ...sh, ...lmo, ...lod };
   let toktx = "";
   if (useKtx2) {
     toktx = findToktx2();
@@ -7631,7 +9544,7 @@ var cmdDoctor = async (p) => {
     log(`Processing ${files.length} files…`);
   let exitCode = 0;
   for (const input of files) {
-    if (!existsSync10(input)) {
+    if (!existsSync11(input)) {
       console.error(`
 ✗ not found: ${input}`);
       exitCode = 1;
@@ -7667,13 +9580,23 @@ var cmdDoctor = async (p) => {
       log(`   baked scale ×${+res.scaled.toPrecision(6)}`);
     if (res.lightmapUv)
       log(`   lightmap UV: ${res.lightmapUv.charts} charts over ${res.lightmapUv.primitives} primitive(s) (xatlas ${res.lightmapUv.width}×${res.lightmapUv.height}); vertices ${res.lightmapUv.verticesBefore} → ${res.lightmapUv.verticesAfter}`);
+    if (res.lod) {
+      for (const t of res.lod.tris)
+        log(`   lod: ${t.name} ${t.levels.join(" / ")} tris`);
+      for (const b of res.lod.bones)
+        log(`   lod bones: ${b.name} last level ${b.before} → ${b.after} joints`);
+      for (const k of res.lod.skipped)
+        log(`   lod: ${k.name} level ${k.level} dropped — the simplifier reached only ${k.tris} tris (seams / hard surfaces; try a smaller ratio)`);
+      if (!res.lod.nodes)
+        log(`   lod: no mesh with >= 2000 triangles (or the _LOD nodes are already there)`);
+    }
     const output = outputFor2(input, oVal, files.length > 1, useKtx2);
     const root = doc.getRoot();
     if (!root.getDefaultScene() && root.listScenes().length > 0)
       root.setDefaultScene(root.listScenes()[0]);
     await io.write(output, doc);
-    const beforeBytes = statSync6(input).size;
-    const after = readFileSync11(output);
+    const beforeBytes = statSync7(input).size;
+    const after = readFileSync12(output);
     log(`\uD83D\uDCBE wrote ${output}  (${kb2(beforeBytes)} → ${kb2(after.byteLength)})`);
     log(formatReport2(validateGlb2(after), output));
   }
@@ -7704,6 +9627,42 @@ var cmdSky = async (p) => {
     return 1;
   }
 };
+var cmdTerrainPack = async (p) => {
+  if (p.positionals.length === 0) {
+    console.error("✗ usage: lecodes-assets terrain-pack <layer> [<layer> …] [-o dir] [--normals n0 n1 …] [--names a b …] [--size N] [--png] [--flip-y]");
+    return 2;
+  }
+  const { resolveTerrainLayer: resolveTerrainLayer2, packTerrainTextures: packTerrainTextures2 } = await Promise.resolve().then(() => (init_terrainPack(), exports_terrainPack));
+  const normals = p.values.get("--normals") ?? [];
+  const names = p.values.get("--names") ?? [];
+  const outDir = resolve6(p.values.get("-o")?.[0] ?? "terrain");
+  try {
+    const layers = p.positionals.map((input, i) => {
+      const n = normals[i];
+      return resolveTerrainLayer2(input, n && n !== "-" ? n : undefined, names[i]);
+    });
+    log(`
+\uD83C\uDFD4  ${layers.length} layer(s) → ${outDir}`);
+    const res = await packTerrainTextures2(layers, {
+      outDir,
+      size: num2(p, "--size"),
+      png: p.flags.has("--png"),
+      flipY: p.flags.has("--flip-y"),
+      quality: num2(p, "--quality"),
+      log
+    });
+    log(`
+   Terrain.create({ …,
+${res.snippet.split(`
+`).map((l) => "     " + l).join(`
+`)}
+   })   (asset() paths relative to the calling file)`);
+    return 0;
+  } catch (e) {
+    console.error(`✗ ${e.message}`);
+    return 1;
+  }
+};
 var runAssetsCli = async (argv) => {
   const [cmd, ...rest] = argv;
   const p = parse(rest);
@@ -7718,8 +9677,12 @@ var runAssetsCli = async (argv) => {
       return cmdDoctor(p);
     case "retarget":
       return cmdRetarget(p);
+    case "avatar":
+      return cmdAvatar(p);
     case "sky":
       return cmdSky(p);
+    case "terrain-pack":
+      return cmdTerrainPack(p);
     case "scene":
       return cmdScene(p);
     default:
@@ -7745,22 +9708,129 @@ init_validateGlb();
 init_normalizeScale();
 init_rig();
 init_retarget();
+
+// src/retarget/inPlace.ts
+var qmul3 = (a, b) => [
+  a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
+  a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
+  a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
+  a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2]
+];
+var qinv2 = (q) => [-q[0], -q[1], -q[2], q[3]];
+var headingOf = (q) => Math.atan2(2 * (q[0] * q[2] + q[3] * q[1]), 1 - 2 * (q[0] * q[0] + q[1] * q[1]));
+var makeInPlace = (doc, animationName, rootNodeName, opts = {}) => {
+  const anim = doc.getRoot().listAnimations().find((a) => a.getName() === animationName);
+  if (!anim)
+    throw new Error(`makeInPlace: no animation "${animationName}"`);
+  const channel = anim.listChannels().find((c) => c.getTargetPath() === "translation" && c.getTargetNode()?.getName() === rootNodeName);
+  if (!channel)
+    return null;
+  const node = channel.getTargetNode();
+  const [rx, , rz] = node.getTranslation();
+  const sampler = channel.getSampler();
+  const input = sampler.getInput(), output = sampler.getOutput();
+  const times = Array.from(input.getArray());
+  const values = new Float32Array(output.getArray());
+  const travel = [];
+  for (let k = 0;k < times.length; k++) {
+    travel.push([values[k * 3] - rx, values[k * 3 + 2] - rz]);
+    values[k * 3] = rx;
+    values[k * 3 + 2] = rz;
+  }
+  output.setArray(values);
+  const speed = times.map((_, k) => {
+    const a = Math.max(0, k - 1), b = Math.min(times.length - 1, k + 1);
+    const dt = times[b] - times[a];
+    return dt > 0 ? Math.hypot(travel[b][0] - travel[a][0], travel[b][1] - travel[a][1]) / dt : 0;
+  });
+  const yaw = [];
+  if (opts.yaw) {
+    const rc = anim.listChannels().find((c) => c.getTargetPath() === "rotation" && c.getTargetNode() === node);
+    if (rc) {
+      const rs = rc.getSampler();
+      const rt = Array.from(rs.getInput().getArray());
+      const rv = new Float32Array(rs.getOutput().getArray());
+      const rest = node.getRotation();
+      const at = (t) => {
+        let i = 0;
+        while (i < rt.length - 2 && rt[i + 1] <= t)
+          i++;
+        const t0 = rt[i], t1 = rt[i + 1] ?? t0, u = t1 > t0 ? Math.min(1, Math.max(0, (t - t0) / (t1 - t0))) : 0;
+        const a = Array.from(rv.subarray(i * 4, i * 4 + 4)), b = rt.length > i + 1 ? Array.from(rv.subarray(i * 4 + 4, i * 4 + 8)) : a;
+        const s = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3] < 0 ? -1 : 1;
+        const q = [a[0] + (s * b[0] - a[0]) * u, a[1] + (s * b[1] - a[1]) * u, a[2] + (s * b[2] - a[2]) * u, a[3] + (s * b[3] - a[3]) * u];
+        const n = Math.hypot(...q) || 1;
+        return [q[0] / n, q[1] / n, q[2] / n, q[3] / n];
+      };
+      let acc = 0, prev = 0;
+      for (let k = 0;k < times.length; k++) {
+        const h = headingOf(qmul3(at(times[k]), qinv2(rest)));
+        if (k > 0) {
+          let d = h - prev;
+          d = Math.atan2(Math.sin(d), Math.cos(d));
+          acc += d;
+        }
+        prev = h;
+        yaw.push(acc * 180 / Math.PI);
+      }
+      const base = yaw[0] ?? 0;
+      for (let k = 0;k < yaw.length; k++)
+        yaw[k] = yaw[k] - base;
+      for (let k = 0;k < rt.length; k++) {
+        rv[k * 4] = rest[0];
+        rv[k * 4 + 1] = rest[1];
+        rv[k * 4 + 2] = rest[2];
+        rv[k * 4 + 3] = rest[3];
+      }
+      rs.getOutput().setArray(rv);
+    }
+  }
+  const extras = anim.getExtras();
+  const lecodes = { ...extras.lecodes ?? {}, inPlace: true };
+  anim.setExtras({ ...extras, lecodes });
+  return { times, travel, speed, yaw };
+};
+var resample = (times, series, hz) => {
+  const end = times[times.length - 1] ?? 0;
+  const n = Math.ceil(end * hz);
+  const out = [];
+  for (let k = 0;k <= n; k++) {
+    const t = Math.min(end, k / hz);
+    let i = 0;
+    while (i < times.length - 2 && times[i + 1] <= t)
+      i++;
+    const t0 = times[i], t1 = times[i + 1] ?? t0;
+    const u = t1 > t0 ? (t - t0) / (t1 - t0) : 0;
+    out.push(series[i] + ((series[i + 1] ?? series[i]) - series[i]) * u);
+  }
+  return out;
+};
+var speedProfile = (r, hz = 30) => resample(r.times, r.speed, hz);
+var yawProfile = (r, hz = 30) => r.yaw.length ? resample(r.times, r.yaw, hz) : [];
+
+// src/index.ts
+init_terrainPack();
 export {
+  yawProfile,
   writeGlb,
   validateGlb,
   toDocument,
+  speedProfile,
   sceneBounds,
   runAssetsCli,
   rigFromFbx,
   rigFromDocument,
   retarget,
+  resolveTerrainLayer,
   reportPlan,
   readFbx,
   probeFile,
   probeFbx,
   probeDocument,
+  packTerrainTextures,
   mergeClipScene,
   measureScale,
+  makeInPlace,
   makeIO,
   loadRig,
   formatReport,