@genex-ai/cli-demo 0.87.0-dev.218 → 0.88.0-dev.219

package/dist/index.js

@@ -402,7 +402,7 @@ async function syncSkillsForTarget(target, templatesDir = getTemplatesDir(), ver
   if (await readSkillsMarker(skillsDir) === version) return false;
   const src = target.full ? templatesDir : path4.join(templatesDir, "skills");
   const dest = target.full ? target.baseDir : skillsDir;
-  await copyTemplates(src, dest, { exclude: ["controllers"] });
+  await copyTemplates(src, dest, { exclude: ["controllers", "motion"] });
   await pruneRemovedSkills(skillsDir, log);
   await writeSkillsMarker(skillsDir, version);
   return true;
@@ -1315,7 +1315,7 @@ async function runInit(opts) {
     const dest = t.full ? t.baseDir : path9.join(t.baseDir, "skills");
     const { copied, updated } = await copyTemplates(src, dest, {
       force: opts.force,
-      exclude: ["controllers"]
+      exclude: ["controllers", "motion"]
     });
     await pruneRemovedSkills(path9.join(t.baseDir, "skills"), log);
     await writeSkillsMarker(path9.join(t.baseDir, "skills"));
@@ -2071,9 +2071,9 @@ function measureSeam(png, tolerance = DEFAULT_SEAM_TOLERANCE) {
   }
   baseH = Math.max(baseH / Math.max(1, nH), 1e-6);
   baseV = Math.max(baseV / Math.max(1, nV), 1e-6);
-  const round = (n) => Math.round(n * 100) / 100;
-  const ratioHorizontal = round(seamH / baseH);
-  const ratioVertical = round(seamV / baseV);
+  const round2 = (n) => Math.round(n * 100) / 100;
+  const ratioHorizontal = round2(seamH / baseH);
+  const ratioVertical = round2(seamV / baseV);
   const worstRatio = Math.max(ratioHorizontal, ratioVertical);
   return {
     width: w,
@@ -3606,11 +3606,11 @@ async function uiAudit(opts, log) {
     return;
   }
   const hard = findings.filter((finding) => HARD_AUDIT_KINDS.has(finding.kind));
-  const soft = findings.filter((finding) => !HARD_AUDIT_KINDS.has(finding.kind));
+  const soft2 = findings.filter((finding) => !HARD_AUDIT_KINDS.has(finding.kind));
   for (const finding of hard) log.error(`[${finding.kind}] ${finding.message}`);
-  if (soft.length > 0) {
-    log.warn(`${soft.length} finding(s). These are heuristics \u2014 check each one; some may be fine:`);
-    for (const finding of soft) log.warn(`  [${finding.kind}] ${finding.message}`);
+  if (soft2.length > 0) {
+    log.warn(`${soft2.length} finding(s). These are heuristics \u2014 check each one; some may be fine:`);
+    for (const finding of soft2) log.warn(`  [${finding.kind}] ${finding.message}`);
   }
   if (opts.strict || hard.length > 0) process.exitCode = 1;
 }
@@ -4259,6 +4259,8 @@ var WAIT_TIMEOUT_MS = 10 * 60 * 1e3;
 var KIND_WAIT_TIMEOUT_MS = {
   video: 15 * 60 * 1e3,
   // 15 min
+  motion: 20 * 60 * 1e3,
+  // 8 takes ≈ 8-9 GPU min + a serverless cold start
   character_concept: 15 * 60 * 1e3,
   character_preview: 30 * 60 * 1e3,
   character: 30 * 60 * 1e3,
@@ -4374,6 +4376,7 @@ function printHint(kind, view, files, log) {
     texture: `Load each map with TextureLoader (RepeatWrapping) into a MeshStandardMaterial \u2014 see genex-ai-texture. Use the URLs above by role.`,
     image: `Load with TextureLoader (set colorSpace = SRGBColorSpace) onto any mesh/plane/sprite \u2014 see genex-ai-image. url = "${url}"`,
     video: `Wire an HTMLVideoElement (crossOrigin="anonymous", muted, loop, playsInline) into a THREE.VideoTexture \u2014 see genex-ai-video. url = "${url}"`,
+    motion: `Raw ARDY takes + verify report \u2014 download the takes, rename them meaningfully (routing is by filename), then: genex motion verify \u2192 compile \u2192 install. Full procedure: the genex-ai-character skill's motion reference.`,
     character_concept: "Show all three concept candidates to the user and wait for an explicit selection.",
     character_preview: "Show all four preview views to the user and wait for explicit approval before finalizing.",
     character: `Install the controller and current manifest with genex controller character --character ${view.id}.`,
@@ -14986,17 +14989,17 @@ function searchMeshyAnimations(query, options = {}) {
     if (options.category && entry.category.toLowerCase() !== options.category.toLowerCase()) continue;
     if (options.inPlace !== void 0 && entry.inPlace !== options.inPlace) continue;
     const matched = [];
-    let score = 0;
+    let score2 = 0;
     if (String(entry.actionId) === rawQuery) {
-      score += 1e5;
+      score2 += 1e5;
       matched.push("action id");
     }
     if (entry.key.toLowerCase() === rawQuery) {
-      score += 8e4;
+      score2 += 8e4;
       matched.push("stable key");
     }
     if (entry.name.toLowerCase() === rawQuery) {
-      score += 6e4;
+      score2 += 6e4;
       matched.push("exact name");
     }
     const haystack = new Set(tokens([
@@ -15014,13 +15017,13 @@ function searchMeshyAnimations(query, options = {}) {
       coveredGroups++;
       const original = queryTokens[index];
       const best = hits.includes(original) ? original : hits[0];
-      score += best === original ? 400 : 140;
+      score2 += best === original ? 400 : 140;
       matched.push(best);
     }
-    if (entry.inPlace && (expanded.has("walk") || expanded.has("run"))) score += 35;
-    const exact = score >= 6e4;
-    if (score > 0 && (exact || coveredGroups === groups.length)) {
-      results.push({ entry, score, matched: [...new Set(matched)] });
+    if (entry.inPlace && (expanded.has("walk") || expanded.has("run"))) score2 += 35;
+    const exact = score2 >= 6e4;
+    if (score2 > 0 && (exact || coveredGroups === groups.length)) {
+      results.push({ entry, score: score2, matched: [...new Set(matched)] });
     }
   }
   return results.sort((a, b) => b.score - a.score || a.entry.name.localeCompare(b.entry.name) || a.entry.actionId - b.entry.actionId).slice(0, options.limit ?? 20);
@@ -15604,9 +15607,9 @@ async function installMeshyCharacterManifest(args) {
 `
   );
   args.log.dim(`  public/assets/meshy-character.json (${args.characterId}, current revision)`);
-  const pack = manifest.controllerPack;
-  if (typeof pack?.key === "string" && typeof pack.version === "number") {
-    args.log.success(`Meshy controller pack ${pack.key} v${pack.version}`);
+  const pack2 = manifest.controllerPack;
+  if (typeof pack2?.key === "string" && typeof pack2.version === "number") {
+    args.log.success(`Meshy controller pack ${pack2.key} v${pack2.version}`);
   } else {
     args.log.warn("Legacy Meshy manifest \u2014 regenerate the character for the immutable preview-reviewed neutral-v3 locomotion pack.");
   }
@@ -15667,37 +15670,37 @@ function incompletePack(message) {
   throw new Error(`Incomplete Meshy controller pack: ${message}`);
 }
 function assertCompleteMeshyControllerPack(manifest) {
-  const pack = manifest.controllerPack;
-  if (pack === void 0) return;
-  if (typeof pack.key !== "string" || pack.key.length === 0 || typeof pack.version !== "number" || !Number.isInteger(pack.version)) {
+  const pack2 = manifest.controllerPack;
+  if (pack2 === void 0) return;
+  if (typeof pack2.key !== "string" || pack2.key.length === 0 || typeof pack2.version !== "number" || !Number.isInteger(pack2.version)) {
     incompletePack("invalid key or version.");
   }
-  if (typeof pack.fingerprint !== "string" || pack.fingerprint.length === 0) {
-    incompletePack(`${pack.key} v${pack.version} has no immutable fingerprint.`);
+  if (typeof pack2.fingerprint !== "string" || pack2.fingerprint.length === 0) {
+    incompletePack(`${pack2.key} v${pack2.version} has no immutable fingerprint.`);
   }
-  if (!Array.isArray(pack.actionIds) || pack.actionIds.length === 0 || pack.actionIds.some((actionId) => typeof actionId !== "number" || !Number.isInteger(actionId))) {
-    incompletePack(`${pack.key} v${pack.version} has no valid action snapshot.`);
+  if (!Array.isArray(pack2.actionIds) || pack2.actionIds.length === 0 || pack2.actionIds.some((actionId) => typeof actionId !== "number" || !Number.isInteger(actionId))) {
+    incompletePack(`${pack2.key} v${pack2.version} has no valid action snapshot.`);
   }
-  const actionIds = pack.actionIds;
+  const actionIds = pack2.actionIds;
   const packActionIds = new Set(actionIds);
   if (packActionIds.size !== actionIds.length) {
-    incompletePack(`${pack.key} v${pack.version} repeats an action ID.`);
+    incompletePack(`${pack2.key} v${pack2.version} repeats an action ID.`);
   }
   const bindings = manifest.locomotion?.bindings;
-  if (!bindings) incompletePack(`${pack.key} v${pack.version} has no authoritative locomotion bindings.`);
+  if (!bindings) incompletePack(`${pack2.key} v${pack2.version} has no authoritative locomotion bindings.`);
   const missingSlots = REQUIRED_MESHY_CONTROLLER_SLOTS.filter((slot) => bindings[slot] === void 0);
   if (missingSlots.length > 0) {
-    incompletePack(`${pack.key} v${pack.version} is missing ${missingSlots.join(", ")}.`);
+    incompletePack(`${pack2.key} v${pack2.version} is missing ${missingSlots.join(", ")}.`);
   }
   const clips = manifest.clips ?? [];
   const boundActionIds = /* @__PURE__ */ new Set();
   const snapshotBindings = {};
   for (const [slot, binding] of Object.entries(bindings)) {
     if (typeof binding.actionId !== "number" || !Number.isInteger(binding.actionId) || typeof binding.clip !== "string" || binding.clip.length === 0 || binding.mode !== "loop" && binding.mode !== "one-shot" && binding.mode !== "pose") {
-      incompletePack(`${pack.key} v${pack.version} has an invalid ${slot} binding.`);
+      incompletePack(`${pack2.key} v${pack2.version} has an invalid ${slot} binding.`);
     }
     if (binding.phase !== void 0 && (typeof binding.phase !== "number" || !Number.isFinite(binding.phase) || binding.phase < 0 || binding.phase > 1)) {
-      incompletePack(`${pack.key} v${pack.version} has an invalid ${slot} phase.`);
+      incompletePack(`${pack2.key} v${pack2.version} has an invalid ${slot} phase.`);
     }
     const actionId = binding.actionId;
     boundActionIds.add(actionId);
@@ -15716,21 +15719,21 @@ function assertCompleteMeshyControllerPack(manifest) {
   }
   const unboundActionIds = actionIds.filter((actionId) => !boundActionIds.has(actionId));
   if (unboundActionIds.length > 0) {
-    incompletePack(`${pack.key} v${pack.version} action snapshot contains unbound actions ${unboundActionIds.join(", ")}.`);
+    incompletePack(`${pack2.key} v${pack2.version} action snapshot contains unbound actions ${unboundActionIds.join(", ")}.`);
   }
   let computedFingerprint;
   try {
     computedFingerprint = createMeshyControllerPackSnapshot({
-      key: pack.key,
-      version: pack.version,
+      key: pack2.key,
+      version: pack2.version,
       actionIds,
       bindings: snapshotBindings
     }).fingerprint;
   } catch (error) {
     incompletePack(error instanceof Error ? error.message : "the immutable snapshot is invalid.");
   }
-  if (computedFingerprint !== pack.fingerprint) {
-    incompletePack(`${pack.key} v${pack.version} fingerprint does not match its action bindings.`);
+  if (computedFingerprint !== pack2.fingerprint) {
+    incompletePack(`${pack2.key} v${pack2.version} fingerprint does not match its action bindings.`);
   }
 }
 async function installOwnerAvatar(args) {
@@ -16375,16 +16378,1550 @@ function rank(items, query) {
   const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
   return items.map((p) => {
     const hay = `${p.title} ${p.description} ${p.categories.join(" ")}`.toLowerCase();
-    let score = 0;
+    let score2 = 0;
     for (const t of terms) {
-      if (p.title.toLowerCase().includes(t)) score += 3;
-      if (p.categories.some((cat) => cat.includes(t))) score += 2;
-      if (hay.includes(t)) score += 1;
+      if (p.title.toLowerCase().includes(t)) score2 += 3;
+      if (p.categories.some((cat) => cat.includes(t))) score2 += 2;
+      if (hay.includes(t)) score2 += 1;
     }
-    return { p, score };
+    return { p, score: score2 };
   }).filter((x) => x.score > 0).sort((a, b) => b.score - a.score || b.p.playsCount - a.p.playsCount).map((x) => x.p);
 }
 
+// src/commands/motion.ts
+import fs18 from "fs/promises";
+import path18 from "path";
+
+// src/lib/motion/npz.ts
+import zlib from "zlib";
+function readNpy(b) {
+  if (b.toString("latin1", 1, 6) !== "NUMPY") throw new Error("not an .npy member");
+  const major = b[6];
+  const hlen = major >= 2 ? b.readUInt32LE(8) : b.readUInt16LE(8);
+  const hstart = major >= 2 ? 12 : 10;
+  const header = b.toString("latin1", hstart, hstart + hlen);
+  const descr = /'descr':\s*'([^']+)'/.exec(header)?.[1];
+  const fortran = /'fortran_order':\s*(True|False)/.exec(header)?.[1] === "True";
+  const shapeRaw = /'shape':\s*\(([^)]*)\)/.exec(header)?.[1];
+  if (!descr || shapeRaw === void 0) throw new Error(`unparseable .npy header: ${header}`);
+  if (fortran) throw new Error("fortran-order .npy is unsupported");
+  const shape = shapeRaw.split(",").map((s) => s.trim()).filter(Boolean).map(Number);
+  const data = Buffer.from(b.subarray(hstart + hlen));
+  if (descr === "<f4") return { shape, descr, data: new Float32Array(data.buffer, data.byteOffset, data.length / 4) };
+  if (descr === "<f8") return { shape, descr, data: new Float64Array(data.buffer, data.byteOffset, data.length / 8) };
+  if (descr === "<i8") return { shape, descr, data: new BigInt64Array(data.buffer, data.byteOffset, data.length / 8) };
+  if (descr === "|b1") return { shape, descr, data: new Uint8Array(data.buffer, data.byteOffset, data.length) };
+  if (descr.startsWith("<U")) return { shape, descr, data: data.toString("utf16le").replace(/\0+$/, "") };
+  if (descr === "|O") throw new Error(".npz member is a pickled object array \u2014 regenerate the take with a current ARDY");
+  throw new Error(`unsupported .npy dtype ${descr}`);
+}
+function readNpz(buf) {
+  let e = buf.length - 22;
+  while (e >= 0 && buf.readUInt32LE(e) !== 101010256) e--;
+  if (e < 0) throw new Error("not a ZIP/.npz file (no end-of-central-directory)");
+  const count = buf.readUInt16LE(e + 10);
+  let off = buf.readUInt32LE(e + 16);
+  const out = {};
+  for (let i = 0; i < count; i++) {
+    if (buf.readUInt32LE(off) !== 33639248) throw new Error("corrupt ZIP central directory");
+    const method = buf.readUInt16LE(off + 10);
+    const csize = buf.readUInt32LE(off + 20);
+    const nameLen = buf.readUInt16LE(off + 28);
+    const extraLen = buf.readUInt16LE(off + 30);
+    const cmtLen = buf.readUInt16LE(off + 32);
+    const lho = buf.readUInt32LE(off + 42);
+    const name = buf.toString("utf8", off + 46, off + 46 + nameLen);
+    const lNameLen = buf.readUInt16LE(lho + 26);
+    const lExtraLen = buf.readUInt16LE(lho + 28);
+    const dataStart = lho + 30 + lNameLen + lExtraLen;
+    const raw = buf.subarray(dataStart, dataStart + csize);
+    const bytes = method === 8 ? zlib.inflateRawSync(raw) : Buffer.from(raw);
+    if (method !== 0 && method !== 8) throw new Error(`unsupported ZIP method ${method} for ${name}`);
+    out[name.replace(/\.npy$/, "")] = readNpy(bytes);
+    off += 46 + nameLen + extraLen + cmtLen;
+  }
+  return out;
+}
+function floats(npz, key) {
+  const m = npz[key];
+  if (!m) throw new Error(`.npz is missing "${key}" \u2014 not an ARDY take?`);
+  const d = m.data;
+  if (d instanceof Float64Array) return { shape: m.shape, a: d };
+  if (d instanceof Float32Array) return { shape: m.shape, a: Float64Array.from(d) };
+  if (d instanceof Uint8Array && m.descr === "|b1") return { shape: m.shape, a: Float64Array.from(d) };
+  throw new Error(`"${key}" has dtype ${m.descr}, expected floats`);
+}
+
+// src/lib/motion/core27.ts
+var JOINTS = ["Hips", "Spine", "Spine1", "Spine2", "Spine3", "Neck", "Head", "RightShoulder", "RightArm", "RightForeArm", "RightHand", "RightHandEnd", "RightHandThumb1", "LeftShoulder", "LeftArm", "LeftForeArm", "LeftHand", "LeftHandEnd", "LeftHandThumb1", "RightUpLeg", "RightLeg", "RightFoot", "RightToeBase", "LeftUpLeg", "LeftLeg", "LeftFoot", "LeftToeBase"];
+var PARENTS = [-1, 0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 10, 10, 4, 13, 14, 15, 16, 16, 0, 19, 20, 21, 0, 23, 24, 25];
+var REST_OFFSETS = [[0, 0, 0], [0, 0.071, -0.0473], [0, 0.0932, -0.0164], [0, 0.0943, -82e-4], [0, 0.0947, -0], [0, 0.2485, 0.0355], [-0, 0.1282, 0.0226], [-0.032, 0.1728, 0.0533], [-0.1589, -0, 0], [-0.2954, -0, -0], [-0.2327, -0, -0], [-0.0696, -0, 0], [-0.0278, -0.0186, 0.0464], [0.032, 0.1728, 0.0533], [0.1589, -0, -0], [0.2954, 0, 0], [0.2327, -0, 0], [0.0696, 0, 0], [0.0278, -0.0186, 0.0464], [-0.0949, -0.0277, -0], [-0, -0.4121, -0], [0, -0.4561, -0], [0, -0.0585, 0.1607], [0.0949, -0.0277, 0], [-0, -0.4121, 0], [-0, -0.4561, -0], [0, -0.0585, 0.1607]];
+var REST_POSITIONS = [[0, 0, 0], [0, 0.071, -0.0473], [0, 0.1642, -0.0637], [0, 0.2585, -0.0719], [0, 0.3532, -0.0719], [0, 0.6017, -0.0364], [0, 0.7299, -0.0138], [-0.032, 0.526, -0.0186], [-0.1909, 0.526, -0.0186], [-0.4863, 0.526, -0.0186], [-0.719, 0.526, -0.0186], [-0.7886, 0.526, -0.0186], [-0.7468, 0.5074, 0.0278], [0.032, 0.526, -0.0186], [0.1909, 0.526, -0.0186], [0.4863, 0.526, -0.0186], [0.719, 0.526, -0.0186], [0.7886, 0.526, -0.0186], [0.7468, 0.5074, 0.0278], [-0.0949, -0.0277, 0], [-0.0949, -0.4398, 0], [-0.0949, -0.8959, 0], [-0.0949, -0.9544, 0.1607], [0.0949, -0.0277, 0], [0.0949, -0.4398, 0], [0.0949, -0.8959, 0], [0.0949, -0.9544, 0.1607]];
+var HIPS_REST_Y = 0.9544;
+var J = JOINTS.length;
+
+// src/lib/motion/skeleton.ts
+var ji = (name) => {
+  const i = JOINTS.indexOf(name);
+  if (i < 0) throw new Error(`unknown CoreSkeleton27 joint ${name}`);
+  return i;
+};
+function matMul(a, b) {
+  return [
+    a[0] * b[0] + a[1] * b[3] + a[2] * b[6],
+    a[0] * b[1] + a[1] * b[4] + a[2] * b[7],
+    a[0] * b[2] + a[1] * b[5] + a[2] * b[8],
+    a[3] * b[0] + a[4] * b[3] + a[5] * b[6],
+    a[3] * b[1] + a[4] * b[4] + a[5] * b[7],
+    a[3] * b[2] + a[4] * b[5] + a[5] * b[8],
+    a[6] * b[0] + a[7] * b[3] + a[8] * b[6],
+    a[6] * b[1] + a[7] * b[4] + a[8] * b[7],
+    a[6] * b[2] + a[7] * b[5] + a[8] * b[8]
+  ];
+}
+function matVec(m, v) {
+  return [
+    m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
+    m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
+    m[6] * v[0] + m[7] * v[1] + m[8] * v[2]
+  ];
+}
+function matT(m) {
+  return [m[0], m[3], m[6], m[1], m[4], m[7], m[2], m[5], m[8]];
+}
+function rotY(a) {
+  const c2 = Math.cos(a), s = Math.sin(a);
+  return [c2, 0, s, 0, 1, 0, -s, 0, c2];
+}
+function rotAxis(axis, angle) {
+  const [x, y, z] = [axis[0], axis[1], axis[2]];
+  const c2 = Math.cos(angle), s = Math.sin(angle), t = 1 - c2;
+  return [
+    t * x * x + c2,
+    t * x * y - s * z,
+    t * x * z + s * y,
+    t * x * y + s * z,
+    t * y * y + c2,
+    t * y * z - s * x,
+    t * x * z - s * y,
+    t * y * z + s * x,
+    t * z * z + c2
+  ];
+}
+function quatFromMat(m) {
+  const tr = m[0] + m[4] + m[8];
+  let x, y, z, w;
+  if (tr > 0) {
+    const s = Math.sqrt(tr + 1) * 2;
+    w = s / 4;
+    x = (m[7] - m[5]) / s;
+    y = (m[2] - m[6]) / s;
+    z = (m[3] - m[1]) / s;
+  } else if (m[0] > m[4] && m[0] > m[8]) {
+    const s = Math.sqrt(1 + m[0] - m[4] - m[8]) * 2;
+    w = (m[7] - m[5]) / s;
+    x = s / 4;
+    y = (m[1] + m[3]) / s;
+    z = (m[2] + m[6]) / s;
+  } else if (m[4] > m[8]) {
+    const s = Math.sqrt(1 + m[4] - m[0] - m[8]) * 2;
+    w = (m[2] - m[6]) / s;
+    x = (m[1] + m[3]) / s;
+    y = s / 4;
+    z = (m[5] + m[7]) / s;
+  } else {
+    const s = Math.sqrt(1 + m[8] - m[0] - m[4]) * 2;
+    w = (m[3] - m[1]) / s;
+    x = (m[2] + m[6]) / s;
+    y = (m[5] + m[7]) / s;
+    z = s / 4;
+  }
+  const n = Math.hypot(x, y, z, w);
+  return [x / n, y / n, z / n, w / n];
+}
+function matFromQuat(q) {
+  const [x, y, z, w] = [q[0], q[1], q[2], q[3]];
+  const n = x * x + y * y + z * z + w * w || 1;
+  const s = 2 / n;
+  const xx = x * x * s, yy = y * y * s, zz = z * z * s;
+  const xy = x * y * s, xz = x * z * s, yz = y * z * s;
+  const wx = w * x * s, wy = w * y * s, wz = w * z * s;
+  return [
+    1 - yy - zz,
+    xy - wz,
+    xz + wy,
+    xy + wz,
+    1 - xx - zz,
+    yz - wx,
+    xz - wy,
+    yz + wx,
+    1 - xx - yy
+  ];
+}
+function quatMul(a, b) {
+  const [ax, ay, az, aw] = [a[0], a[1], a[2], a[3]];
+  const [bx, by, bz, bw] = [b[0], b[1], b[2], b[3]];
+  return [
+    aw * bx + ax * bw + ay * bz - az * by,
+    aw * by - ax * bz + ay * bw + az * bx,
+    aw * bz + ax * by - ay * bx + az * bw,
+    aw * bw - ax * bx - ay * by - az * bz
+  ];
+}
+var mean = (a) => {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i];
+  return a.length ? s / a.length : NaN;
+};
+function percentile(values, q) {
+  const a = Array.from(values).sort((x, y) => x - y);
+  if (a.length === 0) return NaN;
+  const pos = (a.length - 1) * q / 100;
+  const lo = Math.floor(pos), hi = Math.ceil(pos);
+  if (lo === hi) return a[lo];
+  return a[lo] * (hi - pos) + a[hi] * (pos - lo);
+}
+var median2 = (a) => percentile(a, 50);
+function std(a) {
+  const m = mean(a);
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += (a[i] - m) ** 2;
+  return Math.sqrt(a.length ? s / a.length : NaN);
+}
+function unwrap(a) {
+  const out = [a[0] ?? 0];
+  for (let i = 1; i < a.length; i++) {
+    let d = a[i] - a[i - 1];
+    d -= 2 * Math.PI * Math.round(d / (2 * Math.PI));
+    out.push(out[i - 1] + d);
+  }
+  return out;
+}
+function lstsqLinear(t, y) {
+  const n = t.length;
+  const mt = mean(t), my = mean(y);
+  let sxx = 0, sxy = 0;
+  for (let i = 0; i < n; i++) {
+    sxx += (t[i] - mt) ** 2;
+    sxy += (t[i] - mt) * (y[i] - my);
+  }
+  const slope = sxx > 0 ? sxy / sxx : 0;
+  return { slope, intercept: my - slope * mt };
+}
+function loadTake(buf) {
+  const npz = readNpz(buf);
+  const posed = floats(npz, "posed_joints");
+  const rootRaw = floats(npz, "root_positions");
+  const lm = floats(npz, "local_rot_mats");
+  const fcRaw = floats(npz, "foot_contacts");
+  const F = posed.shape[0];
+  if (lm.shape[1] !== J) throw new Error(`take has ${lm.shape[1]} joints, expected ${J}`);
+  const P = [];
+  const root = [];
+  const localMats = [];
+  const quat = [];
+  const heading = [];
+  const fc = [];
+  for (let f = 0; f < F; f++) {
+    const pf = [];
+    for (let j = 0; j < J; j++) {
+      const o = (f * J + j) * 3;
+      pf.push([posed.a[o], posed.a[o + 1], posed.a[o + 2]]);
+    }
+    P.push(pf);
+    root.push([rootRaw.a[f * 3], rootRaw.a[f * 3 + 1], rootRaw.a[f * 3 + 2]]);
+    const mf = [];
+    const qf = [];
+    for (let j = 0; j < J; j++) {
+      const o = (f * J + j) * 9;
+      const m = Array.from(lm.a.subarray(o, o + 9));
+      mf.push(m);
+      qf.push(quatFromMat(m));
+    }
+    localMats.push(mf);
+    quat.push(qf);
+    const m0 = mf[0];
+    heading.push(Math.atan2(m0[2], m0[8]));
+    fc.push([fcRaw.a[f * 4] !== 0, fcRaw.a[f * 4 + 1] !== 0, fcRaw.a[f * 4 + 2] !== 0, fcRaw.a[f * 4 + 3] !== 0]);
+  }
+  for (let j = 0; j < J; j++) {
+    for (let f = 1; f < F; f++) {
+      const a = quat[f][j], b = quat[f - 1][j];
+      if (a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3] < 0) {
+        quat[f][j] = [-a[0], -a[1], -a[2], -a[3]];
+      }
+    }
+  }
+  let gm = null;
+  if (npz.global_rot_mats) {
+    const g = floats(npz, "global_rot_mats");
+    gm = [];
+    for (let f = 0; f < F; f++) {
+      const gf = [];
+      for (let j = 0; j < J; j++) {
+        const o = (f * J + j) * 9;
+        gf.push(Array.from(g.a.subarray(o, o + 9)));
+      }
+      gm.push(gf);
+    }
+  }
+  const fpsMember = npz.fps;
+  const fps = fpsMember && typeof fpsMember.data !== "string" ? Number(fpsMember.data[0]) : 20;
+  const text = typeof npz.text?.data === "string" ? npz.text.data : "";
+  return { F, fps, text, P, root, quat, heading, fc, gm, localMats };
+}
+function fkRots(localFrame) {
+  const W = new Array(J);
+  for (let j = 0; j < J; j++) {
+    const p = PARENTS[j];
+    W[j] = p < 0 ? localFrame[j] : matMul(W[p], localFrame[j]);
+  }
+  return W;
+}
+var I_HIPS = 0;
+function charFrame(P, heading) {
+  const out = [];
+  for (let f = 0; f < P.length; f++) {
+    const rot = rotY(-heading[f]);
+    const hx = P[f][I_HIPS][0], hz = P[f][I_HIPS][2];
+    const cf = [];
+    for (let j = 0; j < J; j++) {
+      cf.push(matVec(rot, [P[f][j][0] - hx, P[f][j][1], P[f][j][2] - hz]));
+    }
+    out.push(cf);
+  }
+  return out;
+}
+function poseDist(quat, a, b) {
+  let s = 0;
+  for (let j = 0; j < J; j++) {
+    const qa = quat[a][j], qb = quat[b][j];
+    const d = Math.min(1, Math.abs(qa[0] * qb[0] + qa[1] * qb[1] + qa[2] * qb[2] + qa[3] * qb[3]));
+    s += 2 * Math.acos(d);
+  }
+  return s / J;
+}
+
+// src/lib/motion/normalize.ts
+var ARM_ROOTS = [ji("RightArm"), ji("LeftArm")];
+var I_RARM = ji("RightArm");
+var I_LARM = ji("LeftArm");
+var NECK_HEAD = [ji("Neck"), ji("Head")];
+var SPINE_IDX = ["Spine", "Spine1", "Spine2", "Spine3"].map(ji);
+var I_HIPS2 = ji("Hips");
+var I_RH = ji("RightHand");
+var I_LH = ji("LeftHand");
+var I_HEAD = ji("Head");
+var deg = Math.PI / 180;
+function deroot(quatCyc, rootCyc, fps, refHeading, targetHeading = 0) {
+  const F = rootCyc.length;
+  const ts = [], xs = [], zs = [];
+  for (let f = 0; f < F; f++) {
+    ts.push(f / fps);
+    xs.push(rootCyc[f][0]);
+    zs.push(rootCyc[f][2]);
+  }
+  const fx = lstsqLinear(ts, xs), fz = lstsqLinear(ts, zs);
+  for (let f = 0; f < F; f++) {
+    rootCyc[f][0] -= fx.intercept + fx.slope * ts[f];
+    rootCyc[f][2] -= fz.intercept + fz.slope * ts[f];
+  }
+  const theta = targetHeading - refHeading;
+  const rotM = rotY(theta);
+  const half = theta / 2;
+  const rotQ = [0, Math.sin(half), 0, Math.cos(half)];
+  for (let f = 0; f < F; f++) {
+    const r = matVec(rotM, rootCyc[f]);
+    rootCyc[f][0] = r[0];
+    rootCyc[f][2] = r[2];
+    quatCyc[f][0] = quatMul(rotQ, quatCyc[f][0]);
+  }
+  const v = matVec(rotM, [fx.slope, 0, fz.slope]);
+  const speed = Math.hypot(v[0], v[2]);
+  return { speed, dir: speed > 1e-6 ? [v[0] / speed, v[2] / speed] : [0, 0] };
+}
+function levelArms(qframe, Pf, pitchDeg) {
+  const ax = [
+    Pf[I_LARM][0] - Pf[I_RARM][0],
+    Pf[I_LARM][1] - Pf[I_RARM][1],
+    Pf[I_LARM][2] - Pf[I_RARM][2]
+  ];
+  const n = Math.hypot(...ax) + 1e-9;
+  const Rax = rotAxis([ax[0] / n, ax[1] / n, ax[2] / n], pitchDeg * deg);
+  const local = qframe.map(matFromQuat);
+  const W = fkRots(local);
+  const out = qframe.slice();
+  for (const j of ARM_ROOTS) {
+    const Wp = W[PARENTS[j]];
+    out[j] = quatFromMat(matMul(matT(Wp), matMul(Rax, matMul(Wp, local[j]))));
+  }
+  return out;
+}
+function levelHead(qframe, Pf, excessDeg) {
+  const ax = [
+    Pf[I_LARM][0] - Pf[I_RARM][0],
+    Pf[I_LARM][1] - Pf[I_RARM][1],
+    Pf[I_LARM][2] - Pf[I_RARM][2]
+  ];
+  const n = Math.hypot(...ax) + 1e-9;
+  const Rax = rotAxis([ax[0] / n, ax[1] / n, ax[2] / n], -excessDeg / 2 * deg);
+  const local = qframe.map(matFromQuat);
+  const W = fkRots(local);
+  const out = qframe.slice();
+  for (const j of NECK_HEAD) {
+    const Wp = W[PARENTS[j]];
+    out[j] = quatFromMat(matMul(matT(Wp), matMul(Rax, matMul(Wp, local[j]))));
+    local[j] = matFromQuat(out[j]);
+    W[j] = matMul(Wp, local[j]);
+  }
+  return out;
+}
+function headPitchFrames(localMats, s, e) {
+  const vals = [];
+  for (let f = s; f < e; f++) {
+    const W = fkRots(localMats[f]);
+    const fzY = W[NECK_HEAD[1]][5];
+    vals.push(Math.asin(Math.max(-1, Math.min(1, -fzY))) / deg);
+  }
+  return mean(vals);
+}
+function pitched(q, theta) {
+  const out = q.slice();
+  const half = theta / SPINE_IDX.length / 2;
+  const step = [Math.sin(half), 0, 0, Math.cos(half)];
+  for (const si of SPINE_IDX) out[si] = quatMul(step, out[si]);
+  return out;
+}
+function yawed(q, theta) {
+  const out = q.slice();
+  const half = theta / SPINE_IDX.length / 2;
+  const step = [0, Math.sin(half), 0, Math.cos(half)];
+  for (const si of SPINE_IDX) out[si] = quatMul(step, out[si]);
+  return out;
+}
+function gripLineChar(P, heading) {
+  const yaws = [], pitches = [];
+  for (let f = 0; f < P.length; f++) {
+    const rot = rotY(-heading[f]);
+    const rel = (j) => matVec(rot, [
+      P[f][j][0] - P[f][I_HIPS2][0],
+      P[f][j][1] - P[f][I_HIPS2][1],
+      P[f][j][2] - P[f][I_HIPS2][2]
+    ]);
+    const rh = rel(I_RH), lh = rel(I_LH);
+    const v = [lh[0] - rh[0], lh[1] - rh[1], lh[2] - rh[2]];
+    yaws.push(Math.atan2(v[0], Math.max(v[2], 1e-6)) / deg);
+    pitches.push(Math.atan2(v[1], Math.hypot(v[0], v[2]) + 1e-9) / deg);
+  }
+  return { yaws, pitches };
+}
+
+// src/lib/motion/verify.ts
+var I_HIPS3 = ji("Hips");
+var I_HEAD2 = ji("Head");
+var I_RSH = ji("RightShoulder");
+var I_LSH = ji("LeftShoulder");
+var I_RF = ji("RightFoot");
+var I_RT = ji("RightToeBase");
+var I_LF = ji("LeftFoot");
+var I_LT = ji("LeftToeBase");
+var I_NECK = ji("Neck");
+var I_RH2 = ji("RightHand");
+var I_LH2 = ji("LeftHand");
+var I_CHEST = ji("Spine2");
+var RAMP = 50;
+var TAIL = 10;
+var D = Math.sqrt(0.5);
+var EXPECT_DIR = {
+  // ARDY frame: +z forward, +x LEFT of the character
+  forward: [0, 1],
+  back: [0, -1],
+  "strafe-left": [1, 0],
+  "strafe-right": [-1, 0],
+  fl: [D, D],
+  fr: [-D, D],
+  bl: [D, -D],
+  br: [-D, -D]
+};
+function classify(stemRaw) {
+  const stem = stemRaw.replace(/-s\d+$/, "");
+  if (stem.includes("jump") || stem.includes("ollie") || stem.includes("trick")) {
+    return { kind: "oneshot", expect: null };
+  }
+  for (const [key, dxz] of Object.entries(EXPECT_DIR)) {
+    if (stem.endsWith(`-${key}`) || stem.includes(`-run-${key}`)) return { kind: "loco", expect: dxz };
+  }
+  if (stem.includes("-idle") || stem.includes("stance")) return { kind: "idle", expect: null };
+  if (stem.includes("push")) return { kind: "travel", expect: null };
+  return { kind: "freeform", expect: null };
+}
+function mSlip(t, w) {
+  const { P, fc, fps } = t;
+  const vals = [];
+  for (const [cA, cB, iF, iT] of [[0, 1, I_LF, I_LT], [2, 3, I_RF, I_RT]]) {
+    const s = [];
+    for (let f = w[0]; f < w[1] - 1; f++) {
+      if (!(fc[f][cA] || fc[f][cB])) continue;
+      const sp = (j) => Math.hypot(P[f + 1][j][0] - P[f][j][0], P[f + 1][j][2] - P[f][j][2]) * fps;
+      s.push(Math.min(sp(iF), sp(iT)));
+    }
+    if (s.length < 3) continue;
+    vals.push(mean(s));
+  }
+  return vals.length ? mean(vals) * 100 : null;
+}
+function mTravel(t, w) {
+  const ts = [], xs = [], zs = [];
+  for (let f = w[0]; f < w[1]; f++) {
+    ts.push(f / t.fps);
+    xs.push(t.root[f][0]);
+    zs.push(t.root[f][2]);
+  }
+  const vx = lstsqLinear(ts, xs).slope;
+  const vz = lstsqLinear(ts, zs).slope;
+  const v = matVec(rotY(-mean(t.heading.slice(w[0], w[1]))), [vx, 0, vz]);
+  const speed = Math.hypot(v[0], v[2]);
+  return { speed, dir: speed > 1e-6 ? [v[0] / speed, v[2] / speed] : null };
+}
+var mHeadingStd = (t, w) => std(unwrap(t.heading.slice(w[0], w[1]))) * 180 / Math.PI;
+function mBlade(C, w) {
+  let ss = 0, cs = 0, n = 0;
+  for (let f = w[0]; f < w[1]; f++) {
+    const shx = C[f][I_RSH][0] - C[f][I_LSH][0];
+    const shz = C[f][I_RSH][2] - C[f][I_LSH][2];
+    const ang = Math.atan2(shz, -shx);
+    ss += Math.sin(ang);
+    cs += Math.cos(ang);
+    n++;
+  }
+  return Math.abs(Math.atan2(ss / n, cs / n)) * (180 / Math.PI);
+}
+function mSpeedCv(t, w) {
+  const n = Math.max(2, Math.floor(t.fps / 2));
+  const sp = [];
+  for (let s = w[0]; s < w[1] - n; s += n) {
+    sp.push(Math.hypot(t.root[s + n][0] - t.root[s][0], t.root[s + n][2] - t.root[s][2]) / (n / t.fps));
+  }
+  return sp.length >= 3 ? std(sp) / (mean(sp) + 1e-6) : null;
+}
+function mRoughness(t, w) {
+  const F = w[1] - w[0];
+  if (F < 5) return null;
+  let accSq = 0, velSq = 0, n = 0;
+  for (let f = w[0] + 1; f < w[1] - 1; f++) {
+    for (let j = 0; j < t.P[f].length; j++) {
+      for (let k = 0; k < 3; k++) {
+        const a = t.P[f + 1][j][k] - 2 * t.P[f][j][k] + t.P[f - 1][j][k];
+        const v = (t.P[f + 1][j][k] - t.P[f - 1][j][k]) / 2;
+        accSq += a * a;
+        velSq += v * v;
+        n++;
+      }
+    }
+  }
+  const velRms = Math.max(Math.sqrt(velSq / n), 6e-3);
+  return Math.sqrt(accSq / n) / velRms;
+}
+function mHeadyaw(t, w) {
+  if (!t.gm) return null;
+  let ss = 0, cs = 0, n = 0;
+  for (let f = w[0]; f < w[1]; f++) {
+    const yawOf = (idx) => {
+      const m = t.gm[f][idx];
+      return Math.atan2(m[2], m[8]) * 180 / Math.PI;
+    };
+    const dDeg = ((yawOf(I_HEAD2) - yawOf(I_HIPS3) + 180) % 360 + 360) % 360 - 180;
+    const d = dDeg * Math.PI / 180;
+    ss += Math.sin(d);
+    cs += Math.cos(d);
+    n++;
+  }
+  return Math.abs(Math.atan2(ss / n, cs / n) * 180 / Math.PI);
+}
+function mHeadpitch(t, w) {
+  if (!t.gm) return null;
+  let s = 0, n = 0;
+  for (let f = w[0]; f < w[1]; f++) {
+    s += t.gm[f][I_HEAD2][5];
+    n++;
+  }
+  const v = Math.max(-1, Math.min(1, -(s / n)));
+  return Math.asin(v) * 180 / Math.PI;
+}
+function mGround(t, w) {
+  const feet = [I_LF, I_LT, I_RF, I_RT];
+  let minAll = Infinity;
+  const minOn = [];
+  for (let f = w[0]; f < w[1]; f++) {
+    let mn = Infinity;
+    for (const j of feet) mn = Math.min(mn, t.P[f][j][1]);
+    minAll = Math.min(minAll, mn);
+    if (t.fc[f].some(Boolean)) minOn.push(mn);
+  }
+  return {
+    pen: Math.max(0, -minAll) * 100,
+    float: minOn.length >= 3 ? median2(minOn) * 100 : null
+  };
+}
+function mHipsRatio(t, w) {
+  const ys = [];
+  for (let f = w[0]; f < w[1]; f++) if (t.fc[f].some(Boolean)) ys.push(t.P[f][I_HIPS3][1]);
+  return ys.length >= 3 ? median2(ys) / HIPS_REST_Y : null;
+}
+function mSeam(t, w, kind) {
+  if (kind === "loco" || kind === "travel") {
+    const ls = [];
+    for (let f = w[0] + 1; f < w[1]; f++) {
+      const on = (i) => t.fc[i][0] || t.fc[i][1];
+      if (on(f) && !on(f - 1)) ls.push(f);
+    }
+    let best2 = null;
+    for (let i = 0; i < ls.length - 1; i++) {
+      const s = ls[i];
+      for (const e of [ls[i + 1] - 1, ls[i + 1], ls[i + 1] + 1]) {
+        if (e <= s + 6 || e >= w[1]) continue;
+        const d = poseDist(t.quat, s, e);
+        if (best2 === null || d < best2) best2 = d;
+      }
+    }
+    return best2 === null ? null : best2 * 180 / Math.PI;
+  }
+  let best = null;
+  const [lo, hi] = w;
+  for (let s = lo; s < hi - 30; s += 2) {
+    for (let L = Math.floor(t.fps); L < Math.floor(t.fps * 3); L += 4) {
+      const e = s + L;
+      if (e >= hi) continue;
+      const d = poseDist(t.quat, s, e);
+      if (best === null || d < best) best = d;
+    }
+  }
+  return best === null ? null : best * 180 / Math.PI;
+}
+function mOneshot(t, w) {
+  let maxY = -Infinity;
+  const early = [];
+  let air = 0;
+  for (let f = w[0]; f < w[1]; f++) {
+    maxY = Math.max(maxY, t.root[f][1]);
+    if (f < w[0] + 10) early.push(t.root[f][1]);
+    if (!t.fc[f].some(Boolean)) air++;
+  }
+  return { rise: maxY - median2(early), air };
+}
+function mAimhold(C, w) {
+  const hunchF = [], dyF = [], gapF = [];
+  const yawSigned = [], pitchF = [], archF = [];
+  const fwdSrc = [];
+  const handFwd = [], rhClear = [];
+  for (let f = w[0]; f < w[1]; f++) {
+    const up = [
+      C[f][I_HEAD2][0] - C[f][I_HIPS3][0],
+      C[f][I_HEAD2][1] - C[f][I_HIPS3][1],
+      C[f][I_HEAD2][2] - C[f][I_HIPS3][2]
+    ];
+    const upN = Math.hypot(...up) + 1e-9;
+    hunchF.push(Math.acos(Math.max(-1, Math.min(1, up[1] / upN))) * 180 / Math.PI);
+    const rh = C[f][I_RH2], lh = C[f][I_LH2];
+    dyF.push(0.5 * (rh[1] + lh[1]) - C[f][I_HEAD2][1]);
+    handFwd.push(0.5 * (rh[2] + lh[2]));
+    const a = C[f][I_HIPS3], b = C[f][I_NECK], p = rh;
+    const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+    const tt = Math.max(0, Math.min(
+      1,
+      ((p[0] - a[0]) * ab[0] + (p[1] - a[1]) * ab[1] + (p[2] - a[2]) * ab[2]) / (ab[0] ** 2 + ab[1] ** 2 + ab[2] ** 2 + 1e-9)
+    ));
+    rhClear.push(Math.hypot(p[0] - (a[0] + tt * ab[0]), p[1] - (a[1] + tt * ab[1]), p[2] - (a[2] + tt * ab[2])));
+    const v = [lh[0] - rh[0], lh[1] - rh[1], lh[2] - rh[2]];
+    const L = Math.hypot(...v);
+    gapF.push(L);
+    fwdSrc.push({ v, L });
+    yawSigned.push(Math.atan2(v[0], Math.max(v[2], 1e-6)) * 180 / Math.PI);
+    pitchF.push(Math.atan2(v[1], Math.hypot(v[0], v[2]) + 1e-9) * 180 / Math.PI);
+    const c2 = C[f][I_CHEST], h2 = C[f][I_HEAD2];
+    const ab2 = [h2[0] - a[0], h2[1] - a[1], h2[2] - a[2]];
+    const t2 = ((c2[0] - a[0]) * ab2[0] + (c2[1] - a[1]) * ab2[1] + (c2[2] - a[2]) * ab2[2]) / (ab2[0] ** 2 + ab2[1] ** 2 + ab2[2] ** 2 + 1e-9);
+    archF.push(c2[2] - (a[2] + t2 * ab2[2]));
+  }
+  const yawMed = median2(yawSigned);
+  const dev = yawSigned.map((y) => Math.abs(y - yawMed));
+  const r = yawMed * Math.PI / 180;
+  const axis = [Math.sin(r), 0, Math.cos(r)];
+  const fwdF = fwdSrc.map(({ v, L }) => (v[0] * axis[0] + v[1] * axis[1] + v[2] * axis[2]) / (L + 1e-9));
+  let run2 = 0, best = 0;
+  for (let i = 0; i < fwdF.length; i++) {
+    const ok = dev[i] < 15 && dyF[i] < -0.22 && gapF[i] > 0.18 && gapF[i] < 0.46 && fwdF[i] > 0.75 && hunchF[i] < 16;
+    run2 = ok ? run2 + 1 : 0;
+    best = Math.max(best, run2);
+  }
+  let holdBest = 0, holdBestScore = -Infinity;
+  for (let i = 0; i < fwdF.length; i++) {
+    const s = fwdF[i] - dev[i] / 45 - Math.abs(gapF[i] - 0.32);
+    if (s > holdBestScore) {
+      holdBestScore = s;
+      holdBest = i;
+    }
+  }
+  return {
+    hunch_deg: percentile(hunchF, 90),
+    hand_dy_m: mean(dyF),
+    hand_fwd_m: mean(handFwd),
+    rh_clear_m: mean(rhClear),
+    hand_gap_m: percentile(gapF, 90),
+    line_fwd: mean(fwdF),
+    line_yaw_deg: percentile(dev, 90),
+    line_yaw_med_deg: yawMed,
+    line_pitch_deg: median2(pitchF),
+    arch_m: median2(archF),
+    hold_run: best,
+    hold_best_f: holdBest + w[0]
+  };
+}
+var DEFAULT_GATES = {
+  pass: 70,
+  warn: 50,
+  common: {
+    slip: { w: 3, good: 12, bad: 45 },
+    rough: { w: 2, good: 0.4, bad: 0.8 },
+    pen: { w: 1, good: 1.5, bad: 8 },
+    float: { w: 1, good: 4, bad: 12 },
+    headyaw: { w: 2, good: 15, bad: 45 }
+  },
+  aim: {
+    hunch: { w: 3, good: 10, bad: 18 },
+    handhigh: { w: 2, good: -0.32, bad: -0.22 },
+    handfwd: { w: 2, good: 0.3, bad: 0.12, invert: true },
+    handclear: { w: 2, good: 0.16, bad: 0.07, invert: true },
+    twohand: { w: 3, good: 0.35, bad: 0.48 },
+    lineFwd: { w: 3, good: 0.88, bad: 0.75, invert: true },
+    lineYaw: { w: 3, good: 8, bad: 18 },
+    lineMed: { w: 2, good: 45, bad: 65 },
+    holdRun: { w: 3, good: 15, bad: 6, invert: true },
+    linePitch: { w: 2, good: 8, bad: 22 },
+    arch: { w: 1, good: -0.1, bad: -0.16, invert: true },
+    headDown: { w: 2, good: 15, bad: 30 },
+    tiptoe: { w: 1, good: 1.03, bad: 1.07 }
+  },
+  loco: {
+    dir: { w: 3, good: 0.92, bad: 0.6, invert: true },
+    headstd: { w: 1, good: 8, bad: 30 },
+    blade: { w: 2, good: 28, bad: 60 },
+    speedcv: { w: 1, good: 0.18, bad: 0.5 },
+    seam: { w: 2, good: 6, bad: 20 },
+    hips: { w: 1, good: 0.82, bad: 0.55, invert: true }
+  },
+  idle: {
+    still: { w: 2, good: 0.06, bad: 0.35 },
+    blade: { w: 1, good: 30, bad: 65 },
+    seam: { w: 2, good: 6, bad: 20 },
+    hips: { w: 2, good: 0.82, bad: 0.55, invert: true }
+  },
+  oneshot: {
+    hips: { w: 1, good: 0.8, bad: 0.5, invert: true }
+  },
+  freeform: {
+    seam: { w: 1, good: 8, bad: 25 }
+  }
+};
+function soft(x, good, bad, invert = false) {
+  if (x === null || x === void 0) return null;
+  if (invert) {
+    x = -x;
+    const g = -good, b = -bad;
+    good = g;
+    bad = b;
+  }
+  return Math.max(0, Math.min(1, (bad - x) / (bad - good)));
+}
+var WHY = {
+  slip: { fmt: (v) => `${v.toFixed(0)} cm/s`, why: "feet skate during stance" },
+  rough: { fmt: (v) => v.toFixed(2), why: "jittery motion" },
+  pen: { fmt: (v) => `${v.toFixed(1)} cm`, why: "feet clip the floor" },
+  float: { fmt: (v) => `${v.toFixed(1)} cm`, why: "floats above the floor" },
+  headyaw: { fmt: (v) => `${v.toFixed(0)}\xB0`, why: "head/body twisted \u2014 bladed stance" },
+  hunch: { fmt: (v) => `${v.toFixed(0)}\xB0`, why: "hunched marksman crouch" },
+  handhigh: { fmt: (v) => `${v.toFixed(2)} m`, why: "hands at face height (cheek weld)" },
+  handfwd: { fmt: (v) => `${v.toFixed(2)} m`, why: "weapon held tight to the chest" },
+  handclear: { fmt: (v) => `${v.toFixed(2)} m`, why: "trigger hand hugs the torso" },
+  twohand: { fmt: (v) => `${v.toFixed(2)} m`, why: "support hand off the weapon (one-handed hold)" },
+  lineFwd: { fmt: (v) => v.toFixed(2), why: "support hand off the take's own barrel axis" },
+  lineYaw: { fmt: (v) => `${v.toFixed(0)}\xB0`, why: "grip line wanders \u2014 no stable barrel axis" },
+  lineMed: { fmt: (v) => `${v.toFixed(0)}\xB0`, why: "median line beyond bladed-stance range (cross-chest carry)" },
+  holdRun: { fmt: (v) => `${v.toFixed(0)}f`, why: "no sustained clean hold segment to pluck/loop" },
+  linePitch: { fmt: (v) => `${v.toFixed(0)}\xB0`, why: "grip line slopes up/down \u2014 barrel not level" },
+  arch: { fmt: (v) => `${v.toFixed(2)} m`, why: "leaning-back spine bow (hips forward, chest behind)" },
+  headDown: { fmt: (v) => `${v.toFixed(0)}\xB0`, why: "head tilted down at the hold" },
+  tiptoe: { fmt: (v) => v.toFixed(2), why: "stands taller than rest \u2014 short-legged rigs dangle/float" },
+  dir: { fmt: (v) => v.toFixed(2), why: "doesn't travel the commanded direction" },
+  headstd: { fmt: (v) => `${v.toFixed(0)}\xB0`, why: "heading wanders" },
+  blade: { fmt: (v) => `${v.toFixed(0)}\xB0`, why: "bladed stance" },
+  speedcv: { fmt: (v) => v.toFixed(2), why: "speed surges" },
+  seam: { fmt: (v) => `${v.toFixed(1)}\xB0`, why: "no clean loop boundary" },
+  hips: { fmt: (v) => v.toFixed(2), why: "crouched/collapsed" },
+  still: { fmt: (v) => `${v.toFixed(2)} m/s`, why: "idle drifts" }
+};
+function score(kind, m, gates = DEFAULT_GATES) {
+  const subs = {};
+  const reasons = [];
+  const add = (name, band, val, whyKey = name) => {
+    if (!band) return;
+    const s = soft(val ?? null, band.good, band.bad, band.invert);
+    if (s === null) return;
+    subs[name] = [s, band.w];
+    const info = WHY[whyKey];
+    if (s < 0.5 && info && val !== null && val !== void 0) {
+      reasons.push(`${name} ${info.fmt(val)} (${info.why})`);
+    }
+  };
+  const num = (k) => typeof m[k] === "number" && Number.isFinite(m[k]) ? m[k] : null;
+  add("slip", gates.common.slip, num("slip_cms"));
+  add("rough", gates.common.rough, num("roughness"));
+  add("pen", gates.common.pen, num("pen_cm"));
+  if (num("float_cm") !== null) add("float", gates.common.float, num("float_cm"));
+  if (kind !== "oneshot" && kind !== "freeform" && !m.twist_ok) {
+    add("headyaw", gates.common.headyaw, num("headyaw_deg"));
+  }
+  if (m.aim) {
+    add("hunch", gates.aim.hunch, num("hunch_deg"));
+    add("handhigh", gates.aim.handhigh, num("hand_dy_m"));
+    add("handfwd", gates.aim.handfwd, num("hand_fwd_m"));
+    add("handclear", gates.aim.handclear, num("rh_clear_m"));
+    add("twohand", gates.aim.twohand, num("hand_gap_m"));
+    add("lineFwd", gates.aim.lineFwd, num("line_fwd"));
+    add("lineYaw", gates.aim.lineYaw, num("line_yaw_deg"));
+    const lm = num("line_yaw_med_deg");
+    add("lineMed", gates.aim.lineMed, lm === null ? null : Math.abs(lm));
+    add("holdRun", gates.aim.holdRun, num("hold_run"));
+    const lp = num("line_pitch_deg");
+    add("linePitch", gates.aim.linePitch, lp === null ? null : Math.abs(lp));
+    add("arch", gates.aim.arch, num("arch_m"));
+    add("headDown", gates.aim.headDown, num("headpitch_deg"));
+    add("tiptoe", gates.aim.tiptoe, num("hips_ratio"));
+  }
+  if (kind === "loco") {
+    add("dir", gates.loco.dir, num("dir_dot"));
+    add("headstd", gates.loco.headstd, num("heading_std"));
+    add("blade", gates.loco.blade, num("blade_deg"));
+    add("speedcv", gates.loco.speedcv, num("speed_cv"));
+    add("seam", gates.loco.seam, num("seam_deg"));
+    add("hips", gates.loco.hips, num("hips_ratio"));
+  } else if (kind === "idle" || kind === "travel") {
+    if (kind === "idle") add("still", gates.idle.still, num("speed"));
+    add("blade", gates.idle.blade, num("blade_deg"));
+    add("seam", gates.idle.seam, num("seam_deg"));
+    add("hips", gates.idle.hips, num("hips_ratio"), "hips");
+  } else if (kind === "oneshot") {
+    const rise = num("rise_m") ?? 0, air = num("air_frames") ?? 0;
+    if (air >= 3 && rise < 0.12) {
+      subs.airlie = [0, 2];
+      reasons.push(`contacts say airborne x${air} but rise ${rise.toFixed(2)} m`);
+    }
+    add("hips", gates.oneshot.hips, num("hips_ratio"));
+  } else {
+    add("seam", gates.freeform.seam, num("seam_deg"));
+  }
+  let total = 0, wsum = 0;
+  for (const [s, w] of Object.values(subs)) {
+    total += s * w;
+    wsum += w;
+  }
+  const pts = wsum ? Math.round(100 * total / wsum) : 0;
+  const zeros = Object.values(subs).filter(([s]) => s === 0).map(([, w]) => w);
+  const cap = zeros.some((w) => w >= 3) || zeros.length >= 2 ? "FAIL" : zeros.length ? "WARN" : null;
+  const subscores = {};
+  for (const [k, [s]] of Object.entries(subs)) subscores[k] = Math.round(s * 100) / 100;
+  return { pts, subscores, reasons, cap };
+}
+function analyzeTake(stem, buf, gates = DEFAULT_GATES) {
+  const t = loadTake(buf);
+  const { kind, expect } = classify(stem);
+  const F = t.F;
+  const lo = kind !== "oneshot" ? Math.min(RAMP, Math.max(4, Math.floor(F / 4))) : 8;
+  const w = [lo, F - Math.min(TAIL, Math.max(2, Math.floor(F / 8)))];
+  const C = charFrame(t.P, t.heading);
+  const m = { frames: F, fps: t.fps, kind };
+  m.twist_ok = stem.startsWith("skate-");
+  m.slip_cms = mSlip(t, w);
+  m.roughness = mRoughness(t, w);
+  const g = mGround(t, w);
+  m.pen_cm = g.pen;
+  m.float_cm = g.float;
+  m.hips_ratio = mHipsRatio(t, w);
+  m.blade_deg = mBlade(C, w);
+  m.headyaw_deg = mHeadyaw(t, w);
+  m.aim = /aim|rifle|pistol/.test(stem);
+  if (m.aim) {
+    Object.assign(m, mAimhold(C, w));
+    m.headpitch_deg = mHeadpitch(t, w);
+  }
+  const travel = mTravel(t, w);
+  m.speed = travel.speed;
+  if (kind === "loco") {
+    m.dir_dot = travel.dir && expect ? travel.dir[0] * expect[0] + travel.dir[1] * expect[1] : 0;
+    m.heading_std = mHeadingStd(t, w);
+    m.speed_cv = mSpeedCv(t, w);
+  }
+  if (kind === "loco" || kind === "idle" || kind === "travel" || kind === "freeform") {
+    m.seam_deg = mSeam(t, w, kind);
+  }
+  if (kind === "oneshot") {
+    const o = mOneshot(t, w);
+    m.rise_m = o.rise;
+    m.air_frames = o.air;
+  }
+  const { pts, subscores, reasons, cap } = score(kind, m, gates);
+  let verdict = pts >= gates.pass ? "PASS" : pts >= gates.warn ? "WARN" : "FAIL";
+  if (cap === "WARN" && verdict === "PASS") verdict = "WARN";
+  else if (cap === "FAIL") verdict = "FAIL";
+  const metrics = {};
+  for (const [k, v] of Object.entries(m)) {
+    metrics[k] = typeof v === "number" ? Math.round(v * 1e3) / 1e3 : v;
+  }
+  return { take: stem, kind, score: pts, verdict, reasons, metrics, subscores, prompt: t.text.slice(0, 140) };
+}
+
+// src/lib/motion/compile.ts
+var deg2 = Math.PI / 180;
+var D2 = Math.sqrt(0.5);
+var DEFAULT_MOTION_CONFIG = {
+  rampFrames: 50,
+  tailSkip: 10,
+  idleLoop: { minFrames: 40, maxFrames: 70, step: 2 },
+  headGazeTargetDeg: 6,
+  aimPitchDeg: 40,
+  aimCandidates: 3,
+  hipsClampM: 5e-3,
+  minDirDot: 0.9
+};
+var GAIT_BY_SUFFIX = [
+  ["forward", "forward", [0, 1]],
+  ["back", "back", [0, -1]],
+  ["strafe-left", "strafeLeft", [1, 0]],
+  ["strafe-right", "strafeRight", [-1, 0]],
+  ["fl", "forwardLeft", [D2, D2]],
+  ["fr", "forwardRight", [-D2, D2]],
+  ["bl", "backLeft", [D2, -D2]],
+  ["br", "backRight", [-D2, -D2]]
+];
+var round = (v, p) => {
+  const m = 10 ** p;
+  return Math.round(v * m) / m;
+};
+function pack(quatCyc, hipsPos, contacts, fps, speed, dxz, loop = true) {
+  return {
+    fps,
+    frames: quatCyc.length,
+    speed: round(speed, 3),
+    dir: [round(dxz[0], 3), round(dxz[1], 3)],
+    loop,
+    localQuat: quatCyc.map((f) => f.map((q) => q.map((v) => round(v, 6)))),
+    hipsPos: hipsPos.map((p) => p.map((v) => round(v, 5))),
+    contacts
+  };
+}
+var folded = (t) => t.fc.map((f) => [f[0] || f[1] ? 1 : 0, f[2] || f[3] ? 1 : 0]);
+function strikes(cc, col, lo, hi) {
+  const out = [];
+  for (let f = lo + 1; f < hi; f++) if (cc[f][col] === 1 && cc[f - 1][col] === 0) out.push(f);
+  return out;
+}
+var slice2 = (a, s, e) => a.slice(s, e);
+var copyQuats = (q, s, e) => q.slice(s, e).map((f) => f.map((x) => x.slice()));
+var copyRoots = (r, s, e) => r.slice(s, e).map((v) => v.slice());
+function cutCycle(stem, t, expect, cfg) {
+  const cc = folded(t);
+  const lo = cfg.rampFrames, hi = t.F - cfg.tailSkip;
+  const ls = strikes(cc, 0, lo, hi);
+  if (ls.length < 3) {
+    throw new Error(
+      `${stem}: only ${ls.length} left-foot strikes in the steady window \u2014 the take never settles into a gait (longer --duration, or regenerate).`
+    );
+  }
+  let best = null;
+  for (let i = 0; i < ls.length - 1; i++) {
+    const s2 = ls[i];
+    for (const e2 of [ls[i + 1] - 1, ls[i + 1], ls[i + 1] + 1]) {
+      if (e2 <= s2 + 6 || e2 >= hi) continue;
+      const d = poseDist(t.quat, s2, e2);
+      if (!best || d < best[0]) best = [d, s2, e2];
+    }
+  }
+  if (!best) throw new Error(`${stem}: no valid strike pair for a loop cycle.`);
+  const [seam, s, e] = best;
+  const qc = copyQuats(t.quat, s, e);
+  const rc = copyRoots(t.root, s, e);
+  const { speed, dir } = deroot(qc, rc, t.fps, mean(t.heading.slice(s, e)));
+  const dot = dir[0] * expect[0] + dir[1] * expect[1];
+  if (dot <= cfg.minDirDot) {
+    throw new Error(
+      `${stem}: cycle travels (${dir[0].toFixed(2)}, ${dir[1].toFixed(2)}) vs expected (${expect[0].toFixed(2)}, ${expect[1].toFixed(2)}) \u2014 wrong direction; check the constraint/prompt.`
+    );
+  }
+  return { track: pack(qc, rc, slice2(cc, s, e), t.fps, speed, dir), seamDeg: seam / deg2 };
+}
+function bestLoop(t, cfg) {
+  const lo = 10, hi = t.F - 5;
+  let best = null;
+  for (let s = lo; s < hi - cfg.idleLoop.minFrames; s++) {
+    for (let L = cfg.idleLoop.minFrames; L <= cfg.idleLoop.maxFrames; L += cfg.idleLoop.step) {
+      const e = s + L;
+      if (e >= hi) continue;
+      const d = poseDist(t.quat, s, e);
+      if (!best || d < best[0]) best = [d, s, e];
+    }
+  }
+  if (!best) throw new Error("take too short for an idle loop window");
+  return { seam: best[0], s: best[1], e: best[2] };
+}
+function compileIdle(stem, t, aim, cfg) {
+  const log = [];
+  const { seam, s, e } = bestLoop(t, cfg);
+  const qc = copyQuats(t.quat, s, e);
+  const rc = copyRoots(t.root, s, e);
+  const cc = folded(t);
+  if (!aim) {
+    deroot(qc, rc, t.fps, mean(t.heading.slice(s, e)));
+    return { track: pack(qc, rc, slice2(cc, s, e), t.fps, 0, [0, 0]), seamDeg: seam / deg2, log };
+  }
+  const { yaws, pitches } = gripLineChar(t.P, t.heading);
+  const yawMed = median2(yaws.slice(s, e));
+  const pitchMed = median2(pitches.slice(s, e));
+  const headExcess = headPitchFrames(t.localMats, s, e) - cfg.headGazeTargetDeg;
+  log.push(
+    `idle root-yaw ${(-yawMed).toFixed(1)}\xB0 (whole body blades) \xB7 arm-level ${(-pitchMed).toFixed(1)}\xB0 \xB7 head-raise ${Math.max(0, headExcess).toFixed(1)}\xB0`
+  );
+  for (let f = 0; f < qc.length; f++) {
+    qc[f] = levelArms(qc[f], t.P[s + f], pitchMed);
+    if (headExcess > 0) qc[f] = levelHead(qc[f], t.P[s + f], headExcess);
+  }
+  deroot(qc, rc, t.fps, mean(t.heading.slice(s, e)) + yawMed * deg2);
+  const over = mean(rc.map((r) => r[1])) - HIPS_REST_Y;
+  if (over > cfg.hipsClampM) {
+    log.push(`hips tall-stance clamp: -${over.toFixed(3)} m`);
+    for (const r of rc) r[1] -= over;
+  }
+  return { track: pack(qc, rc, slice2(cc, s, e), t.fps, 0, [0, 0]), seamDeg: seam / deg2, log };
+}
+function cutOneshot(t, cfg) {
+  const cc = folded(t);
+  const air = cc.map((c2) => c2[0] === 0 && c2[1] === 0);
+  let best = null;
+  let run2 = null;
+  for (let f = 0; f < air.length; f++) {
+    if (air[f]) run2 = run2 ? [run2[0], f] : [f, f];
+    else {
+      if (run2 && (!best || run2[1] - run2[0] > best[1] - best[0])) best = run2;
+      run2 = null;
+    }
+  }
+  if (run2 && (!best || run2[1] - run2[0] > best[1] - best[0])) best = run2;
+  let s, e;
+  if (best) {
+    s = best[0];
+    while (s > 8 && !air[s - 1]) s--;
+    e = Math.min(t.F - 4, Math.floor(best[1] + 0.6 * t.fps));
+  } else {
+    s = 8;
+    e = t.F - 4;
+  }
+  void cfg;
+  const qc = copyQuats(t.quat, s, e);
+  const rc = copyRoots(t.root, s, e);
+  deroot(qc, rc, t.fps, mean(t.heading.slice(s, Math.min(s + 10, e))));
+  return pack(qc, rc, slice2(cc, s, e), t.fps, 0, [0, 0], false);
+}
+function aimPoseTracks(takes, cfg) {
+  const I_HIPS4 = ji("Hips"), I_HEAD3 = ji("Head");
+  const I_RH3 = ji("RightHand"), I_LH3 = ji("LeftHand");
+  const cands = [];
+  for (const { stem, take: t } of takes) {
+    const { yaws, pitches } = gripLineChar(t.P, t.heading);
+    const lo = Math.min(cfg.rampFrames, Math.floor(t.F / 3));
+    const hiY = t.F - cfg.tailSkip;
+    const yawMed = median2(yaws.slice(lo, hiY));
+    const handVel = [];
+    for (let f = 0; f < t.F - 1; f++) {
+      const sp = (j) => Math.hypot(
+        t.P[f + 1][j][0] - t.P[f][j][0],
+        t.P[f + 1][j][1] - t.P[f][j][1],
+        t.P[f + 1][j][2] - t.P[f][j][2]
+      ) * t.fps;
+      handVel.push(Math.max(sp(I_RH3), sp(I_LH3)));
+    }
+    for (let f = lo; f < hiY; f++) {
+      const rot = rotY(-t.heading[f]);
+      const rel = (j) => matVec(rot, [
+        t.P[f][j][0] - t.P[f][I_HIPS4][0],
+        t.P[f][j][1] - t.P[f][I_HIPS4][1],
+        t.P[f][j][2] - t.P[f][I_HIPS4][2]
+      ]);
+      const rh = rel(I_RH3), lh = rel(I_LH3), head = rel(I_HEAD3), hips = rel(I_HIPS4);
+      const up = [head[0] - hips[0], head[1] - hips[1], head[2] - hips[2]];
+      const hunch = Math.acos(Math.max(-1, Math.min(1, up[1] / (Math.hypot(...up) + 1e-9)))) / deg2;
+      const v = [lh[0] - rh[0], lh[1] - rh[1], lh[2] - rh[2]];
+      const L = Math.hypot(...v);
+      if (L < 0.15) continue;
+      const yaw = Math.atan2(v[0], Math.max(v[2], 1e-6)) / deg2;
+      const ry = yawMed * deg2;
+      const fwdN = (v[0] * Math.sin(ry) + v[2] * Math.cos(ry)) / L;
+      const dy = 0.5 * (rh[1] + lh[1]) - head[1];
+      const score2 = fwdN - Math.abs(yaw - yawMed) / 30 - 4 * Math.max(0, dy + 0.25) - 2.5 * Math.abs(L - 0.32) - Math.max(0, hunch - 14) / 10 - 0.5 * Math.min(handVel[Math.min(f, handVel.length - 1)], 1);
+      cands.push({ score: score2, stem, f, take: t, yaw, pitch: pitches[f] });
+    }
+  }
+  cands.sort((a, b) => b.score - a.score);
+  const picked = [];
+  for (const c2 of cands) {
+    if (picked.some((p) => p.stem === c2.stem)) continue;
+    picked.push(c2);
+    if (picked.length === cfg.aimCandidates) break;
+  }
+  const tracks = {};
+  const log = [];
+  const PITCH = cfg.aimPitchDeg * deg2;
+  picked.forEach((c2, i) => {
+    log.push(
+      `aim${i}: ${c2.stem} frame ${c2.f}  score ${c2.score >= 0 ? "+" : ""}${c2.score.toFixed(2)}  spine-yaw ${(-c2.yaw).toFixed(1)}\xB0  arm-level ${(-c2.pitch).toFixed(1)}\xB0`
+    );
+    let q = levelArms(c2.take.quat[c2.f].map((x) => x.slice()), c2.take.P[c2.f], c2.pitch);
+    const hx = headPitchFrames(c2.take.localMats, c2.f, c2.f + 1) - cfg.headGazeTargetDeg;
+    if (hx > 0) q = levelHead(q, c2.take.P[c2.f], hx);
+    q = yawed(q, -c2.yaw * deg2);
+    const hip = [0, c2.take.P[c2.f][ji("Hips")][1], 0];
+    for (const [suffix, qv] of [["", q], ["Up", pitched(q, -PITCH)], ["Dn", pitched(q, PITCH)]]) {
+      tracks[`aim${i}${suffix}`] = pack([qv], [hip], [[0, 0]], 30, 0, [0, 0]);
+    }
+  });
+  return { tracks, log };
+}
+function compileSet(inputs, setName, cfg = DEFAULT_MOTION_CONFIG) {
+  const log = [];
+  const gaits = {};
+  const aimTakes = [];
+  for (const { stem, take } of inputs) {
+    const { kind } = classify(stem);
+    const aim = /aim|rifle|pistol/.test(stem);
+    if (aim && (kind === "idle" || kind === "freeform")) aimTakes.push({ stem, take });
+    if (kind === "loco") {
+      const hit = GAIT_BY_SUFFIX.find(
+        ([suffix]) => stem.replace(/-s\d+$/, "").endsWith(`-${suffix}`) || stem.includes(`-run-${suffix}`)
+      );
+      if (!hit) throw new Error(`${stem}: locomotion take with no recognizable direction suffix.`);
+      const { track, seamDeg } = cutCycle(stem, take, hit[2], cfg);
+      gaits[hit[1]] = track;
+      log.push(`${hit[1]}: ${track.frames} frames  speed ${track.speed} m/s  seam ${seamDeg.toFixed(1)}\xB0`);
+    } else if (kind === "idle") {
+      const { track, seamDeg, log: l } = compileIdle(stem, take, aim, cfg);
+      gaits.idle = track;
+      log.push(`idle: ${track.frames} frames  seam ${seamDeg.toFixed(1)}\xB0`, ...l);
+    } else if (kind === "oneshot") {
+      const clean2 = stem.replace(/-s\d+$/, "");
+      const name = /jump.*run|run.*jump/.test(clean2) ? "jumpRun" : /jump/.test(clean2) ? "jumpStand" : clean2.replace(/[^a-zA-Z0-9]+(.)/g, (_, ch) => ch.toUpperCase());
+      const track = cutOneshot(take, cfg);
+      gaits[name] = track;
+      log.push(`${name}: ${track.frames} frames (one-shot)`);
+    } else if (kind === "travel" || kind === "freeform") {
+      const { track, seamDeg } = compileIdle(stem, take, false, cfg);
+      const name = stem.replace(/-s\d+$/, "").replace(/[^a-zA-Z0-9]+(.)/g, (_, ch) => ch.toUpperCase());
+      gaits[name] = track;
+      log.push(`${name}: ${track.frames} frames  seam ${seamDeg.toFixed(1)}\xB0 (freeform loop)`);
+    }
+  }
+  if (aimTakes.length > 0) {
+    const { tracks, log: l } = aimPoseTracks(aimTakes, cfg);
+    Object.assign(gaits, tracks);
+    log.push(...l);
+  }
+  return {
+    data: {
+      version: 1,
+      set: setName,
+      skeleton: "core27",
+      joints: [...JOINTS],
+      parents: [...PARENTS],
+      restOffsets: REST_OFFSETS.map((o) => [...o]),
+      restPositions: REST_POSITIONS.map((o) => [...o]),
+      hipsRestY: HIPS_REST_Y,
+      gaits
+    },
+    log
+  };
+}
+
+// src/lib/motion/constraints.ts
+var FPS = 20;
+var RAMP_S = 1.5;
+var WAYPOINT_EVERY = 10;
+var FIRST_FRAME = 10;
+var D3 = Math.sqrt(0.5);
+var MOTION_DIRECTIONS = {
+  forward: [0, 1],
+  back: [0, -1],
+  "strafe-left": [1, 0],
+  "strafe-right": [-1, 0],
+  "forward-left": [D3, D3],
+  "forward-right": [-D3, D3],
+  "back-left": [D3, -D3],
+  "back-right": [-D3, -D3]
+};
+function distAt(t, speed) {
+  if (t <= RAMP_S) return 0.5 * speed * t * t / RAMP_S;
+  return 0.5 * speed * RAMP_S + speed * (t - RAMP_S);
+}
+function directionConstraint(dir, speed, durationS) {
+  const frames = [];
+  const pts = [];
+  const nFrames = Math.floor(durationS * FPS);
+  for (let f = FIRST_FRAME; f <= nFrames; f += WAYPOINT_EVERY) {
+    const t = f / FPS;
+    const d = distAt(t, speed);
+    frames.push(f);
+    pts.push([Math.round(dir[0] * d * 1e4) / 1e4, Math.round(dir[1] * d * 1e4) / 1e4]);
+  }
+  return [
+    {
+      type: "root2d",
+      frame_indices: frames,
+      root_2d: pts,
+      global_root_heading: frames.map(() => 0)
+    }
+  ];
+}
+
+// src/commands/motion.ts
+var MOTION_USAGE = `${c.bold("Options for `motion` (custom character animations \u2014 text \u2192 CoreSkeleton27 takes \u2192 compiled set)")}
+  motion gen "<prompt>"   Generate N raw motion takes + the objective verify
+                       report on the GPU service (bills per take; default 4).
+                       [--takes 1-8] [--duration 2-10 s] [--seeds 0,1,2]
+                       [--constraints file.json] [--no-wait]
+  motion verify <takes\u2026>  LOCALLY score .npz takes/dirs against the objective
+                       gates (same math the service ran \u2014 reproducible).
+                       [--gates gates.json] [--json]
+  motion compile <takes\u2026> --out src/motion/<set>.json \u2014 cut loop cycles,
+                       deroot, grip-line normalize, pack the game-ready set.
+                       Take FILENAMES drive routing (rifle-run-forward.npz,
+                       rifle-idle.npz, jump-stand.npz\u2026). [--set <name>]
+                       [--config motion.config.json]
+  motion install       Vendor the motion runtime INTO this game: retarget
+                       formulas (src/motion/rigs.js), the clip player
+                       (anim-runtime.js), and motion.config.json \u2014 files the
+                       agent then owns and can edit. [--set rifle: also drop
+                       the proven rifle starter set] [--force]
+  motion constraints   Write an ARDY root-2d constraint JSON (heading-pinned
+                       straight run) for gen. [--dir forward|back|strafe-left|
+                       strafe-right|forward-left|\u2026] [--speed 2.5] [--duration 5]
+                       [--out constraints.json]`;
+async function motionGen(opts, log) {
+  const prompt = opts.query?.trim();
+  if (!prompt) {
+    log.error(`Missing prompt. Usage: ${c.cyan('genex motion gen "<prompt>"')}`);
+    process.exitCode = 1;
+    return;
+  }
+  const generationOptions = {};
+  if (opts.takes !== void 0) generationOptions.takes = opts.takes;
+  if (opts.duration !== void 0) generationOptions.duration = opts.duration;
+  if (opts.seeds !== void 0) {
+    const seeds = opts.seeds.split(",").map((s) => Number(s.trim()));
+    if (seeds.length === 0 || seeds.length > 8 || seeds.some((s) => !Number.isInteger(s) || s < 0)) {
+      log.error(`Invalid --seeds value: ${opts.seeds} (expected 1-8 comma-separated non-negative integers).`);
+      process.exitCode = 1;
+      return;
+    }
+    generationOptions.seeds = seeds;
+  }
+  if (opts.constraintsPath !== void 0) {
+    try {
+      const raw = await fs18.readFile(opts.constraintsPath, "utf8");
+      generationOptions.constraints = JSON.parse(raw);
+    } catch {
+      log.error(`Couldn't read the --constraints JSON at ${opts.constraintsPath}.`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const genOpts = {
+    prompt,
+    generationOptions,
+    apiUrl: opts.apiUrl,
+    envPath: opts.envPath,
+    token: opts.token,
+    noWait: opts.noWait,
+    json: opts.json,
+    quiet: opts.quiet,
+    open: opts.open
+  };
+  await runGenerate("motion", genOpts);
+}
+async function expandTakes(selectors) {
+  const out = [];
+  for (const sel of selectors) {
+    const st = await fs18.stat(sel).catch(() => null);
+    if (st?.isDirectory()) {
+      const names = await fs18.readdir(sel);
+      for (const n of names.sort()) if (n.endsWith(".npz")) out.push(path18.join(sel, n));
+    } else if (st?.isFile()) {
+      out.push(sel);
+    } else {
+      throw new Error(`No such take file or directory: ${sel}`);
+    }
+  }
+  return out;
+}
+function mergeGates(base, patch) {
+  const out = structuredClone(base);
+  for (const [k, v] of Object.entries(patch)) {
+    if (k === "pass" || k === "warn") {
+      if (typeof v === "number") out[k] = v;
+    } else if (v && typeof v === "object" && k in out) {
+      const section = out[k];
+      for (const [name, band] of Object.entries(v)) {
+        if (band && typeof band === "object") {
+          section[name] = { ...section[name], ...band };
+        }
+      }
+    }
+  }
+  return out;
+}
+async function motionVerify(opts, log) {
+  const selectors = opts.selectors ?? [];
+  if (selectors.length === 0) {
+    log.error(`Missing takes. Usage: ${c.cyan("genex motion verify <take.npz\u2026|dir> [--gates gates.json] [--json]")}`);
+    process.exitCode = 1;
+    return;
+  }
+  let gates = DEFAULT_GATES;
+  if (opts.gatesPath) {
+    try {
+      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs18.readFile(opts.gatesPath, "utf8")));
+    } catch {
+      log.error(`Couldn't read the --gates JSON at ${opts.gatesPath}.`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  let files;
+  try {
+    files = await expandTakes(selectors);
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  if (files.length === 0) {
+    log.error("No .npz takes found.");
+    process.exitCode = 1;
+    return;
+  }
+  const reports = [];
+  for (const file of files) {
+    const stem = path18.basename(file).replace(/\.npz$/, "");
+    try {
+      reports.push(analyzeTake(stem, await fs18.readFile(file), gates));
+    } catch (err) {
+      reports.push({
+        take: stem,
+        kind: "?",
+        score: 0,
+        verdict: "ERROR",
+        reasons: [err instanceof Error ? err.message : String(err)],
+        metrics: {},
+        subscores: {},
+        prompt: ""
+      });
+    }
+  }
+  reports.sort((a, b) => a.score - b.score);
+  if (opts.json) {
+    writeJson(reports);
+    return;
+  }
+  const wide = Math.max(...reports.map((r) => r.take.length));
+  for (const r of reports) {
+    const why = r.reasons.length ? `  \u2014 ${r.reasons.join("; ")}` : "";
+    log.plain(`${r.verdict.padEnd(5)} ${String(r.score).padStart(3)}  ${r.take.padEnd(wide)} [${r.kind}]${why}`);
+  }
+  log.plain("");
+  log.dim("  The report is data, not a verdict on the verb \u2014 pick the takes whose motion");
+  log.dim("  reads right, then: genex motion compile <picked\u2026> --out src/motion/<set>.json");
+}
+async function motionCompile(opts, log) {
+  const selectors = opts.selectors ?? [];
+  if (selectors.length === 0 || !opts.out) {
+    log.error(`Usage: ${c.cyan("genex motion compile <take.npz\u2026|dir> --out src/motion/<set>.json [--config motion.config.json]")}`);
+    process.exitCode = 1;
+    return;
+  }
+  let cfg = DEFAULT_MOTION_CONFIG;
+  if (opts.configPath) {
+    try {
+      const patch = JSON.parse(await fs18.readFile(opts.configPath, "utf8"));
+      cfg = { ...DEFAULT_MOTION_CONFIG, ...patch, idleLoop: { ...DEFAULT_MOTION_CONFIG.idleLoop, ...patch.idleLoop } };
+    } catch {
+      log.error(`Couldn't read the --config JSON at ${opts.configPath}.`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  let files;
+  try {
+    files = await expandTakes(selectors);
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  const inputs = [];
+  for (const file of files) {
+    const stem = path18.basename(file).replace(/\.npz$/, "");
+    try {
+      inputs.push({ stem, take: loadTake(await fs18.readFile(file)) });
+    } catch (err) {
+      log.error(`${stem}: ${err instanceof Error ? err.message : String(err)}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const setName = opts.set ?? path18.basename(opts.out).replace(/\.json$/, "");
+  let result;
+  try {
+    result = compileSet(inputs, setName, cfg);
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  const trackCount = Object.keys(result.data.gaits).length;
+  if (trackCount === 0) {
+    log.error("No tracks compiled \u2014 check the take filenames (routing is by stem: rifle-run-forward, rifle-idle, jump-stand\u2026).");
+    process.exitCode = 1;
+    return;
+  }
+  await fs18.mkdir(path18.dirname(path18.resolve(opts.out)), { recursive: true });
+  const json = JSON.stringify(result.data);
+  await fs18.writeFile(opts.out, json);
+  if (opts.json) {
+    writeJson({ out: opts.out, set: setName, tracks: Object.keys(result.data.gaits), bytes: json.length });
+    return;
+  }
+  for (const line of result.log) log.dim(`  ${line}`);
+  log.success(`Wrote ${opts.out} (${(json.length / 1e3).toFixed(0)} KB, ${trackCount} tracks).`);
+  log.dim("  Play it with the vendored runtime (genex motion install) \u2014 see the genex-ai-character skill's motion reference.");
+}
+var MOTION_RUNTIME_FILES = [
+  "rigs.js",
+  "anim-runtime.js",
+  "ik.js",
+  "motion.config.json"
+];
+var MOTION_PRESETS = {
+  rifle: ["sets/rifle.json", "sets/jumps.json"]
+};
+var MOTION_DEST = path18.join("src", "motion");
+async function motionInstall(opts, log) {
+  const srcDir = path18.join(getTemplatesDir(), "motion");
+  const root = opts.cwd ?? process.cwd();
+  const preset = opts.set;
+  if (preset !== void 0 && !MOTION_PRESETS[preset]) {
+    log.error(`Unknown motion preset "${preset}". Available: ${Object.keys(MOTION_PRESETS).join(", ")}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const files = [...MOTION_RUNTIME_FILES, ...preset ? MOTION_PRESETS[preset] : []];
+  log.plain(c.bold(`genex motion install${preset ? ` --set ${preset}` : ""}`));
+  log.plain("");
+  log.step(`Vendoring the motion runtime into ${c.cyan(MOTION_DEST + path18.sep)}`);
+  let copied = 0, skipped = 0;
+  try {
+    for (const rel of files) {
+      const dest = path18.join(root, MOTION_DEST, rel);
+      const exists4 = await fs18.access(dest).then(() => true, () => false);
+      if (!opts.force && exists4) {
+        skipped++;
+        log.dim(`  skipped ${path18.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
+        continue;
+      }
+      await fs18.mkdir(path18.dirname(dest), { recursive: true });
+      await fs18.copyFile(path18.join(srcDir, rel), dest);
+      copied++;
+      log.dim(`  ${path18.join(MOTION_DEST, rel)}`);
+    }
+  } catch (err) {
+    log.error(`Copy failed: ${String(err)}`);
+    process.exitCode = 1;
+    return;
+  }
+  log.success(`Motion runtime ready (${copied} copied${skipped > 0 ? `, ${skipped} skipped` : ""}).`);
+  log.plain("");
+  log.plain(c.bold("Next steps"));
+  log.plain("  1. No new dependencies for GLB rigs (three is in the scaffold); VRM avatars also need @pixiv/three-vrm.");
+  log.plain(`  2. Read the ${c.cyan("genex-ai-character")} skill's motion reference for wiring, the prompt wording ladder, and the gen \u2192 verify \u2192 compile loop.`);
+  log.plain("  3. Wiring sketch:");
+  for (const line of [
+    `const rig = await loadRig("./assets/character.glb", set, scene); rig.computeCorrection();`,
+    `const restAnkle = captureRestAnkle(rig, scene); reanchorFeet(rig, set, scene); // BEFORE ClipSet`,
+    `const clipSet = new ClipSet(rig, set, set.gaits); const anim = new Animator(clipSet);`,
+    `groundCalibrate(rig, clipSet, scene, restAnkle); curlFingers(rig, scene); // once, at load`,
+    `anim.setLoops({ idle: 1 - mag, ...dir8Weights(x, z, mag) }, dt); maskW = aimMaskStep(maskW, { mag, grounded, pitch, dt });`,
+    `anim.setMask("aim0", maskW, pitch / 0.6); anim.update(dt); // per frame \u2014 src/motion/ is YOURS to tune`
+  ]) {
+    log.dim(`       ${line}`);
+  }
+}
+async function motionConstraints(opts, log) {
+  const dirName = opts.dir ?? "forward";
+  const dir = MOTION_DIRECTIONS[dirName];
+  if (!dir) {
+    log.error(`Unknown --dir "${dirName}". Directions: ${Object.keys(MOTION_DIRECTIONS).join(", ")}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const speed = opts.speed ?? 2.5;
+  const duration = opts.duration ?? 5;
+  if (!(speed > 0) || !(duration >= 2 && duration <= 10)) {
+    log.error("Expected --speed > 0 and --duration 2-10 seconds.");
+    process.exitCode = 1;
+    return;
+  }
+  const doc = directionConstraint(dir, speed, duration);
+  const out = opts.out ?? "constraints.json";
+  await fs18.writeFile(out, JSON.stringify(doc));
+  if (opts.json) {
+    writeJson({ out, dir: dirName, speed, duration, waypoints: doc[0].frame_indices.length });
+    return;
+  }
+  log.success(`Wrote ${out} \u2014 ${dirName} at ${speed} m/s for ${duration}s (heading pinned +Z).`);
+  log.dim(`  Use it with: ${c.cyan(`genex motion gen "<gait prompt>" --constraints ${out}`)}`);
+}
+async function runMotion(opts) {
+  const log = createLogger({ quiet: opts.quiet || opts.json });
+  switch (opts.sub?.trim()) {
+    case "gen":
+      await motionGen(opts, log);
+      return;
+    case "verify":
+      await motionVerify(opts, log);
+      return;
+    case "compile":
+      await motionCompile(opts, log);
+      return;
+    case "install":
+      await motionInstall(opts, log);
+      return;
+    case "constraints":
+      await motionConstraints(opts, log);
+      return;
+    default: {
+      const bare = createLogger({ quiet: opts.quiet });
+      bare.error(
+        opts.sub ? `Unknown motion command "${opts.sub}". Commands: gen, verify, compile, install, constraints.` : 'Missing motion command. Usage: genex motion <gen|verify|compile|install|constraints> \u2014 e.g. genex motion gen "soldier low-ready rifle idle".'
+      );
+      process.exitCode = 1;
+    }
+  }
+}
+
 // src/index.ts
 var GEN_KINDS = /* @__PURE__ */ new Set(["model", "skybox", "sfx", "music", "voice", "texture", "image", "video"]);
 var HELP = `${c.bold("genex")} \u2014 set up your project's agent workspace, authorize, and publish 3D games.
@@ -16427,6 +17964,14 @@ ${c.bold("Usage")}
                                      bind library clips via --animation. No approval
                                      ceremony, no player controller pack.
   genex animations search "<intent>" Search Meshy's animation library by gameplay intent.
+  genex motion <sub> [args]          Custom character animations from text (ARDY):
+                                     gen "<prompt>" (GPU service, bills per take) |
+                                     verify <takes\u2026> | compile <takes\u2026> --out \u2026 |
+                                     install [--set rifle] | constraints \u2014 the
+                                     local toolkit + vendored runtime the agent
+                                     owns. Catalog actions (genex animations
+                                     search) stay the first stop; motion covers
+                                     the verbs the catalog lacks.
   genex wait <id>                    Attach to a generation enqueued with --no-wait and
                                      print its asset URL(s) when it finishes. Safe to
                                      re-run \u2014 it never creates a new generation.
@@ -16578,6 +18123,8 @@ ${c.bold("Options for `controller character` / legacy `controller anims`")}
 
 ${UI_USAGE}
 
+${MOTION_USAGE}
+
 ${c.bold("Global")}
   --quiet              Reduce output.
   -h, --help           Show this help.
@@ -16626,6 +18173,10 @@ ${c.bold("Examples")}
   genex controller anims sword pistol
   genex controller touch
   genex controller networked-physics
+  genex motion gen "soldier rifle low-ready idle, fully upright, head held high" --takes 4 --no-wait
+  genex motion verify takes/ --json
+  genex motion compile takes/rifle-idle.npz takes/rifle-run-forward.npz --out src/motion/rifle.json
+  genex motion install --set rifle
 `;
 function parseArgs(argv) {
   const parsed = {
@@ -16687,7 +18238,15 @@ function parseArgs(argv) {
     "--candidate",
     "--approve-remesh",
     "--category",
-    "--limit"
+    "--limit",
+    // `genex motion` value flags.
+    "--takes",
+    "--seeds",
+    "--constraints",
+    "--gates",
+    "--config",
+    "--set",
+    "--speed"
   ]);
   let i = 0;
   while (i < argv.length) {
@@ -16814,6 +18373,12 @@ function parseArgs(argv) {
           }
         } else if (parsed.command === "creature") {
           parsed.options.name = `${parsed.options.name} ${arg}`;
+        } else if (parsed.command === "motion") {
+          if (parsed.options.name === "gen") {
+            parsed.options.query = parsed.options.query ? `${parsed.options.query} ${arg}` : arg;
+          } else {
+            (parsed.options.selectors ??= []).push(arg);
+          }
         } else if (parsed.command === "animations") {
           parsed.options.query = parsed.options.query ? `${parsed.options.query} ${arg}` : arg;
         } else {
@@ -16929,6 +18494,37 @@ function applyValueFlag(options, flag, value) {
     case "--category":
       options.category = value;
       break;
+    case "--takes": {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n < 1 || n > 8) {
+        throw new Error(`Invalid --takes value: ${value} (expected an integer 1-8)`);
+      }
+      options.takes = n;
+      break;
+    }
+    case "--seeds":
+      options.seeds = value;
+      break;
+    case "--constraints":
+      options.constraintsPath = value;
+      break;
+    case "--gates":
+      options.gatesPath = value;
+      break;
+    case "--config":
+      options.configPath = value;
+      break;
+    case "--set":
+      options.set = value;
+      break;
+    case "--speed": {
+      const n = Number(value);
+      if (!Number.isFinite(n) || n <= 0) {
+        throw new Error(`Invalid --speed value: ${value}`);
+      }
+      options.speed = n;
+      break;
+    }
     case "--limit": {
       const n = Number(value);
       if (!Number.isInteger(n) || n < 1 || n > 100) {
@@ -17155,6 +18751,9 @@ async function main() {
       case "ui":
         await runUi({ ...parsed.options, sub: parsed.options.name });
         break;
+      case "motion":
+        await runMotion({ ...parsed.options, sub: parsed.options.name });
+        break;
       case "wait":
         await runWait({ ...parsed.options, id: parsed.options.name });
         break;