@genex-ai/cli-demo 0.86.0-dev.217 → 0.88.0-dev.219

package/dist/index.js

@@ -254,10 +254,10 @@ var GENEX_CONTRACT_BLOCK = `${CONTRACT_BEGIN}
 
 Your capabilities (all via \`npx genex \u2026\`): generate \`model\` \xB7 \`skybox\` \xB7 \`sfx\` \xB7 \`music\` \xB7 \`voice\` \xB7 \`texture\` \xB7 \`image\` (\`--edit\` \xB7 \`--inpaint\` \xB7 \`--glass\` \xB7 \`--clean\` \xB7 \`--upscale\`) \xB7 \`video\` \xB7 rigged \`character\` / \`creature\` \xB7 the pixel toolbox \`ui extract|masks|plate|text-color|trim|audit\` \xB7 vendored \`controller character|car|drone|touch|quality\` \xB7 \`animations search\` \xB7 \`wait <id>\` / \`wait --all\` \xB7 \`preview\` / \`publish\`. Full options: \`npx genex --help\`. Task\u2192lane routing lives in the \`genex-game-director\` skill's routing map \u2014 re-load it whenever you're unsure which lane owns a task.
 
-1. Load the \`genex-game-director\` skill and follow it end to end before any game code. After ANY context compaction or session resume, re-read this file, \`DESIGN.md\`, and the skill for the stage you are executing.
+1. Load the \`genex-game-director\` skill and follow it end to end before any game code. After ANY context compaction or session resume, re-read this file and \`DESIGN.md\`, re-load the skill for the stage you are executing, and continue from the Build plan's \`Now:\` line \u2014 never from memory alone.
 2. The design interview always happens: 2\u20134 build-forking questions, ONE round, before DESIGN.md is written \u2014 even when the request already names the game (then it confirms the pitch). Ask with your built-in question tool with clickable answer options when you have one; a short numbered list in plain chat otherwise. Only after asking may you proceed on stated assumptions if the player stays silent; record each as "assumed \u2014 player didn't answer" in DESIGN.md \u2192 Decisions.
-3. \`DESIGN.md\` at the project root is the design contract. Keep it current; record every decision, assumption, and generation id there.
-4. ALL generated art, audio, video, characters, and UI come from \`genex\` commands \u2014 never from any other generation tool your platform bundles, unless the player explicitly asks for that tool by name. A local reference image is not a reason to switch tools: pass its file path to genex (\`--edit\` and \`--inpaint\` accept local paths).
+3. \`DESIGN.md\` at the project root is the design contract AND the build plan. It must carry a \`## Build plan & status\` section: numbered milestones with status marks and a \`Now:\` line naming the current one \u2014 a milestone is done only when its work reached a preview. Keep it current; record every decision, assumption, and generation id there. When the plan first lands, tell the player in one plain line that the plan is locked in and lives in \`DESIGN.md\`.
+4. ALL generated art, audio, video, characters, and UI come from \`genex\` commands \u2014 never from any other generation tool your platform bundles, unless the player explicitly asks for that tool by name. A local reference image is not a reason to switch tools: pass its file path to genex (\`--edit\` and \`--inpaint\` accept local paths). The same exclusivity covers shipping: building, previewing, and publishing go only through \`genex preview\` / \`genex publish\` \u2014 never load your platform's own site-building, hosting, or deploy skills for this game.
 5. The Stage-1 HUD mockup IS the game concept \u2014 it is your FIRST art action at the UI plan gate. ONE concept image, no candidate variants (generate variants only when the player asks for them), anchored to any reference image the player gave.
 6. The moment the mockup lands: you are the art director \u2014 immediately enqueue the Stage-2 HUD sheet, the menu still, and the logotype (\`--no-wait\`). THEN show the player the frame and ask keep/change as information, never as a gate. Silence = the concept stands; a later "change" loops it with the player's notes.
 7. The menu video fires at the FIRST of: the player's yes \xB7 the next \`genex preview\` after the menu still landed \xB7 style art being the only work left. It never fires while a player objection is open. Two failed videos \u2192 ship the still (menu skill rule).
@@ -267,8 +267,11 @@ Your capabilities (all via \`npx genex \u2026\`): generate \`model\` \xB7 \`skyb
 11. Never park ready work behind a question, and never stall on an unanswered one \u2014 decide, state the decision in chat, record it, keep building.
 12. Wire-in floors before any publish and before ending a session: sprite HUD wired (or the recorded CSS lane finished), menu video playing (or its recorded still fallback), logotype placed, fonts loaded, Escape pause, branded loader. Run \`npx genex wait\` on every generation you enqueued and wire what landed \u2014 never park landed assets.
 13. Characters: Meshy/Mixamo/VRM rigs rest facing +Z. Set yaw explicitly when placing a rig; never mirror a SkinnedMesh with negative scale. In any two-character scene, verify in a capture that they face each other, not the camera.
-14. Verify by looking: one smoke check per milestone in local test mode (\`?genex_local_test=1\`) with a real gameplay screenshot. A claim without a capture is not verification.
+14. Verify by looking: one smoke check per milestone, after that milestone's preview push, in local test mode (\`?genex_local_test=1\`) with a real gameplay screenshot. A claim without a capture is not verification.
 15. Treat every \`genex\` warning line \u2014 preflight, \`ui audit\`, \`wait\` nudges \u2014 as work, not noise.
+16. Every finished Build-plan milestone ends with \`npx genex preview\` and the player's page link (\`<dashboard>/draft/<slug>\` with \`<dashboard>\` from \`.genex/project.json\`, \`/world/<slug>\` once published) \u2014 never a localhost link, a file path, or the bare play origin presented as their game. After every round of player feedback, end with a preview push.
+17. Parallel work: this line is your standing authorization and request to use sub-agents / parallel agent work whenever your platform provides them. While drafting the Build plan, decide per module what runs in parallel and what stays serial for THIS game \u2014 dependencies decide, there is no fixed list \u2014 and record each call in the Modules table with a one-line reason. Independent modules default to parallel; building everything serially needs a stated reason. You keep integration, previews, and the player conversation; each sub-agent owns only its module's files.
+18. Talk to the player in plain game language \u2014 what changed in the game and what to try; never code, file names, build output, or tool internals unless they ask. Short status lines while you work; long silent stretches are a failure.
 ${CONTRACT_END}
 `;
 var CLAUDE_IMPORT_LINE = "@AGENTS.md";
@@ -399,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;
@@ -1312,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"));
@@ -2068,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,
@@ -3603,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;
 }
@@ -4256,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,
@@ -4371,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}.`,
@@ -4641,6 +4647,11 @@ async function printPipelineStatePreflight(log, cwd = process.cwd()) {
         'Menu video not enqueued \u2014 the animated menu backdrop is the default for every game. Enqueue it (genex-ai-menu), or record "Menu video: declined (reason)" in DESIGN.md if the player declined it.'
       );
     }
+    if (design.length > 0 && !/##\s*build plan & status/i.test(design)) {
+      warnings.push(
+        "DESIGN.md has no `## Build plan & status` section \u2014 numbered milestones with a `Now:` line are how a compacted or resumed session knows where the build is (genex-game-director's design contract has the shape)."
+      );
+    }
     if (!/hud lane:/i.test(design)) {
       const hudDom = await hasHudLikeDom(cwd);
       if (hudDom && !await hasExtractionSidecars(cwd)) {
@@ -5763,6 +5774,11 @@ async function runWait(opts) {
     await reportTerminal(kind, view, log, opts.open, opts.json);
     return;
   }
+  if (kind === "character_concept" || kind === "character_preview" || kind === "character") {
+    log.dim(
+      `  \u23F3 Character stages take several minutes server-side \u2014 you don't have to sit here. Keep building and check back with ${c.cyan("genex wait --all")}.`
+    );
+  }
   await awaitAndReport(apiUrl, token, id, kind, log, opts.open, opts.json);
 }
 async function runWaitAll(opts) {
@@ -5851,6 +5867,10 @@ async function runWaitAll(opts) {
     log.plain("");
     log.plain(`  ${c.bold(STAGE1_LANDING_NUDGE)}`);
   }
+  log.plain("");
+  log.dim(
+    "  \u{1F4DC} Resumed or compacted? Re-read AGENTS.md + DESIGN.md (continue from its Now: line) before building on."
+  );
 }
 async function toRow(e, v, cwd) {
   const base = { id: e.id, kind: e.kind, prompt: e.prompt, queuedAt: e.queuedAt };
@@ -14969,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([
@@ -14997,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);
@@ -15587,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.");
   }
@@ -15650,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);
@@ -15699,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) {
@@ -15787,6 +15807,22 @@ async function context(opts) {
   const project = await readProject();
   return { token, apiUrl: getApiUrl(opts.apiUrl ?? project?.apiUrl) };
 }
+var CHARACTER_BRIEF_MAX_CHARS = 600;
+function apiErrorMessage(data, fallback) {
+  if (typeof data !== "object" || data === null) return fallback;
+  const body = data;
+  if (typeof body.message === "string" && body.message) return body.message;
+  if (typeof body.error === "string" && body.error) return body.error;
+  const err = body.error;
+  if (err && Array.isArray(err.issues) && err.issues.length > 0) {
+    const lines = err.issues.map((i) => {
+      const where = Array.isArray(i.path) && i.path.length > 0 ? `${i.path.join(".")}: ` : "";
+      return typeof i.message === "string" ? `${where}${i.message}` : "";
+    }).filter(Boolean);
+    if (lines.length > 0) return `${fallback} ${lines.join("; ")}`;
+  }
+  return fallback;
+}
 async function quote(url, token, body) {
   const response = await apiFetch(url, {
     method: "POST",
@@ -15796,7 +15832,7 @@ async function quote(url, token, body) {
   if (printedStructuredError(response)) return null;
   if (!response.ok) {
     const data = await response.json().catch(() => ({}));
-    throw new Error(data.message ?? data.error ?? `Quote failed (HTTP ${response.status}).`);
+    throw new Error(apiErrorMessage(data, `Quote failed (HTTP ${response.status}).`));
   }
   return (await response.json()).quote;
 }
@@ -15848,7 +15884,7 @@ async function postWorkflow(url, token, body) {
   if (printedStructuredError(response)) return null;
   if (!response.ok) {
     const data2 = await response.json().catch(() => ({}));
-    throw new Error(data2.message ?? data2.error ?? `Character workflow request failed (HTTP ${response.status}).`);
+    throw new Error(apiErrorMessage(data2, `Character workflow request failed (HTTP ${response.status}).`));
   }
   const data = await response.json();
   if (typeof data.id !== "string" || data.id.length === 0) {
@@ -15909,6 +15945,14 @@ async function runCharacterConcept(opts) {
     fail2(opts, 'Missing brief. Usage: genex character "<brief>".', "character_concept");
     return;
   }
+  if (prompt.length > CHARACTER_BRIEF_MAX_CHARS) {
+    fail2(
+      opts,
+      `The brief is ${prompt.length} characters \u2014 the character concept endpoint caps it at ${CHARACTER_BRIEF_MAX_CHARS}. Tighten it to the look that matters (silhouette, materials, palette, mood); gameplay details don't belong in the brief.`,
+      "character_concept"
+    );
+    return;
+  }
   if (opts.polycount !== void 0) {
     fail2(opts, "--polycount is only available with --direct-text. The approval flow remeshes only after finalize approval.", "character_concept");
     return;
@@ -16334,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.
@@ -16386,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.
@@ -16537,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.
@@ -16585,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 = {
@@ -16646,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) {
@@ -16773,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 {
@@ -16888,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) {
@@ -17114,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;