honeydo 0.1.0

package/packages/lmedia/dist/index.js

@@ -0,0 +1,1594 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import * as fs5 from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { fileURLToPath } from 'url';
+import { spawn, spawnSync, execFileSync } from 'child_process';
+import * as net from 'net';
+import { setTimeout } from 'timers/promises';
+import { createHash } from 'crypto';
+
+var HERE = path.dirname(fileURLToPath(import.meta.url));
+function rootCandidate() {
+  const home = os.homedir();
+  let root = process.env.LMEDIA_RUNTIME ?? "";
+  if (!root) {
+    const link = path.join(home, ".lmedia", "runtime");
+    if (fs5.existsSync(link)) root = fs5.realpathSync(link);
+  }
+  if (!root) root = path.join(home, "ml", "lb-local-gen");
+  return root;
+}
+function pythonDriverDir() {
+  const candidates = [
+    path.resolve(HERE, "..", "python"),
+    // dist/index.js → <pkg>/python
+    path.resolve(HERE, "..", "..", "python")
+    // src/lib/runtime.ts（tsx dev）→ <pkg>/python
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(path.join(c, "sfx.py"))) return c;
+  }
+  return candidates[0];
+}
+function resolveVideoRuntime() {
+  const root = rootCandidate();
+  return {
+    root,
+    venvVideo: path.join(root, ".venv-video"),
+    pythonVideo: path.join(root, ".venv-video", "bin", "python"),
+    mmh3turbo: path.join(root, ".venv-video", "bin", "mmh3turbo"),
+    weightsDir: path.join(os.homedir(), ".cache", "mmh3turbo")
+  };
+}
+function resolveAudioRuntime() {
+  const root = rootCandidate();
+  return {
+    root,
+    pythonAudio: path.join(root, ".venv-audio", "bin", "python"),
+    pythonDir: pythonDriverDir()
+  };
+}
+function hfHubCache() {
+  if (process.env.HF_HUB_CACHE) return process.env.HF_HUB_CACHE;
+  if (process.env.HF_HOME) return path.join(process.env.HF_HOME, "hub");
+  return path.join(os.homedir(), ".cache", "huggingface", "hub");
+}
+function hfSnapshot(repo) {
+  const dir = path.join(hfHubCache(), `models--${repo.replace("/", "--")}`, "snapshots");
+  if (!fs5.existsSync(dir)) return null;
+  const snaps = fs5.readdirSync(dir).filter((s) => !s.startsWith("."));
+  return snaps.length ? path.join(dir, snaps[0]) : null;
+}
+function resolveRuntime() {
+  const root = rootCandidate();
+  if (!fs5.existsSync(root)) {
+    throw new Error(
+      `\u8FD0\u884C\u65F6\u672A\u627E\u5230: ${root}
+\u8BF7\u8BBE\u7F6E LMEDIA_RUNTIME \u6307\u5411\u672C\u5730\u751F\u6210\u6808\u76EE\u5F55\uFF08\u542B .venv/.venv-train\uFF09\uFF0C\u6216\u521B\u5EFA\u8F6F\u94FE: mkdir -p ~/.lmedia && ln -s <\u6808\u76EE\u5F55> ~/.lmedia/runtime`
+    );
+  }
+  const hf = path.join(os.homedir(), ".cache", "huggingface", "hub");
+  const snapOf = (repo) => {
+    const modelDir = path.join(hf, `models--${repo.replace("/", "--")}`);
+    const dir = path.join(modelDir, "snapshots");
+    if (!fs5.existsSync(dir)) throw new Error(`\u6A21\u578B\u672A\u4E0B\u8F7D: ${repo}\uFF08\u5148\u8FD0\u884C lmedia doctor \u5B89\u88C5\u6307\u5F15\uFF09`);
+    const snaps = fs5.readdirSync(dir);
+    if (snaps.length === 0) throw new Error(`\u6A21\u578B\u5FEB\u7167\u4E3A\u7A7A: ${repo}`);
+    const refFile = path.join(modelDir, "refs", "main");
+    if (fs5.existsSync(refFile)) {
+      const ref = fs5.readFileSync(refFile, "utf-8").trim();
+      if (snaps.includes(ref)) return path.join(dir, ref);
+    }
+    return path.join(dir, snaps[0]);
+  };
+  return {
+    root,
+    pythonGen: path.join(root, ".venv-train", "bin", "python"),
+    pythonFast: path.join(root, ".venv", "bin", "python"),
+    snapshot: snapOf("Qwen/Qwen-Image-2512"),
+    snapshotEdit: snapOf("Qwen/Qwen-Image-Edit-2511"),
+    pythonDir: pythonDriverDir()
+  };
+}
+var REGISTRY_DIR = path.join(os.homedir(), ".config", "limg");
+var REGISTRY_PATH = path.join(REGISTRY_DIR, "loras.json");
+function seed() {
+  return [];
+}
+function loadRegistry() {
+  if (!fs5.existsSync(REGISTRY_PATH)) {
+    fs5.mkdirSync(REGISTRY_DIR, { recursive: true });
+    fs5.writeFileSync(REGISTRY_PATH, JSON.stringify(seed(), null, 2));
+  }
+  return JSON.parse(fs5.readFileSync(REGISTRY_PATH, "utf-8"));
+}
+function findLora(name) {
+  return loadRegistry().find((l) => l.name === name);
+}
+function addLora(entry) {
+  const list = loadRegistry().filter((l) => l.name !== entry.name);
+  list.push(entry);
+  fs5.writeFileSync(REGISTRY_PATH, JSON.stringify(list, null, 2));
+}
+function runPython(python, script, payload, opts = {}) {
+  return new Promise((resolve7, reject) => {
+    const child = spawn(python, [script, JSON.stringify(payload)], {
+      env: { ...process.env, HF_HUB_OFFLINE: process.env.HF_HUB_OFFLINE ?? "1" }
+    });
+    let stdoutBuf = "";
+    let stderrTail = "";
+    child.stdout.on("data", (d) => {
+      const text = d.toString();
+      if (!opts.quiet) process.stderr.write(text);
+      stdoutBuf += text;
+    });
+    child.stderr.on("data", (d) => {
+      const text = d.toString();
+      if (!opts.quiet) process.stderr.write(text);
+      stderrTail = (stderrTail + text).slice(-2e3);
+    });
+    child.on("close", (code) => {
+      if (code !== 0) return reject(new Error(`python \u9000\u51FA\u7801 ${code}
+${stderrTail}`));
+      const lines = stdoutBuf.trim().split("\n").filter(Boolean);
+      const lastLine = lines[lines.length - 1] ?? "";
+      try {
+        resolve7(JSON.parse(lastLine));
+      } catch {
+        reject(new Error(`\u65E0\u6CD5\u89E3\u6790 python \u8F93\u51FA: ${lastLine}
+${stderrTail}`));
+      }
+    });
+  });
+}
+var SERVE_DIR = path.join(os.homedir(), ".lmedia", "serve");
+var sockPath = (m) => path.join(SERVE_DIR, `${m}.sock`);
+var statusPath = (m) => path.join(SERVE_DIR, `${m}.json`);
+var logPath = (m) => path.join(SERVE_DIR, `${m}.log`);
+var DEFAULT_IDLE_TIMEOUT_SEC = 1800;
+function otherMode(m) {
+  return m === "gen" ? "edit" : "gen";
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readStatus(m) {
+  try {
+    return JSON.parse(fs5.readFileSync(statusPath(m), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function requestJob(mode, payload) {
+  return new Promise((resolve7, reject) => {
+    const sock = net.connect({ path: sockPath(mode) });
+    sock.setNoDelay(true);
+    let buf = "";
+    let settled = false;
+    const fail2 = (err) => {
+      if (settled) return;
+      settled = true;
+      sock.destroy();
+      reject(err);
+    };
+    const gone = () => fail2(new Error("daemon \u8FDE\u63A5\u4E2D\u65AD\uFF08\u4EFB\u52A1\u7ED3\u679C\u672A\u77E5\uFF0C\u4E0D\u81EA\u52A8\u91CD\u8DD1\uFF1B\u4EA7\u7269\u6587\u4EF6\u53EF\u80FD\u5DF2\u843D\u76D8\uFF09"));
+    sock.setTimeout(5e3, () => {
+      if (!sock.writableEnded && buf === "") {
+        settled = true;
+        sock.destroy();
+        resolve7(null);
+      }
+    });
+    sock.on("connect", () => {
+      sock.setTimeout(0);
+      sock.write(`${JSON.stringify(payload)}
+`);
+    });
+    sock.on("error", (e) => {
+      if (settled) return;
+      if (e.code === "ENOENT" || e.code === "ECONNREFUSED") {
+        settled = true;
+        sock.destroy();
+        resolve7(null);
+      } else fail2(new Error(`daemon \u8FDE\u63A5\u9519\u8BEF: ${e.message}`));
+    });
+    sock.on("data", (d) => {
+      buf += d.toString();
+      let idx;
+      while ((idx = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, idx);
+        buf = buf.slice(idx + 1);
+        if (!line) continue;
+        let frame;
+        try {
+          frame = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (frame.t === "log") {
+          process.stderr.write(String(frame.line ?? "") + (String(frame.line ?? "").endsWith("\n") ? "" : "\n"));
+        } else if (frame.t === "queued") {
+          process.stderr.write(`\u6392\u961F\u4E2D\uFF08\u524D\u9762\u8FD8\u6709 ${frame.position} \u4E2A\u4EFB\u52A1\uFF09
+`);
+        } else if (frame.t === "done") {
+          settled = true;
+          sock.end();
+          if (frame.ok) resolve7(frame.result);
+          else fail2(new Error(`daemon \u4EFB\u52A1\u5931\u8D25: ${frame.error}
+${frame.tb ?? ""}`));
+        }
+      }
+    });
+    sock.on("close", () => gone());
+  });
+}
+async function pingDaemon(mode) {
+  const r = await requestJob(mode, { kind: "ping" });
+  return r ?? null;
+}
+async function spawnDaemon(mode, opts = {}) {
+  const alive = await pingDaemon(mode);
+  if (alive) return { pid: alive.pid };
+  const rt = resolveRuntime();
+  fs5.mkdirSync(SERVE_DIR, { recursive: true });
+  const idle = String(opts.idleTimeoutSec ?? DEFAULT_IDLE_TIMEOUT_SEC);
+  const args = [
+    path.join(rt.pythonDir, "serve.py"),
+    "--mode",
+    mode,
+    "--socket",
+    sockPath(mode),
+    "--status",
+    statusPath(mode),
+    "--log",
+    logPath(mode),
+    "--snapshot",
+    mode === "gen" ? rt.snapshot : rt.snapshotEdit,
+    "--idle-timeout",
+    idle
+  ];
+  const logFd = fs5.openSync(logPath(mode), "a");
+  const child = spawn(rt.pythonGen, args, {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env, HF_HUB_OFFLINE: process.env.HF_HUB_OFFLINE ?? "1" }
+  });
+  child.unref();
+  const deadline = Date.now() + 2e4;
+  while (Date.now() < deadline) {
+    if (fs5.existsSync(sockPath(mode))) return { pid: child.pid ?? -1 };
+    await setTimeout(200);
+  }
+  return null;
+}
+async function stopDaemon(mode) {
+  const st = await pingDaemon(mode);
+  if (!st) {
+    const had = fs5.existsSync(sockPath(mode)) || fs5.existsSync(statusPath(mode));
+    for (const p of [sockPath(mode), statusPath(mode)]) {
+      try {
+        fs5.rmSync(p);
+      } catch {
+      }
+    }
+    return had ? "not-running-cleaned" : "not-running";
+  }
+  try {
+    process.kill(st.pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + 15e3;
+  while (Date.now() < deadline && pidAlive(st.pid)) await setTimeout(300);
+  if (pidAlive(st.pid)) {
+    try {
+      process.kill(st.pid, "SIGKILL");
+    } catch {
+    }
+    await setTimeout(500);
+    for (const p of [sockPath(mode), statusPath(mode)]) {
+      try {
+        fs5.rmSync(p);
+      } catch {
+      }
+    }
+    return "killed";
+  }
+  return "stopped";
+}
+async function waitGpuIdle() {
+  if (process.env.LMEDIA_NO_GPU_WAIT === "1") return;
+  for (; ; ) {
+    const busy = await pingDaemon("gen") ?? await pingDaemon("edit");
+    if (!busy || !busy.busy && busy.queue === 0) return;
+    process.stderr.write(`\u7B49\u5F85 ${busy.mode} daemon \u7A7A\u95F2\uFF08GPU \u4E32\u884C\uFF1BLMEDIA_NO_GPU_WAIT=1 \u53EF\u8DF3\u8FC7\uFF09\u2026
+`);
+    await setTimeout(5e3);
+  }
+}
+function parseMode(v) {
+  if (v !== "gen" && v !== "edit") {
+    console.error("--mode \u5FC5\u987B\u662F gen \u6216 edit");
+    process.exit(2);
+  }
+  return v;
+}
+function registerStart(serve) {
+  serve.command("start").description("\u542F\u52A8\u5E38\u9A7B\u63A8\u7406 daemon\uFF08\u6A21\u578B\u52A0\u8F7D\u4E00\u6B21\uFF0C\u540E\u7EED\u4EFB\u52A1\u514D ~2min \u51B7\u52A0\u8F7D\uFF1B\u7A7A\u95F2\u81EA\u52A8\u9000\u51FA\uFF09").requiredOption("--mode <m>", "\u7BA1\u7EBF\uFF1Agen\uFF08Qwen-Image-2512\uFF09| edit\uFF08Qwen-Image-Edit-2511\uFF09").option("--idle-timeout <sec>", "\u7A7A\u95F2\u81EA\u9000\u79D2\u6570", String(DEFAULT_IDLE_TIMEOUT_SEC)).option("--wait", "\u963B\u585E\u7B49\u6A21\u578B\u52A0\u8F7D\u5B8C\u6210\uFF08\u9ED8\u8BA4\u7ACB\u5373\u8FD4\u56DE\uFF0C\u671F\u95F4\u4EFB\u52A1\u81EA\u52A8\u6392\u961F\uFF09").option("--swap", "\u53E6\u4E00\u6A21\u5F0F daemon \u5728\u8FD0\u884C\u65F6\u5148\u505C\u5B83\u518D\u542F\u52A8\uFF08\u53CC\u9A7B ~110GB \u8D85\u672C\u673A\u5185\u5B58\uFF09").action(async (opts) => {
+    const mode = parseMode(opts.mode);
+    const idleTimeoutSec = parseInt(opts.idleTimeout, 10);
+    if (!Number.isFinite(idleTimeoutSec) || idleTimeoutSec < 5) {
+      console.error("--idle-timeout \u9700 \u22655 \u79D2");
+      process.exit(2);
+    }
+    const alive = await pingDaemon(mode);
+    if (alive) {
+      console.log(`${mode} daemon \u5DF2\u5728\u8FD0\u884C\uFF08pid ${alive.pid}\uFF0C${alive.state}\uFF0Cjobs ${alive.jobs}\uFF09`);
+      return;
+    }
+    const other = await pingDaemon(otherMode(mode));
+    if (other) {
+      if (!opts.swap) {
+        console.error(
+          `\u2717 ${other.mode} daemon \u6B63\u5728\u8FD0\u884C\uFF08pid ${other.pid}\uFF09\u3002\u53CC\u7BA1\u7EBF\u9A7B\u7559 ~110GB \u8D85\u51FA 128GB \u673A\u5668\uFF1B\u786E\u8BA4\u5207\u6362\u8BF7\u52A0 --swap`
+        );
+        process.exit(1);
+      }
+      console.log(`--swap\uFF1A\u5148\u505C ${other.mode} daemon\uFF08pid ${other.pid}\uFF09\u2026`);
+      const r2 = await stopDaemon(other.mode);
+      console.log(`  \u5DF2${r2 === "killed" ? "\u5F3A\u5236\u7EC8\u6B62" : "\u505C\u6B62"}`);
+    }
+    const r = await spawnDaemon(mode, { idleTimeoutSec });
+    if (!r) {
+      console.error(`\u2717 daemon \u542F\u52A8\u5931\u8D25\uFF0820s \u5185\u672A bind socket\uFF09\u2014\u2014\u73B0\u573A\u65E5\u5FD7\uFF1Atail -50 ${logPath(mode)}`);
+      process.exit(1);
+    }
+    console.log(`\u2713 ${mode} daemon \u5DF2\u542F\u52A8\uFF08pid ${r.pid}\uFF09\uFF1B\u6A21\u578B\u52A0\u8F7D\u4E2D\uFF08~2 \u5206\u949F\uFF09\uFF0C\u671F\u95F4\u4EFB\u52A1\u81EA\u52A8\u6392\u961F`);
+    console.log(`  \u65E5\u5FD7\uFF1Atail -f ${logPath(mode)}`);
+    if (!opts.wait) return;
+    const deadline = Date.now() + 3e5;
+    while (Date.now() < deadline) {
+      const st = await pingDaemon(mode);
+      if (st?.state === "ready") {
+        console.log(`\u2713 \u5C31\u7EEA\uFF08pid ${st.pid}\uFF0Cjobs ${st.jobs}\uFF09`);
+        return;
+      }
+      await setTimeout(2e3);
+    }
+    console.error(`\u2717 5 \u5206\u949F\u672A\u5C31\u7EEA\u2014\u2014\u770B\u65E5\u5FD7\uFF1Atail -50 ${logPath(mode)}`);
+    process.exit(1);
+  });
+}
+function registerStop(serve) {
+  serve.command("stop").description("\u505C\u6B62 daemon\uFF08TERM \u2192 15s \u2192 KILL\uFF1Bbusy \u65F6\u4F1A\u4E2D\u65AD\u5F53\u524D\u4EFB\u52A1\uFF09").option("--mode <m>", "gen | edit\uFF08\u7F3A\u7701\u4E24\u6A21\u5F0F\u90FD\u5904\u7406\uFF09").action(async (opts) => {
+    const modes = opts.mode ? [parseMode(opts.mode)] : ["gen", "edit"];
+    let any = false;
+    for (const m of modes) {
+      const st = await pingDaemon(m);
+      if (st?.busy) console.error(`\u26A0\uFE0F ${m} daemon \u6B63\u5728\u8DD1\u4EFB\u52A1\uFF0Cstop \u5C06\u4E2D\u65AD\u5B83\uFF08\u5BA2\u6237\u7AEF\u4F1A\u62A5\u9519\uFF09`);
+      const r = await stopDaemon(m);
+      if (r === "stopped") {
+        console.log(`\u2713 ${m} daemon \u5DF2\u505C\u6B62`);
+        any = true;
+      } else if (r === "killed") {
+        console.log(`\u2713 ${m} daemon \u5DF2 SIGKILL \u5F3A\u5236\u7EC8\u6B62\uFF08\u6B63\u5E38 TERM \u672A\u9000\uFF09`);
+        any = true;
+      } else if (r === "not-running-cleaned") console.log(`${m} daemon \u672A\u8FD0\u884C\uFF08\u5DF2\u6E05\u7406\u6B8B\u7559 socket/status\uFF09`);
+      else console.log(`${m} daemon \u672A\u8FD0\u884C`);
+    }
+    if (!any && modes.length === 1) process.exit(1);
+  });
+}
+function registerStatus(serve) {
+  serve.command("status").description("\u67E5\u770B\u4E24\u6A21\u5F0F daemon \u72B6\u6001\uFF08\u8FD0\u884C\u4E2D / \u6B8B\u7559 / \u672A\u8FD0\u884C\uFF09").action(async () => {
+    let anyRunning = false;
+    for (const m of ["gen", "edit"]) {
+      const st = await pingDaemon(m);
+      if (st) {
+        anyRunning = true;
+        const idle = st.lastJobAt ? Math.round((Date.now() / 1e3 - st.lastJobAt) / 60) : "-";
+        console.log(
+          `\u2713 ${m}: pid ${st.pid}\uFF0C${st.state}\uFF0Cqueue ${st.queue}\uFF0Cjobs ${st.jobs}\uFF0C\u4E0A\u6B21\u4EFB\u52A1 ${idle}min \u524D`
+        );
+        continue;
+      }
+      const saved = readStatus(m);
+      if (saved) {
+        console.log(`\u2717 ${m}: \u6B8B\u7559\u72B6\u6001\uFF08pid ${saved.pid} \u5DF2\u9000\u51FA\uFF09\u2014\u2014 lmedia image serve stop --mode ${m} \u6E05\u7406`);
+      } else {
+        console.log(`\xB7 ${m}: \u672A\u8FD0\u884C\uFF08\u53EF\u9009\u52A0\u901F\uFF1Bgen/edit \u4F1A\u81EA\u52A8\u62C9\u8D77\uFF09`);
+      }
+    }
+    process.exit(anyRunning ? 0 : 1);
+  });
+}
+function registerServe(image) {
+  const serve = image.command("serve").description("\u5E38\u9A7B\u63A8\u7406 daemon\uFF08\u6A21\u578B\u52A0\u8F7D\u4E00\u6B21\uFF0C\u4EFB\u52A1\u514D\u51B7\u52A0\u8F7D\uFF1B\u7A7A\u95F2 30min \u81EA\u52A8\u9000\u51FA\uFF09");
+  registerStart(serve);
+  registerStop(serve);
+  registerStatus(serve);
+}
+
+// src/commands/image.ts
+var DEFAULT_NEG = "\u4F4E\u5206\u8FA8\u7387\uFF0C\u4F4E\u753B\u8D28\uFF0C\u80A2\u4F53\u7578\u5F62\uFF0C\u624B\u6307\u7578\u5F62\uFF0C\u753B\u9762\u8FC7\u9971\u548C\uFF0C\u8721\u50CF\u611F\uFF0C\u4EBA\u8138\u65E0\u7EC6\u8282\uFF0C\u8FC7\u5EA6\u5149\u6ED1\uFF0C\u753B\u9762\u5177\u6709AI\u611F\u3002\u6784\u56FE\u6DF7\u4E71\u3002\u6587\u5B57\u6A21\u7CCA\uFF0C\u626D\u66F2\u3002";
+function parseCache(v) {
+  if (v === void 0) return void 0;
+  return { thresh: v === true ? 0.3 : parseFloat(String(v)) };
+}
+async function runImageJob(rt, args) {
+  if (!args.noDaemon && process.env.LMEDIA_NO_DAEMON !== "1") {
+    for (const mode of args.daemonModes) {
+      const r = await requestJob(mode, { kind: args.kind, ...args.payload });
+      if (r !== null) return r;
+    }
+    if (args.kind === "gen" || args.kind === "edit") {
+      const mode = args.daemonModes[0];
+      if (!await pingDaemon(otherMode(mode))) {
+        process.stderr.write(
+          `\u27F3 \u62C9\u8D77 ${mode} daemon\uFF08\u9996\u6B21\u4EFB\u52A1\u542B ~2min \u6A21\u578B\u52A0\u8F7D\uFF1B\u7A7A\u95F2 ${DEFAULT_IDLE_TIMEOUT_SEC / 60}min \u81EA\u9000\uFF0C--no-daemon \u53EF\u7ED5\u8FC7\uFF09\u2026
+`
+        );
+        await spawnDaemon(mode);
+        const r = await requestJob(mode, { kind: args.kind, ...args.payload });
+        if (r !== null) return r;
+      }
+    }
+    await waitGpuIdle();
+  }
+  return runPython(rt.pythonGen, args.script, args.payload);
+}
+function registerGen(image) {
+  image.command("gen <prompt>").description("\u6587\u751F\u56FE\uFF1AQwen-Image-2512 bf16\uFF08\u672C\u5730\uFF0C\u96F6 API \u6210\u672C\uFF09").option("-o, --out <path>", "\u8F93\u51FA\u8DEF\u5F84", `lmedia-${Date.now()}.png`).option("--style <name>", "\u98CE\u683C LoRA \u540D\uFF08\u5982 lbwatercolor\uFF09").option("--char <name>", "\u89D2\u8272 LoRA \u540D\uFF08\u5982 pipi\uFF09").option("--style-weight <n>", "\u98CE\u683C LoRA \u6743\u91CD\uFF08\u8986\u76D6\u6CE8\u518C\u8868\u9ED8\u8BA4\uFF09").option("--char-weight <n>", "\u89D2\u8272 LoRA \u6743\u91CD\uFF08\u8986\u76D6\u6CE8\u518C\u8868\u9ED8\u8BA4\uFF09").option("--lora <name...>", "\u4EFB\u610F\u6CE8\u518C LoRA \u540D\uFF08\u53EF\u591A\u4E2A\uFF09").option("--width <px>", "\u5BBD", "1664").option("--height <px>", "\u9AD8", "928").option("--steps <n>", "\u6B65\u6570\uFF08\u9ED8\u8BA4 20\uFF1B--fast \u9ED8\u8BA4 8\uFF1B\u663E\u5F0F\u4F20\u5165\u4F18\u5148\uFF09").option("--seed <n>", "\u968F\u673A\u79CD\u5B50", "42").option("--cfg <n>", "true CFG \u5F3A\u5EA6\uFF08\u9ED8\u8BA4 4.0=\u5B98\u65B9\u914D\u65B9\uFF1B<=1 \u5173\u95ED\u5F15\u5BFC\uFF1B--fast \u9ED8\u8BA4 1.0\uFF09").option("--neg <text>", "\u8D1F\u5411\u63D0\u793A\u8BCD\uFF08\u9ED8\u8BA4\u5B98\u65B9\u4E2D\u6587\u6A21\u677F\uFF1B\u4F20\u7A7A\u4E32=\u65E0\u8D1F\u5411\uFF09").option("--fast [steps]", "Lightning \u84B8\u998F\u52A0\u901F\uFF1A\u6CE8\u5165 lightning2512 LoRA\uFF08\u9ED8\u8BA4 8 \u6B65\uFF0C\u53EF --fast 4\uFF09\uFF0Ccfg=1\uFF0C\u53EF\u4E0E --style/--char \u53E0\u52A0").option("--cache [thresh]", "TeaCache \u6B65\u7F13\u5B58\uFF08\u9608\u503C\u7F3A\u7701 0.3\uFF0C\u8D8A\u5927\u8D8A\u5FEB\u8D8A\u7CD9\uFF1B\u8D28\u91CF\u8FD1\u4F3C\u65E0\u635F\uFF09").option("--num <n>", "\u4E00\u6B21\u751F\u6210\u5F20\u6570\uFF081-4\uFF09\uFF0C\u8F93\u51FA out-1.png..out-N.png", "1").option("--upscale", "\u751F\u6210\u540E\u8D85\u5206\u5230 2730\xD71535").option("--no-daemon", "\u7ED5\u8FC7\u5E38\u9A7B daemon\uFF0C\u5F3A\u5236\u51B7\u8DEF\u5F84\uFF08\u6392\u969C\u7528\uFF09").action(async (promptIn, opts) => {
+    const rt = resolveRuntime();
+    let prompt = promptIn;
+    const loras = [];
+    const names = [opts.style, opts.char, ...opts.lora ?? []].filter(Boolean);
+    const weightOverride = {
+      [opts.style ?? ""]: opts.styleWeight ? parseFloat(opts.styleWeight) : void 0,
+      [opts.char ?? ""]: opts.charWeight ? parseFloat(opts.charWeight) : void 0
+    };
+    for (const name of names) {
+      const entry = findLora(name);
+      if (!entry) {
+        console.error(`\u672A\u6CE8\u518C\u7684 LoRA: ${name}\uFF08lmedia lora list \u67E5\u770B\uFF09`);
+        process.exit(2);
+      }
+      loras.push({ path: entry.path, scale: weightOverride[name] ?? entry.defaultWeight });
+      if (entry.trigger && !prompt.includes(entry.trigger)) {
+        prompt = `${entry.trigger}\uFF0C${prompt}`;
+      }
+    }
+    const fast = opts.fast !== void 0;
+    const num2 = parseInt(opts.num ?? "1", 10);
+    if (!Number.isFinite(num2) || num2 < 1 || num2 > 4) {
+      console.error("--num \u53D6\u503C 1-4");
+      process.exit(2);
+    }
+    const steps = opts.steps !== void 0 ? parseInt(opts.steps, 10) : fast ? opts.fast === true ? 8 : parseInt(opts.fast, 10) : 20;
+    const trueCfg = opts.cfg !== void 0 ? parseFloat(opts.cfg) : fast ? 1 : 4;
+    if (fast && !names.includes("lightning2512")) {
+      const lt = findLora("lightning2512");
+      if (!lt || !fs5.existsSync(lt.path)) {
+        console.error("--fast \u9700\u8981 lightning2512 LoRA\uFF08\u4E0B\u8F7D\u540E: lmedia lora add lightning2512 <path> --kind speed\uFF09");
+        process.exit(2);
+      }
+      loras.unshift({ path: lt.path, scale: 1 });
+    }
+    let neg;
+    if (trueCfg > 1) {
+      if (opts.neg !== void 0 && opts.neg !== "") neg = opts.neg;
+      else if (opts.neg === void 0) neg = DEFAULT_NEG;
+    }
+    const result = await runImageJob(rt, {
+      kind: "gen",
+      daemonModes: ["gen"],
+      script: path.join(rt.pythonDir, "gen.py"),
+      noDaemon: opts.daemon === false,
+      payload: {
+        prompt,
+        out: path.resolve(opts.out),
+        snapshot: rt.snapshot,
+        width: parseInt(opts.width, 10),
+        height: parseInt(opts.height, 10),
+        steps,
+        trueCfg,
+        neg,
+        num: num2,
+        seed: parseInt(opts.seed, 10),
+        loras,
+        lightningSched: fast || void 0,
+        teaCache: parseCache(opts.cache),
+        upscaleTo: opts.upscale ? [2730, 1535] : void 0
+      }
+    });
+    console.log(JSON.stringify(result, null, 2));
+  });
+}
+function registerEdit(image) {
+  image.command("edit <prompt>").description("\u53C2\u8003\u56FE\u7F16\u8F91\uFF1AQwen-Image-Edit-2511\uFF081+ \u5F20\u53C2\u8003\u56FE\u9501\u89D2\u8272/\u98CE\u683C\uFF09").requiredOption("--ref <path...>", "\u53C2\u8003\u56FE\uFF08\u53EF\u591A\u5F20\uFF09").option("-o, --out <path>", "\u8F93\u51FA\u8DEF\u5F84", `lmedia-edit-${Date.now()}.png`).option("--width <px>", "\u5BBD", "1664").option("--height <px>", "\u9AD8", "928").option("--steps <n>", "\u6B65\u6570\uFF08\u9ED8\u8BA4 20\uFF1B\u5B98\u65B9 2511 \u914D\u65B9 40\uFF0C\u8D28\u91CF\u4F18\u5148\u53EF\u4E0A\u8C03\uFF1B--fast \u9ED8\u8BA4 8\uFF1B\u663E\u5F0F\u4F20\u5165\u4F18\u5148\uFF09").option("--seed <n>", "\u968F\u673A\u79CD\u5B50", "42").option("--cfg <n>", "true CFG \u5F3A\u5EA6\uFF08\u9ED8\u8BA4 4.0=\u5B98\u65B9 Edit-2511 \u914D\u65B9\uFF1B--fast \u9ED8\u8BA4 1.0\uFF09").option("--neg <text>", '\u8D1F\u5411\u63D0\u793A\u8BCD\uFF08\u5B98\u65B9\u7F16\u8F91\u914D\u65B9\u9ED8\u8BA4 " "\uFF0C\u51E0\u4E4E\u65E0\u7EA6\u675F\uFF1Bcfg<=1 \u65F6\u4E0D\u4E0B\u53D1\uFF09').option("--fast [steps]", "Lightning \u84B8\u998F\u52A0\u901F\uFF1A\u6CE8\u5165 lightningedit2511 LoRA\uFF08\u9ED8\u8BA4 8 \u6B65\uFF0C\u53EF --fast 4\uFF09\uFF0Ccfg=1 + \u84B8\u998F\u8C03\u5EA6\u5668\uFF0C\u7EA6 1/7 \u8017\u65F6").option("--cache [thresh]", "TeaCache \u6B65\u7F13\u5B58\uFF08\u9608\u503C\u7F3A\u7701 0.3\uFF0C\u8D8A\u5927\u8D8A\u5FEB\u8D8A\u7CD9\uFF1B\u8D28\u91CF\u8FD1\u4F3C\u65E0\u635F\uFF0C\u51FA\u7248\u6863\u5019\u9009\uFF09").option("--no-daemon", "\u7ED5\u8FC7\u5E38\u9A7B daemon\uFF0C\u5F3A\u5236\u51B7\u8DEF\u5F84\uFF08\u6392\u969C\u7528\uFF09").action(async (prompt, opts) => {
+    const rt = resolveRuntime();
+    const fast = opts.fast !== void 0;
+    const fastSteps = opts.fast === true ? 8 : parseInt(opts.fast, 10);
+    const trueCfg = opts.cfg !== void 0 ? parseFloat(opts.cfg) : fast ? 1 : 4;
+    const steps = opts.steps !== void 0 ? parseInt(opts.steps, 10) : fast ? fastSteps : 20;
+    const loras = [];
+    if (fast) {
+      const wantX4 = fastSteps <= 4;
+      const lt = (wantX4 ? findLora("lightningedit2511x4") : void 0) ?? findLora("lightningedit2511");
+      if (!lt || !fs5.existsSync(lt.path)) {
+        console.error("--fast \u9700\u8981 lightningedit2511 LoRA\uFF08\u4E0B\u8F7D\u540E: lmedia lora add lightningedit2511 <path> --kind speed\uFF09");
+        process.exit(2);
+      }
+      loras.push({ path: lt.path, scale: 1 });
+    }
+    const result = await runImageJob(rt, {
+      kind: "edit",
+      daemonModes: ["edit"],
+      script: path.join(rt.pythonDir, "edit.py"),
+      noDaemon: opts.daemon === false,
+      payload: {
+        prompt,
+        out: path.resolve(opts.out),
+        snapshotEdit: rt.snapshotEdit,
+        refs: opts.ref.map((r) => path.resolve(r)),
+        width: parseInt(opts.width, 10),
+        height: parseInt(opts.height, 10),
+        steps,
+        trueCfg,
+        neg: trueCfg > 1 ? opts.neg ?? " " : void 0,
+        seed: parseInt(opts.seed, 10),
+        loras,
+        lightningSched: fast || void 0,
+        teaCache: parseCache(opts.cache)
+      }
+    });
+    console.log(JSON.stringify(result, null, 2));
+  });
+}
+function registerUpscale(image) {
+  image.command("upscale <input> <output>").description("Real-ESRGAN x2 \u8D85\u5206\uFF08MPS\uFF0C\u79D2\u7EA7\uFF09").option("--size <WxH>", "\u6700\u7EC8\u5C3A\u5BF8\uFF08\u5982 2730x1535\uFF09").option("--no-daemon", "\u7ED5\u8FC7\u5E38\u9A7B daemon\uFF0C\u5F3A\u5236\u51B7\u8DEF\u5F84\uFF08\u6392\u969C\u7528\uFF09").action(async (input, output, opts) => {
+    const rt = resolveRuntime();
+    const size = opts.size?.split("x").map((s) => parseInt(s, 10));
+    const result = await runImageJob(rt, {
+      kind: "upscale",
+      daemonModes: ["gen", "edit"],
+      // 哪种 daemon 活着搭哪个便车；都不在直接冷路径（spandrel 秒级）
+      script: path.join(rt.pythonDir, "upscale.py"),
+      noDaemon: opts.daemon === false,
+      payload: {
+        in: path.resolve(input),
+        out: path.resolve(output),
+        finalSize: size
+      }
+    });
+    console.log(JSON.stringify(result, null, 2));
+  });
+}
+function registerImage(program2) {
+  const image = program2.command("image").description("\u56FE\u50CF\u751F\u4EA7\u80FD\u529B\uFF08\u6587\u751F\u56FE/\u53C2\u8003\u56FE\u7F16\u8F91/\u8D85\u5206/\u5E38\u9A7B daemon\uFF09");
+  registerGen(image);
+  registerEdit(image);
+  registerUpscale(image);
+  registerServe(image);
+}
+function hasCommand(cmd) {
+  return spawnSync("which", [cmd], { stdio: "ignore" }).status === 0;
+}
+
+// src/commands/video.ts
+var RES_PRESETS = [
+  "256p",
+  "352p",
+  "480p",
+  "576p",
+  "704p",
+  "720p",
+  "768p",
+  "square",
+  "portrait",
+  "vertical"
+  // 竖版/方版（绘本竖页用 portrait）
+];
+function runStep(cmd, args) {
+  const r = spawnSync(cmd, args, { stdio: "inherit" });
+  if (r.status !== 0) {
+    console.error(`\u6B65\u9AA4\u5931\u8D25: ${cmd} ${args.join(" ")}\uFF08\u9000\u51FA\u7801 ${r.status}\uFF09`);
+    process.exit(1);
+  }
+}
+function patchGgufFilename(venvVideo) {
+  const libDir = path.join(venvVideo, "lib");
+  if (!fs5.existsSync(libDir)) return;
+  const pyDir = fs5.readdirSync(libDir).find((d) => d.startsWith("python"));
+  if (!pyDir) return;
+  const w = path.join(libDir, pyDir, "site-packages", "mmh3turbo", "weights.py");
+  if (!fs5.existsSync(w)) return;
+  const src = fs5.readFileSync(w, "utf8");
+  const OLD = "MiniMax-H3-Qwen3VL-32B-TextEncoder-Q2_K.gguf";
+  const NEW = "qwen3vl-32B-MiniMax-H3-Q2_K.gguf";
+  if (src.includes(OLD)) {
+    fs5.writeFileSync(w, src.replaceAll(OLD, NEW));
+    console.error(`\u5DF2\u4FEE\u8865 mmh3turbo \u4E0A\u6E38 GGUF \u6587\u4EF6\u540D\u6F02\u79FB\uFF08${OLD} \u2192 ${NEW}\uFF09`);
+  }
+}
+var MIRROR = "https://hf-mirror.com";
+var MIRROR_FILES = [
+  { repo: "yunfengwang/mmh3turbo-bundles", dest: "~/.cache/mmh3turbo/dit.bin", bytes: 20967495552 },
+  { repo: "yunfengwang/mmh3turbo-bundles", dest: "~/.cache/mmh3turbo/dit.idx" },
+  // 尺寸运行时探测
+  { repo: "yunfengwang/mmh3turbo-bundles", dest: "~/.cache/mmh3turbo/qwen3vl_4bit.safetensors", bytes: 15239339391 },
+  { repo: "realrebelai/MiniMax-H3_GGUFs", dest: "~/.cache/huggingface/hub/models--realrebelai--MiniMax-H3_GGUFs/blobs/qwen3vl-32B-MiniMax-H3-Q2_K.gguf", bytes: 8487968160 },
+  { repo: "Comfy-Org/MiniMax-H3", dest: "~/.cache/huggingface/hub/models--Comfy-Org--MiniMax-H3/blobs/minimax_h3_video_vae_fp16.safetensors", bytes: 5207808496 },
+  { repo: "Comfy-Org/MiniMax-H3", dest: "~/.cache/huggingface/hub/models--Comfy-Org--MiniMax-H3/blobs/minimax_h3_audio_vae_fp32.safetensors", bytes: 605254808 }
+];
+function remoteSize(url) {
+  const r = spawnSync("curl", ["-sIL", "--max-time", "20", url], { encoding: "utf8" });
+  const m = (r.stdout ?? "").match(/content-length:\s*(\d+)/i);
+  return m ? parseInt(m[1], 10) : 0;
+}
+function mirrorProvision() {
+  for (const f of MIRROR_FILES) {
+    const dest = f.dest.replace(/^~/, os.homedir());
+    const url = f.repo === "Comfy-Org/MiniMax-H3" ? `${MIRROR}/${f.repo}/resolve/main/vae/${path.basename(dest)}` : `${MIRROR}/${f.repo}/resolve/main/${path.basename(dest)}`;
+    fs5.mkdirSync(path.dirname(dest), { recursive: true });
+    if (fs5.existsSync(dest) && fs5.statSync(dest).size === f.bytes) {
+      console.error(`\u5DF2\u5C31\u4F4D: ${dest}`);
+      continue;
+    }
+    const expect = f.bytes ?? remoteSize(url);
+    console.error(`\u4E0B\u8F7D ${path.basename(dest)}\uFF08${(expect / 1e9).toFixed(1)} GB\uFF09\u2192 ${dest}`);
+    for (let attempt = 1; ; attempt++) {
+      const r = spawnSync(
+        "curl",
+        ["-L", "-C", "-", "--retry", "8", "--retry-delay", "3", "--connect-timeout", "20", "-o", `${dest}.part`, url],
+        { stdio: "inherit" }
+      );
+      if (r.status === 0) break;
+      if (attempt >= 5) {
+        console.error(`\u4E0B\u8F7D\u5931\u8D25\uFF08\u5DF2\u8BD5 ${attempt} \u8F6E\uFF09: ${url}`);
+        process.exit(1);
+      }
+      console.error(`\u4E0B\u8F7D\u4E2D\u65AD\uFF0C5 \u79D2\u540E\u7EED\u4F20\uFF08\u7B2C ${attempt} \u8F6E\uFF09\u2026`);
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5e3);
+    }
+    fs5.renameSync(`${dest}.part`, dest);
+    const got = fs5.statSync(dest).size;
+    if (expect && got !== expect) {
+      console.error(`\u5927\u5C0F\u6821\u9A8C\u5931\u8D25: ${dest} got=${got} expect=${expect}`);
+      process.exit(1);
+    }
+  }
+  console.log("H3 \u6743\u91CD\u955C\u50CF\u9884\u7F6E\u5B8C\u6210\uFF08~/.cache/mmh3turbo + HF blobs\uFF0Cmmh3turbo \u5168\u90E8\u672C\u5730\u547D\u4E2D\uFF0C\u4E0D\u518D\u8D70\u7F51\u7EDC\uFF09");
+}
+function registerSetup(video) {
+  video.command("setup").description("\u521B\u5EFA .venv-video \u5E76\u5B89\u88C5 mmh3turbo\uFF08MiniMax-H3 MLX \u5F15\u64CE\uFF0CApple Silicon\uFF09").option("--mirror", "\u7528 hf-mirror.com + curl \u9884\u7F6E H3 \u6743\u91CD\uFF08~50GB\uFF0C\u56FD\u5185\u63A8\u8350\uFF1Bhuggingface_hub \u5BA2\u6237\u7AEF\u4E0E\u955C\u50CF\u91CD\u5B9A\u5411\u4E0D\u517C\u5BB9\u65F6\u7684\u6B63\u89E3\uFF09").action((opts) => {
+    const rt = resolveVideoRuntime();
+    fs5.mkdirSync(rt.root, { recursive: true });
+    if (!hasCommand("ffmpeg")) {
+      console.error("\u26A0\uFE0F  \u672A\u627E\u5230 ffmpeg\uFF08mp4 \u5C01\u88C5\u5FC5\u9700\uFF09\uFF1Abrew install ffmpeg");
+    }
+    if (!fs5.existsSync(rt.pythonVideo)) {
+      console.error(`\u521B\u5EFA venv: ${rt.venvVideo}`);
+      if (hasCommand("uv")) runStep("uv", ["venv", "--python", "3.12", rt.venvVideo]);
+      else runStep("python3", ["-m", "venv", rt.venvVideo]);
+    }
+    console.error("\u5B89\u88C5/\u5347\u7EA7 mmh3turbo \u2026");
+    if (hasCommand("uv")) {
+      runStep("uv", ["pip", "install", "--python", rt.pythonVideo, "--upgrade", "mmh3turbo"]);
+    } else {
+      runStep(rt.pythonVideo, ["-m", "pip", "install", "--upgrade", "mmh3turbo"]);
+    }
+    patchGgufFilename(rt.venvVideo);
+    if (opts.mirror) {
+      mirrorProvision();
+    } else {
+      console.log(`\u89C6\u9891\u8FD0\u884C\u65F6\u5C31\u7EEA: ${rt.mmh3turbo}`);
+      console.log("\u9996\u6B21 lmedia video gen \u4F1A\u81EA\u52A8\u4E0B\u8F7D H3 \u6743\u91CD\uFF08~33GB\uFF0C\u9700\u80FD\u76F4\u8FDE huggingface.co\uFF09\uFF1B\u56FD\u5185\u63A8\u8350\u6539\u7528: lmedia video setup --mirror");
+    }
+  });
+}
+function registerGen2(video) {
+  video.command("gen <prompt>").description("\u6587\u751F\u89C6\u9891/\u9996\u5E27\u56FE\u751F\u89C6\u9891\uFF1AMiniMax-H3 \u672C\u5730\uFF08\u9ED8\u8BA4 480p / 5s / 12 \u6B65\uFF0Cmp4 \u542B\u7ACB\u4F53\u58F0\u97F3\u8F68\uFF09").option("-o, --out <path>", "\u8F93\u51FA mp4 \u8DEF\u5F84", `lmedia-video-${Date.now()}.mp4`).option("-r, --res <preset>", `\u5206\u8FA8\u7387\u6863\uFF1A${RES_PRESETS.join("|")}\uFF08lmedia video list-res \u770B\u5B9E\u9645\u753B\u5E03\uFF09`, "480p").option("--seconds <s>", "\u7247\u6BB5\u65F6\u957F\u79D2\uFF081-15\uFF09", "5").option("--steps <n>", "\u53BB\u566A\u6B65\u6570\uFF0812 \u6B65\u4E0E 20 \u6B65\u89C6\u89C9\u4E0D\u53EF\u533A\u5206\uFF0C4/8 \u6B65\u660E\u663E\u6389\u8D28\uFF09", "12").option("--seed <n>", "\u968F\u673A\u79CD\u5B50", "42").option("--first-frame <path>", "\u9996\u5E27\u56FE\uFF08\u56FE\u751F\u89C6\u9891\uFF1B\u63A8\u8350\u8854\u63A5 lmedia image gen \u4EA7\u7269\uFF09").action(async (prompt, opts) => {
+    const res = opts.res;
+    const seconds = parseFloat(opts.seconds);
+    const steps = parseInt(opts.steps, 10);
+    const seed2 = parseInt(opts.seed, 10);
+    if (!RES_PRESETS.includes(res)) {
+      console.error(`--res \u4EC5\u652F\u6301 ${RES_PRESETS.join("|")}\uFF08\u5F53\u524D ${res}\uFF09`);
+      process.exit(2);
+    }
+    if (!Number.isFinite(seconds) || seconds < 1 || seconds > 15) {
+      console.error(`--seconds \u9700\u4E3A 1-15 \u7684\u6570\u5B57\uFF08\u5F53\u524D ${opts.seconds}\uFF09`);
+      process.exit(2);
+    }
+    if (!Number.isInteger(steps) || steps < 1 || steps > 50) {
+      console.error(`--steps \u9700\u4E3A 1-50 \u7684\u6574\u6570\uFF08\u5F53\u524D ${opts.steps}\uFF09`);
+      process.exit(2);
+    }
+    if (!Number.isInteger(seed2)) {
+      console.error(`--seed \u9700\u4E3A\u6574\u6570\uFF08\u5F53\u524D ${opts.seed}\uFF09`);
+      process.exit(2);
+    }
+    if (opts.firstFrame && !fs5.existsSync(opts.firstFrame)) {
+      console.error(`\u9996\u5E27\u56FE\u4E0D\u5B58\u5728: ${opts.firstFrame}`);
+      process.exit(2);
+    }
+    const rt = resolveVideoRuntime();
+    if (!fs5.existsSync(rt.mmh3turbo)) {
+      console.error(`mmh3turbo \u672A\u5B89\u88C5\uFF08${rt.venvVideo}\uFF09\u3002\u5148\u8FD0\u884C: lmedia video setup`);
+      process.exit(1);
+    }
+    if (!hasCommand("ffmpeg")) {
+      console.error("\u672A\u627E\u5230 ffmpeg\uFF08mp4 \u5C01\u88C5\u5FC5\u9700\uFF09\uFF1Abrew install ffmpeg \u540E\u91CD\u8BD5");
+      process.exit(1);
+    }
+    if (/[一-鿿]/.test(prompt) && prompt.length < 20) {
+      console.error(`\u63D0\u793A: \u4E2D\u6587 prompt \u5EFA\u8BAE 30-50 \u5B57\uFF08\u5F53\u524D ${prompt.length} \u5B57\uFF09\uFF0C\u592A\u77ED\u6613\u88AB seed \u4E3B\u5BFC\uFF08\u6362 prompt \u753B\u9762\u4E0D\u53D8\uFF09`);
+    }
+    const runDir = path.join(os.homedir(), ".lmedia", "video-runs", `${Date.now()}`);
+    fs5.mkdirSync(runDir, { recursive: true });
+    const args = [
+      prompt,
+      "-r",
+      res,
+      "--seconds",
+      String(seconds),
+      "--steps",
+      String(steps),
+      "--seed",
+      String(seed2),
+      "-o",
+      runDir
+    ];
+    if (opts.firstFrame) args.push("--first-frame", path.resolve(opts.firstFrame));
+    console.error(`mmh3turbo \xB7 ${res} \xB7 ${seconds}s \xB7 ${steps} \u6B65 \xB7 seed ${seed2} \u2192 ${runDir}`);
+    const t0 = Date.now();
+    const env = { ...process.env };
+    const weightsReady = fs5.existsSync(path.join(rt.weightsDir, "dit.bin"));
+    if (!weightsReady && env.HF_HUB_OFFLINE === "1") {
+      console.error("\u63D0\u793A: \u68C0\u6D4B\u5230 HF_HUB_OFFLINE=1 \u4E14 H3 \u6743\u91CD\u672A\u5C31\u7EEA\uFF0C\u672C\u6B21\u4E34\u65F6\u5173\u95ED\u4EE5\u62C9\u53D6\u6743\u91CD\uFF08\u56FD\u5185\u63A8\u8350 lmedia video setup --mirror\uFF09");
+      env.HF_HUB_OFFLINE = "0";
+    }
+    const code = await new Promise((resolve7) => {
+      const child = spawn(rt.mmh3turbo, args, { env });
+      child.stdout.on("data", (d) => process.stderr.write(d));
+      child.stderr.on("data", (d) => process.stderr.write(d));
+      child.on("error", (e) => {
+        console.error(`\u542F\u52A8 mmh3turbo \u5931\u8D25: ${e.message}`);
+        process.exit(1);
+      });
+      child.on("close", (c) => resolve7(c ?? -1));
+    });
+    if (code !== 0) {
+      console.error(`mmh3turbo \u9000\u51FA\u7801 ${code}\uFF08\u8FD0\u884C\u76EE\u5F55\u4FDD\u7559\u4F9B\u6392\u67E5: ${runDir}\uFF1B\u5E38\u89C1\u539F\u56E0: \u78C1\u76D8\u7A7A\u95F4\u4E0D\u8DB3\u3001\u6743\u91CD\u4E0B\u8F7D\u4E2D\u65AD\u2014\u2014\u91CD\u8DD1\u5373\u53EF\u7EED\u4F20\uFF09`);
+      process.exit(1);
+    }
+    const produced = path.join(runDir, "video.mp4");
+    if (!fs5.existsSync(produced)) {
+      console.error(`\u672A\u627E\u5230\u4EA7\u7269 ${produced}\uFF08\u8FD0\u884C\u76EE\u5F55\u5185\u5BB9\u4FDD\u7559\u4F9B\u6392\u67E5: ${runDir}\uFF09`);
+      process.exit(1);
+    }
+    const out = path.resolve(opts.out);
+    fs5.mkdirSync(path.dirname(out), { recursive: true });
+    try {
+      fs5.renameSync(produced, out);
+    } catch {
+      fs5.copyFileSync(produced, out);
+      fs5.unlinkSync(produced);
+    }
+    console.log(
+      JSON.stringify(
+        {
+          out,
+          seconds: Number(((Date.now() - t0) / 1e3).toFixed(1)),
+          runDir,
+          engine: "mmh3turbo",
+          res,
+          duration: seconds,
+          steps,
+          seed: seed2,
+          ...opts.firstFrame ? { firstFrame: path.resolve(opts.firstFrame) } : {}
+        },
+        null,
+        2
+      )
+    );
+  });
+}
+function registerListRes(video) {
+  video.command("list-res").description("\u5217\u51FA mmh3turbo \u652F\u6301\u7684\u5206\u8FA8\u7387\u6863\u4F4D\uFF08\u900F\u4F20\uFF09").action(() => {
+    const rt = resolveVideoRuntime();
+    if (!fs5.existsSync(rt.mmh3turbo)) {
+      console.error("mmh3turbo \u672A\u5B89\u88C5\u3002\u5148\u8FD0\u884C: lmedia video setup");
+      process.exit(1);
+    }
+    const r = spawnSync(rt.mmh3turbo, ["--list-res"], { encoding: "utf8" });
+    if (r.status !== 0) {
+      console.error(`mmh3turbo --list-res \u9000\u51FA\u7801 ${r.status}`);
+      process.exit(1);
+    }
+    console.log((r.stdout ?? "").trim());
+  });
+}
+function registerVideo(program2) {
+  const video = program2.command("video").description("\u89C6\u9891\u751F\u4EA7\u80FD\u529B\uFF08\u672C\u5730 MiniMax-H3 / mmh3turbo\uFF0C\u96F6 API \u6210\u672C\uFF09");
+  registerSetup(video);
+  registerGen2(video);
+  registerListRes(video);
+}
+function registerLora(program2) {
+  const lora = program2.command("lora").description("LoRA \u6CE8\u518C\u8868\u7BA1\u7406");
+  lora.command("list").description("\u5217\u51FA\u5DF2\u6CE8\u518C LoRA").action(() => {
+    for (const l of loadRegistry()) {
+      const exists = fs5.existsSync(l.path) ? "\u2713" : "\u2717 \u6587\u4EF6\u7F3A\u5931";
+      console.log(
+        `${l.name}	[${l.kind}]	weight=${l.defaultWeight}	trigger="${l.trigger}"	${exists}
+  ${l.path}${l.note ? `
+  ${l.note}` : ""}`
+      );
+    }
+  });
+  lora.command("add <name> <path>").description("\u6CE8\u518C\u65B0 LoRA").requiredOption("--kind <kind>", "style|character|speed").option("--trigger <text>", "\u89E6\u53D1\u8BCD", "").option("--weight <n>", "\u9ED8\u8BA4\u6743\u91CD", "1.0").option("--note <text>", "\u5907\u6CE8").action(
+    (name, p, opts) => {
+      addLora({
+        name,
+        path: path.resolve(p),
+        trigger: opts.trigger,
+        defaultWeight: parseFloat(opts.weight),
+        kind: opts.kind,
+        note: opts.note
+      });
+      console.log(`\u5DF2\u6CE8\u518C ${name}`);
+    }
+  );
+}
+var ESRGAN_CACHE_PATH = path.join(os.homedir(), ".cache", "lmedia", "RealESRGAN_x2.pth");
+var LEGACY_TMP_PATH = "/tmp/RealESRGAN_x2.pth";
+function resolveEsrganPath() {
+  const env = process.env.LMEDIA_REALESRGAN_PATH;
+  if (env && fs5.existsSync(env)) return env;
+  if (fs5.existsSync(ESRGAN_CACHE_PATH)) return ESRGAN_CACHE_PATH;
+  if (fs5.existsSync(LEGACY_TMP_PATH)) return LEGACY_TMP_PATH;
+  return process.env.LMEDIA_REALESRGAN_PATH ?? ESRGAN_CACHE_PATH;
+}
+var ManifestCorruptError = class extends Error {
+};
+var InvalidArgsError = class extends Error {
+};
+var SfxEnvError = class extends Error {
+};
+var KEY_RE = /^[a-z0-9-]+$/;
+function defaultLibraryRoot() {
+  return path.join(os.homedir(), ".config", "limg", "sfx-library");
+}
+function resolveLibraryRoot(flag) {
+  if (flag && flag.trim()) return path.resolve(flag.trim());
+  const env = process.env.LMEDIA_SFX_LIB;
+  if (env && env.trim()) return path.resolve(env.trim());
+  return defaultLibraryRoot();
+}
+function manifestPath(root) {
+  return path.join(root, "index.json");
+}
+function emptyManifest() {
+  return { version: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), items: [] };
+}
+function readManifest(root) {
+  const p = manifestPath(root);
+  if (!fs5.existsSync(p)) return emptyManifest();
+  const raw = fs5.readFileSync(p, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new ManifestCorruptError(
+      `\u97F3\u6548\u5E93\u6E05\u5355\u635F\u574F\uFF0C\u65E0\u6CD5\u89E3\u6790: ${p}
+\u8BF7\u624B\u5DE5\u4FEE\u590D\u6216\u79FB\u8D70\u8BE5\u6587\u4EF6\uFF08\u4E0D\u4F1A\u81EA\u52A8\u91CD\u5EFA\u4EE5\u514D\u4E22\u8D26\uFF09\u3002`
+    );
+  }
+  const m = parsed;
+  if (!m || typeof m !== "object" || !Array.isArray(m.items)) {
+    throw new ManifestCorruptError(
+      `\u97F3\u6548\u5E93\u6E05\u5355\u7ED3\u6784\u4E0D\u7B26\u5408\u9884\u671F\uFF08\u7F3A items \u6570\u7EC4\uFF09: ${p}
+\u8BF7\u624B\u5DE5\u4FEE\u590D\uFF08\u4E0D\u4F1A\u81EA\u52A8\u91CD\u5EFA\u4EE5\u514D\u4E22\u8D26\uFF09\u3002`
+    );
+  }
+  return { version: 1, generatedAt: m.generatedAt ?? "", items: m.items };
+}
+function writeManifest(root, manifest) {
+  fs5.mkdirSync(root, { recursive: true });
+  const p = manifestPath(root);
+  const tmp = `${p}.${process.pid}.tmp`;
+  fs5.writeFileSync(tmp, `${JSON.stringify(manifest, null, 1)}
+`, "utf-8");
+  fs5.renameSync(tmp, p);
+}
+function initLibrary(root) {
+  fs5.mkdirSync(path.join(root, "sfx"), { recursive: true });
+  fs5.mkdirSync(path.join(root, "ambient"), { recursive: true });
+  const created = !fs5.existsSync(manifestPath(root));
+  if (created) writeManifest(root, emptyManifest());
+  return { root: path.resolve(root), manifest: manifestPath(root), created };
+}
+function listEntries(root, filter = {}) {
+  return readManifest(root).items.filter(
+    (i) => (!filter.type || i.type === filter.type) && (!filter.status || i.status === filter.status)
+  );
+}
+function sha256File(file) {
+  return createHash("sha256").update(fs5.readFileSync(file)).digest("hex");
+}
+function assertFfmpeg() {
+  for (const cmd of ["ffmpeg", "ffprobe"]) {
+    if (spawnSync("which", [cmd], { stdio: "ignore" }).status !== 0) {
+      throw new SfxEnvError(`\u7F3A\u5C11 ${cmd}\uFF08brew install ffmpeg\uFF09\uFF0C\u97F3\u6548\u5E93\u5165\u5E93\u9700\u8981\u8F6C\u7801/\u63A2\u9488`);
+    }
+  }
+}
+function probeAudio(file) {
+  let stdout;
+  try {
+    stdout = execFileSync(
+      "ffprobe",
+      ["-v", "error", "-show_entries", "format=duration:stream=sample_rate", "-of", "json", file],
+      { encoding: "utf-8" }
+    );
+  } catch {
+    throw new SfxEnvError(`ffprobe \u65E0\u6CD5\u89E3\u6790\u97F3\u9891: ${file}`);
+  }
+  const j = JSON.parse(stdout);
+  return {
+    duration: parseFloat(j.format?.duration ?? "0"),
+    sampleRate: parseInt(j.streams?.[0]?.sample_rate ?? "0", 10)
+  };
+}
+function probeAudioDurationSync(file) {
+  try {
+    return probeAudio(file).duration;
+  } catch {
+    return -1;
+  }
+}
+function transcode(file, dst) {
+  try {
+    execFileSync(
+      "ffmpeg",
+      ["-y", "-v", "error", "-i", file, "-ar", "44100", "-ac", "1", "-b:a", "160k", dst],
+      { stdio: ["ignore", "ignore", "pipe"], encoding: "utf-8" }
+    );
+  } catch (e) {
+    throw new SfxEnvError(`\u8F6C\u7801\u5931\u8D25: ${file} \u2192 ${dst}
+${(e.stderr ?? "").slice(-400)}`);
+  }
+}
+function addEntry(root, opts) {
+  if (!KEY_RE.test(opts.key)) throw new InvalidArgsError(`key \u4EC5\u5141\u8BB8\u5C0F\u5199\u5B57\u6BCD/\u6570\u5B57/\u77ED\u6A2A\u7EBF: ${opts.key}`);
+  const type = opts.type ?? "sfx";
+  if (type !== "sfx" && type !== "ambient") throw new InvalidArgsError(`type \u4EC5\u652F\u6301 sfx|ambient: ${type}`);
+  if (!fs5.existsSync(opts.file)) throw new InvalidArgsError(`\u8F93\u5165\u97F3\u9891\u4E0D\u5B58\u5728: ${opts.file}`);
+  const hash = sha256File(opts.file);
+  const dup = readManifest(root).items.find((i) => i.content_hash === hash);
+  if (dup) return { item: dup, duplicated: true };
+  assertFfmpeg();
+  initLibrary(root);
+  const dst = path.join(root, type, `${opts.key}.mp3`);
+  transcode(opts.file, dst);
+  let probe;
+  try {
+    probe = probeAudio(dst);
+  } catch (e) {
+    fs5.rmSync(dst, { force: true });
+    throw e;
+  }
+  const item = {
+    key: opts.key,
+    library: opts.library?.trim() || "default",
+    type,
+    path: dst,
+    duration: Math.round(probe.duration * 1e3) / 1e3,
+    sample_rate: probe.sampleRate,
+    tags: opts.tags ?? [],
+    title: opts.title ?? "",
+    note: opts.note ?? "",
+    status: "ready",
+    content_hash: hash,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const next = readManifest(root);
+  const idx = next.items.findIndex((i) => i.type === type && i.key === item.key);
+  if (idx >= 0) next.items[idx] = item;
+  else next.items.push(item);
+  writeManifest(root, next);
+  return { item, duplicated: false };
+}
+function removeEntry(root, key, type) {
+  const manifest = readManifest(root);
+  const idx = manifest.items.findIndex((i) => i.key === key && (!type || i.type === type));
+  if (idx < 0) return null;
+  const [removed] = manifest.items.splice(idx, 1);
+  writeManifest(root, manifest);
+  return removed;
+}
+function verifyLibrary(root) {
+  const items = readManifest(root).items;
+  const problems = [];
+  for (const item of items) {
+    const issues = [];
+    if (!fs5.existsSync(item.path)) {
+      issues.push(`\u6587\u4EF6\u7F3A\u5931: ${item.path}`);
+    } else {
+      const dur = probeAudioDurationSync(item.path);
+      if (dur < 0) issues.push(`\u65E0\u6CD5\u8BFB\u53D6\u65F6\u957F: ${item.path}`);
+      else if (Math.abs(dur - item.duration) > 0.1) {
+        issues.push(`\u65F6\u957F\u6F02\u79FB: \u6E05\u5355 ${item.duration.toFixed(2)}s / \u5B9E\u9645 ${dur.toFixed(2)}s`);
+      }
+    }
+    if (item.status !== "ready") issues.push(`\u72B6\u6001\u5F02\u5E38: ${item.status}`);
+    if (issues.length) problems.push({ key: item.key, type: item.type, issues });
+  }
+  return { root: path.resolve(root), items, problems };
+}
+function num(v, name) {
+  const n = parseFloat(v);
+  if (!Number.isFinite(n)) throw new InvalidArgsError(`${name} \u9700\u4E3A\u6570\u5B57: ${v}`);
+  return n;
+}
+function inRange(n, name, min, max) {
+  if (n < min || n > max) throw new InvalidArgsError(`${name} \u53D6\u503C ${min} - ${max}: ${n}`);
+  return n;
+}
+function parseInteger(v, name, min, max, def) {
+  if (v === void 0 || v === "") return def;
+  const n = Number(v);
+  if (!Number.isInteger(n)) throw new InvalidArgsError(`${name} \u9700\u4E3A\u6574\u6570: ${v}`);
+  return inRange(n, name, min, max);
+}
+function parseFloatIn(v, name, min, max, def) {
+  if (v === void 0 || v === "") return def;
+  return inRange(num(v, name), name, min, max);
+}
+var parseRolls = (v) => parseInteger(v, "--rolls", 1, 10, 3);
+function parseThreshDb(v, def) {
+  if (v === void 0 || v === "") return def;
+  if (!/^-\d+dB$/.test(v)) throw new InvalidArgsError(`--thresh \u9700\u5F62\u5982 -35dB: ${v}`);
+  return parseFloat(v.slice(0, -2));
+}
+var parsePad = (v) => parseFloatIn(v, "--pad", 0.01, 2, 0.15);
+var parseCap = (v) => parseFloatIn(v, "--cap", 0.5, 10, 3.5);
+var parseTarget = (v) => parseFloatIn(v, "--target", -60, -0.5, -6);
+var parseLoudness = (v) => parseFloatIn(v, "--loudness", -40, -5, -23);
+function parseMinDur(v) {
+  return parseFloatIn(v, "--min-dur", 0.05, 3600, 0.4);
+}
+function parseMaxDur(v, minDur = 0.4) {
+  const max = parseFloatIn(v, "--max-dur", 0.1, 3600, 4);
+  if (minDur >= max) throw new InvalidArgsError(`--min-dur\uFF08${minDur}\uFF09\u9700\u5C0F\u4E8E --max-dur\uFF08${max}\uFF09`);
+  return max;
+}
+function assertMutuallyExclusive(a, b, nameA, nameB) {
+  if (a !== void 0 && b !== void 0) {
+    throw new InvalidArgsError(`${nameA} \u4E0E ${nameB} \u4E92\u65A5\uFF0C\u53EA\u7ED9\u5176\u4E00`);
+  }
+}
+function assertFilesExist(files, flagName = "\u8F93\u5165\u6587\u4EF6") {
+  const missing = files.filter((f) => !fs5.existsSync(f));
+  if (missing.length) {
+    throw new InvalidArgsError(`${flagName}\u4E0D\u5B58\u5728: ${missing.join(", ")}`);
+  }
+}
+function validateKey(key) {
+  if (!KEY_RE.test(key)) throw new InvalidArgsError(`key \u4EC5\u5141\u8BB8\u5C0F\u5199\u5B57\u6BCD/\u6570\u5B57/\u77ED\u6A2A\u7EBF: ${key}`);
+  return key;
+}
+function parseBatchManifest(text, keysFilter) {
+  if (!text.trim()) {
+    throw new ManifestCorruptError('\u6279\u6E05\u5355\u4E3A\u7A7A\uFF08\u9700 [{"key":"bear","prompt":"..."}]\uFF09');
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (e) {
+    throw new ManifestCorruptError(`\u6279\u6E05\u5355\u89E3\u6790\u5931\u8D25\uFF08\u975E\u6CD5 JSON\uFF09: ${e.message}`);
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    throw new ManifestCorruptError('\u6279\u6E05\u5355\u9700\u4E3A\u975E\u7A7A\u6570\u7EC4 [{"key":"bear","prompt":"..."}]');
+  }
+  const items = [];
+  for (const raw of parsed) {
+    const it = raw;
+    if (!it || typeof it !== "object" || typeof it.key !== "string" || typeof it.prompt !== "string" || !it.prompt.trim()) {
+      throw new ManifestCorruptError("\u6279\u6E05\u5355\u6761\u76EE\u9700\u542B\u975E\u7A7A key \u4E0E prompt \u5B57\u7B26\u4E32");
+    }
+    items.push({ key: it.key, prompt: it.prompt });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const it of items) {
+    validateKey(it.key);
+    if (seen.has(it.key)) throw new InvalidArgsError(`\u6279\u6E05\u5355 key \u91CD\u590D: ${it.key}`);
+    seen.add(it.key);
+  }
+  if (!keysFilter?.length) return items;
+  const unknown = keysFilter.filter((k) => !seen.has(k));
+  if (unknown.length) throw new InvalidArgsError(`--keys \u542B\u6E05\u5355\u5916 key: ${unknown.join(", ")}`);
+  const wanted = new Set(keysFilter);
+  const picked = items.filter((it) => wanted.has(it.key));
+  if (!picked.length) throw new InvalidArgsError("--keys \u8FC7\u6EE4\u540E\u65E0\u53EF\u7528\u6761\u76EE");
+  return picked;
+}
+function parseAbGroups(text) {
+  if (!text.trim()) throw new ManifestCorruptError('A/B groups \u4E3A\u7A7A\uFF08\u9700 [{"name":"...","candidates":["a.wav"]}]\uFF09');
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (e) {
+    throw new ManifestCorruptError(`A/B groups \u89E3\u6790\u5931\u8D25\uFF08\u975E\u6CD5 JSON\uFF09: ${e.message}`);
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    throw new ManifestCorruptError('A/B groups \u9700\u4E3A\u975E\u7A7A\u6570\u7EC4 [{"name":"...","candidates":[...]}]');
+  }
+  return parsed.map((raw, i) => {
+    const g = raw;
+    if (!g || typeof g !== "object" || !Array.isArray(g.candidates) || g.candidates.some((c) => typeof c !== "string" || !c.trim())) {
+      throw new ManifestCorruptError(`A/B groups \u7B2C ${i + 1} \u7EC4\u9700\u542B candidates \u8DEF\u5F84\u6570\u7EC4`);
+    }
+    return { name: typeof g.name === "string" && g.name.trim() ? g.name : `\u7EC4${i + 1}`, candidates: g.candidates };
+  });
+}
+
+// src/commands/sfx.ts
+var MODEL = "mispeech/Dasheng-AudioGen";
+var TOKENIZER = "mispeech/dashengtokenizer";
+function fail(e) {
+  if (e instanceof InvalidArgsError) {
+    console.error(`\u2717 ${e.message}`);
+    process.exit(2);
+  }
+  console.error(`\u2717 ${e instanceof Error ? e.message : String(e)}`);
+  process.exit(1);
+}
+function requireAudioRuntime() {
+  const rt = resolveAudioRuntime();
+  if (!fs5.existsSync(rt.pythonAudio)) {
+    throw new SfxEnvError(
+      `\u97F3\u6548 venv \u672A\u627E\u5230: ${rt.pythonAudio}
+\u4FEE\u590D: lmedia sfx setup\uFF08\u6216 cd ${rt.root} && uv venv .venv-audio --python 3.11 && uv pip install -p .venv-audio/bin/python torch torchaudio "transformers<5" einops soundfile\uFF09`
+    );
+  }
+  return rt;
+}
+function requireFfmpeg() {
+  if (!hasCommand("ffmpeg") || !hasCommand("ffprobe")) {
+    throw new SfxEnvError("\u7F3A\u5C11 ffmpeg/ffprobe\uFF08brew install ffmpeg\uFF09\uFF0C\u97F3\u9891\u540E\u5904\u7406\u4F9D\u8D56");
+  }
+}
+async function runSfxOp(rt, payload) {
+  try {
+    return await runPython(rt.pythonAudio, path.join(rt.pythonDir, "sfx.py"), payload);
+  } catch (e) {
+    throw new SfxEnvError(e.message);
+  }
+}
+var n1 = (v) => v === void 0 ? "?" : v.toFixed(1);
+var pad = (s, w) => s.length >= w ? s : s + " ".repeat(w - s.length);
+var padL = (s, w) => s.length >= w ? s : " ".repeat(w - s.length) + s;
+function registerGen3(sfx) {
+  sfx.command("gen <prompt>").description("\u6587\u751F\u97F3\u6548\u3002prompt \u7528\u82F1\u6587\u63CF\u8FF0\u58F0\u97F3\u573A\u666F\uFF08\u975E\u62DF\u58F0\u8BCD\uFF09").option("-o, --out <file>", "\u8F93\u51FA wav \u8DEF\u5F84", "sfx.wav").option("--rolls <n>", "\u57FA\u7840\u751F\u6210\u6B21\u6570\uFF08\u5168\u5E9F\u81EA\u52A8\u52A0\u63B7\u22642\uFF09", "3").option("--keep-rolls", "\u4FDD\u7559\u5168\u90E8\u63B7\u6B21\u5230 <out>.rolls/ \u76EE\u5F55").option("--full", "\u8DF3\u8FC7\u526A\u88C1\uFF0C\u4FDD\u7559 10s \u539F\u59CB\u751F\u6210").action(async (prompt, opts) => {
+    try {
+      const rolls = parseRolls(opts.rolls);
+      const rt = requireAudioRuntime();
+      requireFfmpeg();
+      const out = path.resolve(opts.out ?? "sfx.wav");
+      fs5.mkdirSync(path.dirname(out), { recursive: true });
+      console.error(`\u{1F3AC} sfx gen\uFF08${rolls} \u63B7 + \u8D28\u91CF\u95E8 + \u526A\u88C1\uFF09\u2026`);
+      const res = await runSfxOp(rt, {
+        prompt,
+        out,
+        rolls,
+        keepRolls: !!opts.keepRolls,
+        trim: !opts.full
+      });
+      const r = res;
+      if (r.out) {
+        console.error(`${r.gatePassed ? "\u2713" : "\u26A0\uFE0F \u65E0\u5408\u683C\u63B7\uFF08\u53D6\u5CF0\u503C\u6700\u9AD8\uFF0C\u5EFA\u8BAE\u91CD\u8DD1\uFF09"} best=r${r.bestRoll} peak=${r.peak}dB snr=${r.snr}dB \u2192 ${r.out} (${r.dur}s)`);
+      }
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerBatch(sfx) {
+  sfx.command("batch").description("\u6E05\u5355\u9A71\u52A8\u6279\u91CF\u751F\u6210\uFF1A\u9010 key \u591A\u63B7 + \u8D28\u91CF\u95E8\u9009\u4F18 \u2192 <dir>/<key>.best.wav + report.json").requiredOption("-m, --manifest <file>", "\u6279\u6E05\u5355 JSON \u8DEF\u5F84\uFF08- \u8BFB stdin\uFF09").requiredOption("-o, --out <dir>", "\u8F93\u51FA\u76EE\u5F55").option("--rolls <n>", "\u6BCF key \u57FA\u7840\u751F\u6210\u6B21\u6570\uFF081-10\uFF0C\u5168\u5E9F\u81EA\u52A8\u52A0\u63B7\u22642\uFF09", "3").option("--keep-rolls", "\u4FDD\u7559\u5168\u90E8\u63B7\u6B21\u5230\u8F93\u51FA\u76EE\u5F55\uFF08<key>.r<N>.wav\uFF09").option("--full", "\u8DF3\u8FC7\u526A\u88C1\uFF0C\u4FDD\u7559 10s \u539F\u59CB\u751F\u6210").option("--keys <list>", "\u53EA\u8DD1\u5B50\u96C6\uFF0C\u9017\u53F7\u5206\u9694\uFF08\u5982 bear,frog\uFF09").action(async (opts) => {
+    try {
+      const rolls = parseRolls(opts.rolls);
+      const text = opts.manifest === "-" ? fs5.readFileSync(0, "utf-8") : (() => {
+        if (!fs5.existsSync(opts.manifest)) {
+          throw new InvalidArgsError(`\u6279\u6E05\u5355\u4E0D\u5B58\u5728: ${opts.manifest}`);
+        }
+        return fs5.readFileSync(opts.manifest, "utf-8");
+      })();
+      const items = parseBatchManifest(
+        text,
+        opts.keys ? opts.keys.split(",").map((k) => k.trim()).filter(Boolean) : void 0
+      );
+      const rt = requireAudioRuntime();
+      requireFfmpeg();
+      const outDir = path.resolve(opts.out);
+      fs5.mkdirSync(outDir, { recursive: true });
+      console.error(`\u{1F3AC} sfx batch\uFF08${items.length} key \xD7 ${rolls} \u63B7\uFF09\u2192 ${outDir}`);
+      const res = await runSfxOp(rt, {
+        op: "batch",
+        items,
+        outDir,
+        rolls,
+        keepRolls: !!opts.keepRolls,
+        trim: !opts.full
+      });
+      const nPass = res.items.filter((i) => i.anyPass).length;
+      console.error(`\u2713 \u5B8C\u6210 ${nPass}/${res.items.length} key \u6709\u5408\u683C\u751F\u6210\uFF08${res.genSec}s\uFF09\u2192 ${path.join(res.dir, "report.json")}`);
+      console.log(JSON.stringify(res, null, 2));
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerTrim(sfx) {
+  sfx.command("trim <files...>").description("\u53BB\u9996\u5C3E\u9759\u97F3\uFF08\u4E24\u7EA7\u9608\u503C\uFF09+ \u5185\u90E8\u7C07\u622A\u65AD \u2192 <name>.trim.wav + <name>.short.wav + <name>.ops.json").option("--thresh <v>", "\u9759\u97F3\u9608\u503C\uFF08\u5F62\u5982 -35dB\uFF09", "-35dB").option("--pad <sec>", "\u526A\u88C1\u524D\u540E\u4FDD\u7559\uFF08\u79D2\uFF09", "0.15").action(async (files, opts) => {
+    try {
+      assertFilesExist(files);
+      const thresh = parseThreshDb(opts.thresh, -35);
+      const padSec = parsePad(opts.pad);
+      requireFfmpeg();
+      const rt = requireAudioRuntime();
+      console.error(`\xB7 \u526A\u88C1 ${files.length} \u4E2A\u6587\u4EF6\uFF08thresh ${opts.thresh} / pad ${padSec}s\uFF09`);
+      const res = await runSfxOp(rt, {
+        op: "trim",
+        files,
+        threshDb: thresh,
+        pad: padSec
+      });
+      for (const it of res.items) {
+        console.log(`\u2713 ${it.in} \u2192 ${it.trim} (dur ${n1(it.durIn)}\u2192${n1(it.durTrim)}, peak ${n1(it.peakIn)}\u2192${n1(it.peakOut)})`);
+        console.error(`\xB7 short: ${it.short}\uFF08${n1(it.durShort)}s\uFF09`);
+      }
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerRecut(sfx) {
+  sfx.command("recut <files...>").description("\u7075\u654F\u91CD\u526A\uFF08-40dB/0.45s \u95F4\u9699 + \u786C\u5E3D\uFF09+ \u6BB5\u5185\u5F52\u4E00 \u2192 \u8986\u5199 <name>.short.wav").option("--thresh <v>", "\u9759\u97F3\u9608\u503C\uFF08\u5F62\u5982 -40dB\uFF09", "-40dB").option("--cap <sec>", "\u6210\u54C1\u65F6\u957F\u786C\u5E3D\uFF080.5-10s\uFF09", "3.5").action(async (files, opts) => {
+    try {
+      assertFilesExist(files);
+      const thresh = parseThreshDb(opts.thresh, -40);
+      const cap = parseCap(opts.cap);
+      requireFfmpeg();
+      const rt = requireAudioRuntime();
+      console.error(`\xB7 \u91CD\u526A ${files.length} \u4E2A\u6587\u4EF6\uFF08thresh ${opts.thresh} / cap ${cap}s\uFF09`);
+      const res = await runSfxOp(rt, {
+        op: "recut",
+        files,
+        threshDb: thresh,
+        cap
+      });
+      for (const it of res.items) {
+        console.log(`\u2713 ${it.in} \u2192 ${it.short} (dur ${n1(it.durIn)}\u2192${n1(it.durOut)}, peak ${n1(it.peakIn)}\u2192${n1(it.peakOut)})`);
+      }
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerNormalize(sfx) {
+  sfx.command("normalize <files...>").description("\u54CD\u5EA6\u5F52\u4E00\uFF1A\u9ED8\u8BA4\u4E24\u904D\u5CF0\u503C\u5F52\u4E00 -6dBFS\uFF1B--loudness \u8D70 loudnorm \u4E24\u904D\uFF08ambient\uFF09").option("--target <dbfs>", "\u5CF0\u503C\u76EE\u6807 dBFS\uFF08-60 - -0.5\uFF0C\u7F3A\u7701 -6\uFF09").option("--loudness <lufs>", "\u7EFC\u5408\u54CD\u5EA6\u76EE\u6807 LUFS\uFF08-40 - -5\uFF0C\u4E0E --target \u4E92\u65A5\uFF09").option("--out-dir <dir>", "\u8F93\u51FA\u76EE\u5F55\uFF08\u7F3A\u7701\u539F\u5730\u8986\u5199\uFF09").action(async (files, opts) => {
+    try {
+      assertFilesExist(files);
+      assertMutuallyExclusive(opts.target, opts.loudness, "--target", "--loudness");
+      const loudness = opts.loudness !== void 0 ? parseLoudness(opts.loudness) : void 0;
+      const target = opts.target !== void 0 ? parseTarget(opts.target) : -6;
+      requireFfmpeg();
+      const rt = requireAudioRuntime();
+      const outDir = opts.outDir ? path.resolve(opts.outDir) : void 0;
+      console.error(`\xB7 \u5F52\u4E00 ${files.length} \u4E2A\u6587\u4EF6\uFF08${loudness !== void 0 ? `loudnorm ${loudness} LUFS` : `\u5CF0\u503C ${target} dBFS`}\uFF09`);
+      const res = await runSfxOp(rt, {
+        op: "normalize",
+        files,
+        target,
+        loudness,
+        outDir
+      });
+      for (const it of res.items) {
+        if (it.skipped) {
+          console.log(`\xB7 ${it.in} \u2192 ${it.out}\uFF08${it.reason}\uFF09`);
+        } else if (it.mode === "loudness") {
+          console.log(`\u2713 ${it.in} \u2192 ${it.out} (dur ${n1(it.durIn)}\u2192${n1(it.durOut)}, lufs ${n1(it.lufsIn)}\u2192${n1(it.lufsOut)})`);
+        } else {
+          console.log(`\u2713 ${it.in} \u2192 ${it.out} (dur ${n1(it.durIn)}\u2192${n1(it.durOut)}, peak ${n1(it.peakIn)}\u2192${n1(it.peakOut)})`);
+        }
+      }
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerAccept(sfx) {
+  sfx.command("accept <files...>").description("\u91CF\u5316\u9A8C\u6536\uFF1A\u65F6\u957F/\u5CF0\u503C/\u5747\u503C\u62A5\u8868\uFF08\u4EFB\u4E00 flag \u547D\u4E2D exit 1\uFF0C\u4EBA\u5DE5\u7EC8\u5BA1\u524D\u7F6E\uFF09").option("--max-dur <sec>", "\u8FC7\u957F\u9608\u503C\uFF08\u79D2\uFF09", "4.0").option("--min-dur <sec>", "\u8FC7\u77ED\u9608\u503C\uFF08\u79D2\uFF09", "0.4").action(async (files, opts) => {
+    try {
+      assertFilesExist(files);
+      const minDur = parseMinDur(opts.minDur);
+      const maxDur = parseMaxDur(opts.maxDur, minDur);
+      requireFfmpeg();
+      const rt = requireAudioRuntime();
+      const res = await runSfxOp(rt, {
+        op: "accept",
+        files,
+        maxDur,
+        minDur
+      });
+      console.error(`${pad("\u6587\u4EF6", 42)}${padL("\u65F6\u957F", 7)}${padL("\u5CF0\u503C", 10)}${padL("\u5747\u503C", 10)}  flag`);
+      for (const it of res.items) {
+        const name = path.basename(it.path);
+        const flagText = it.pass ? it.flags.join(",") : `\u2717 ${it.flags.join(",")}`;
+        console.log(
+          `${pad(name, 42)}${padL(`${n1(it.dur)}s`, 7)}${padL(`${n1(it.peak)}dB`, 10)}${padL(`${n1(it.mean)}dB`, 10)}  ${pad(flagText, 16)} status=${it.pass ? "pass" : "fail"}`
+        );
+      }
+      const nPass = res.items.filter((i) => i.pass).length;
+      console.log(`${nPass}/${res.items.length} \u901A\u8FC7`);
+      if (nPass !== res.items.length) process.exit(1);
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerAb(sfx) {
+  sfx.command("ab").description("\u751F\u6210 A/B \u8BD5\u542C\u9875\uFF08\u72EC\u7ACB html\uFF0C\u5019\u9009\u97F3\u9891\u62F7\u8D1D\u5230 ab_files/ \u76F8\u5BF9\u8DEF\u5F84\u5F15\u7528\uFF09").requiredOption("-m, --groups <file>", 'groups JSON\uFF1A[{"name":"...","candidates":["a.wav","b.wav"]}]').requiredOption("-o, --out <file>", "\u8F93\u51FA html \u8DEF\u5F84").action(async (opts) => {
+    try {
+      if (!fs5.existsSync(opts.groups)) throw new InvalidArgsError(`groups \u6587\u4EF6\u4E0D\u5B58\u5728: ${opts.groups}`);
+      const groups = parseAbGroups(fs5.readFileSync(opts.groups, "utf-8"));
+      const candidates = groups.flatMap((g) => g.candidates);
+      assertFilesExist(candidates, "\u5019\u9009\u97F3\u9891");
+      const rt = requireAudioRuntime();
+      const out = path.resolve(opts.out);
+      fs5.mkdirSync(path.dirname(out), { recursive: true });
+      const res = await runSfxOp(rt, { op: "abpage", groups, out });
+      console.error(`\xB7 \u5019\u9009\u97F3\u9891\u5DF2\u62F7\u8D1D\u5230 ${path.join(path.dirname(out), "ab_files")}`);
+      console.log(`\u2713 ${res.out}\uFF08${res.groups} \u7EC4 / ${res.candidates} \u5019\u9009\uFF09`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerSetup2(sfx) {
+  sfx.command("setup").description("\u5E42\u7B49\u521B\u5EFA\u97F3\u6548 venv\uFF08uv venv .venv-audio + torch/transformers<5 \u7B49\uFF09").action(async () => {
+    try {
+      const rt = resolveAudioRuntime();
+      if (spawnSync("which", ["uv"], { stdio: "ignore" }).status !== 0) {
+        throw new SfxEnvError("\u7F3A\u5C11 uv\uFF08curl -LsSf https://astral.sh/uv/install.sh | sh\uFF09\uFF0Csfx setup \u4F9D\u8D56");
+      }
+      const deps = ["torch", "torchaudio", "transformers<5", "einops", "soundfile"];
+      if (fs5.existsSync(rt.pythonAudio)) {
+        const ok = spawnSync(rt.pythonAudio, ["-c", "import torch, torchaudio, transformers, einops, soundfile"], { stdio: "ignore" }).status === 0;
+        if (ok) {
+          console.error(`\u2713 \u97F3\u6548 venv \u5DF2\u5C31\u7EEA: ${rt.pythonAudio}`);
+          return;
+        }
+        console.error("\xB7 venv \u5DF2\u5B58\u5728\u4F46\u4F9D\u8D56\u4E0D\u5168 \u2192 \u8865\u88C5");
+      } else {
+        console.error(`\xB7 \u521B\u5EFA venv: ${rt.root}/.venv-audio\uFF08python 3.11\uFF09`);
+        const r2 = spawnSync("uv", ["venv", path.join(rt.root, ".venv-audio"), "--python", "3.11"], { stdio: "inherit" });
+        if (r2.status !== 0) throw new SfxEnvError("uv venv \u5931\u8D25");
+      }
+      console.error(`\xB7 \u5B89\u88C5\u4F9D\u8D56: ${deps.map((d) => d.includes("<") ? `"${d}"` : d).join(" ")}`);
+      const r = spawnSync("uv", ["pip", "install", "-p", rt.pythonAudio, ...deps], { stdio: "inherit" });
+      if (r.status !== 0) throw new SfxEnvError("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25\uFF08uv pip install\uFF09");
+      console.error(`\u2713 \u97F3\u6548 venv \u5C31\u7EEA: ${rt.pythonAudio}`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerSfxDoctor(sfx) {
+  sfx.command("doctor").description("\u97F3\u6548\u6808\u81EA\u68C0\uFF08venv / \u4E3B\u6A21\u578B\u7F13\u5B58 / \u5206\u8BCD\u5668\u7F13\u5B58\uFF09\uFF0C\u72EC\u7ACB\u9000\u51FA\u7801 0/1").action(async () => {
+    try {
+      const rt = resolveAudioRuntime();
+      const checks = [
+        [
+          "\u97F3\u6548 venv",
+          fs5.existsSync(rt.pythonAudio),
+          `\u4FEE\u590D: lmedia sfx setup\uFF08\u5EFA ${rt.root}/.venv-audio\uFF09`
+        ],
+        [
+          `\u4E3B\u6A21\u578B\u7F13\u5B58 ${MODEL}`,
+          !!hfSnapshot(MODEL),
+          `\u4FEE\u590D: HF_HUB_OFFLINE=0 huggingface-cli download ${MODEL}\uFF08\u6216\u4EFB\u4E00 transformers \u52A0\u8F7D\u89E6\u53D1\u4E0B\u8F7D\uFF09`
+        ],
+        [
+          `\u5206\u8BCD\u5668\u7F13\u5B58 ${TOKENIZER}`,
+          !!hfSnapshot(TOKENIZER),
+          `\u4FEE\u590D: HF_HUB_OFFLINE=0 huggingface-cli download ${TOKENIZER}`
+        ]
+      ];
+      for (const [name, ok, fix] of checks) {
+        if (ok) console.log(`\u2713 ${name}`);
+        else console.log(`\u2717 ${name} \u7F3A\u5931 \u2192 ${fix}`);
+      }
+      const bad = checks.filter(([, ok]) => !ok).length;
+      if (bad === 0) {
+        console.log("\u97F3\u6548\u6A21\u6001\u5C31\u7EEA\uFF08sfx gen/batch \u53EF\u7528\uFF09");
+      } else {
+        console.error(`\u97F3\u6548\u6808\u7F3A\u5931 ${bad} \u9879\uFF08\u89C1 \u2717 \u4FEE\u590D\u6307\u5F15\uFF09`);
+        process.exit(1);
+      }
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerLib(sfx) {
+  const lib = sfx.command("lib").description("SSOT \u97F3\u6548\u5E93\uFF1A\u5165\u5E93\uFF0844.1k mono 160k mp3\uFF09/ \u5217\u8868 / \u79FB\u9664 / \u5BF9\u8D26");
+  lib.command("init").description("\u521B\u5EFA\u5E93\u6839 + \u76EE\u5F55\u9AA8\u67B6 + \u7A7A\u6E05\u5355\uFF08\u5E42\u7B49\uFF09").option("--lib <dir>", "\u5E93\u6839\uFF08\u7F3A\u7701 ~/.config/limg/sfx-library\uFF0C\u53EF\u88AB LMEDIA_SFX_LIB \u8986\u76D6\uFF09").action(async (opts) => {
+    try {
+      const root = resolveLibraryRoot(opts.lib);
+      const r = initLibrary(root);
+      console.log(`${r.created ? "\u2713 \u5DF2\u521B\u5EFA" : "\xB7 \u5DF2\u5B58\u5728"}\u97F3\u6548\u5E93: ${r.root}\uFF08\u6E05\u5355 ${r.manifest}\uFF09`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+  lib.command("add <file>").description("\u8F6C\u7801\u5165\u5E93 + \u6E05\u5355\u843D\u8D26\uFF08\u540C\u5185\u5BB9\u91CD\u590D\u767B\u8BB0\u5E42\u7B49\u8DF3\u8FC7\uFF09").requiredOption("--key <k>", "\u97F3\u6548 key\uFF08\u5C0F\u5199\u5B57\u6BCD/\u6570\u5B57/\u77ED\u6A2A\u7EBF\uFF09").option("--type <t>", "sfx | ambient", "sfx").option("--library <name>", "\u5E93\u540D\uFF08\u843D\u5165\u8BB0\u5F55 library \u5B57\u6BB5\uFF09", "default").option("--title <t>", "\u6807\u9898").option("--note <n>", "\u5907\u6CE8").option("--tags <list>", "\u6807\u7B7E\uFF0C\u9017\u53F7\u5206\u9694\uFF08\u5982 animal,cute\uFF09").option("--lib <dir>", "\u5E93\u6839").action(async (file, opts) => {
+    try {
+      if (opts.type !== "sfx" && opts.type !== "ambient") {
+        throw new InvalidArgsError(`--type \u4EC5\u652F\u6301 sfx|ambient: ${opts.type}`);
+      }
+      if (opts.library !== void 0 && !opts.library.trim()) {
+        throw new InvalidArgsError("--library \u9700\u4E3A\u975E\u7A7A\u5E93\u540D");
+      }
+      assertFilesExist([file], "\u8F93\u5165\u97F3\u9891");
+      const root = resolveLibraryRoot(opts.lib);
+      const { item, duplicated } = addEntry(root, {
+        file: path.resolve(file),
+        key: opts.key,
+        type: opts.type,
+        library: opts.library,
+        title: opts.title,
+        note: opts.note,
+        tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()).filter(Boolean) : []
+      });
+      if (duplicated) {
+        console.log(`\xB7 \u5DF2\u6709\u540C\u5185\u5BB9\u6761\u76EE: ${item.key}\uFF08content_hash \u76F8\u540C\uFF0C\u5E42\u7B49\u8DF3\u8FC7\uFF09`);
+        return;
+      }
+      console.log(`\u2713 \u5165\u5E93 ${item.key} \u2192 ${item.path}\uFF08${item.duration.toFixed(2)}s / ${item.sample_rate}Hz / [${item.tags.join(", ")}]\uFF09`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+  lib.command("list").description("\u8868\u683C\u5217\u51FA\u5E93\u5185\u6761\u76EE\uFF08stdout \u884C\u6570 == \u8FC7\u6EE4\u540E\u6E05\u5355\u6761\u6570\uFF09").option("--type <t>", "\u6309\u7C7B\u578B\u8FC7\u6EE4\uFF08sfx|ambient\uFF09").option("--status <s>", "\u6309\u72B6\u6001\u8FC7\u6EE4\uFF08ready\uFF09").option("--lib <dir>", "\u5E93\u6839").action(async (opts) => {
+    try {
+      const root = resolveLibraryRoot(opts.lib);
+      const items = listEntries(root, { type: opts.type, status: opts.status });
+      console.error(`${pad("key", 20)}${pad("type", 9)}${padL("dur", 8)}  ${pad("tags", 18)}${pad("status", 7)}path`);
+      for (const i of items) {
+        console.log(
+          `${pad(i.key, 20)}${pad(i.type, 9)}${padL(i.duration.toFixed(2), 8)}  ${pad(`[${i.tags.join(",")}]`, 18)}${pad(i.status, 7)}${i.path}`
+        );
+      }
+      console.error(`\u5171 ${items.length} \u6761`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+  lib.command("remove <key>").description("\u79FB\u9664\u6E05\u5355\u8BB0\u5F55\uFF08\u4E0D\u5220\u97F3\u9891\u6587\u4EF6\uFF09").option("--type <t>", "\u6309\u7C7B\u578B\u9650\u5B9A\uFF08sfx|ambient\uFF09").option("--lib <dir>", "\u5E93\u6839").action(async (key, opts) => {
+    try {
+      const root = resolveLibraryRoot(opts.lib);
+      const removed = removeEntry(root, key, opts.type);
+      if (!removed) {
+        console.error(`\u2717 \u5E93\u4E2D\u65E0\u6B64\u8BB0\u5F55\uFF08\u6309 type \u8FC7\u6EE4\u540E\uFF09: ${key}\uFF08lmedia sfx lib list \u67E5\u770B\uFF09`);
+        process.exit(1);
+      }
+      console.log(`\u2713 \u5DF2\u79FB\u9664\u8BB0\u5F55 ${key}\uFF08\u97F3\u9891\u6587\u4EF6\u4FDD\u7559: ${removed.path}\uFF09`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+  lib.command("verify").description("\u5BF9\u8D26\uFF1A\u8BB0\u5F55 \u2194 \u6587\u4EF6 \u2194 \u65F6\u957F\uFF08\xB10.1s\uFF09\u2194 status\uFF0C\u6F02\u79FB exit 1").option("--lib <dir>", "\u5E93\u6839").action(async (opts) => {
+    try {
+      const root = resolveLibraryRoot(opts.lib);
+      const { items, problems } = verifyLibrary(root);
+      for (const item of items) {
+        const p = problems.find((x) => x.key === item.key && x.type === item.type);
+        if (!p) console.log(`\u2713 ${item.key}\uFF08${item.type}\uFF09`);
+        else console.log(`\u2717 ${item.key}\uFF08${item.type}\uFF09: ${p.issues.join("; ")}`);
+      }
+      console.error(`\u5171 ${items.length} \u6761\uFF0C\u6F02\u79FB ${problems.length} \u6761`);
+      if (problems.length) process.exit(1);
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+function registerSfx(program2) {
+  const sfx = program2.command("sfx").description("\u97F3\u6548\u6A21\u6001\uFF1ADasheng \u672C\u5730\u751F\u6210\uFF08gen/batch\uFF09+ \u526A\u88C1/\u5F52\u4E00/\u9A8C\u6536/\u5165\u5E93\u4EA7\u7EBF\uFF08trim/recut/normalize/accept/ab/lib\uFF09");
+  registerGen3(sfx);
+  registerBatch(sfx);
+  registerTrim(sfx);
+  registerRecut(sfx);
+  registerNormalize(sfx);
+  registerAccept(sfx);
+  registerAb(sfx);
+  registerSetup2(sfx);
+  registerSfxDoctor(sfx);
+  registerLib(sfx);
+}
+function sfxDoctorChecks() {
+  const rt = resolveAudioRuntime();
+  return [
+    [`[sfx] .venv-audio\uFF08Dasheng-AudioGen\uFF09`, fs5.existsSync(rt.pythonAudio)],
+    [`[sfx] \u4E3B\u6A21\u578B\u7F13\u5B58 ${MODEL}`, !!hfSnapshot(MODEL)],
+    [`[sfx] \u5206\u8BCD\u5668\u7F13\u5B58 ${TOKENIZER}`, !!hfSnapshot(TOKENIZER)]
+  ];
+}
+
+// src/commands/doctor.ts
+function registerDoctor(program2) {
+  program2.command("doctor").description("\u73AF\u5883\u81EA\u68C0\uFF1A\u8FD0\u884C\u65F6/\u6A21\u578B\u5FEB\u7167/LoRA \u6587\u4EF6\u5B8C\u6574\u6027").action(async () => {
+    const vrt = resolveVideoRuntime();
+    const videoChecks = [
+      ["[video] .venv-video\uFF08mmh3turbo\uFF09", fs5.existsSync(vrt.mmh3turbo)],
+      ["[video] ffmpeg", hasCommand("ffmpeg")],
+      ["[video] H3 \u6743\u91CD\uFF08~/.cache/mmh3turbo\uFF0C\u672A\u5C31\u7EEA\u65F6\u9996\u6B21\u751F\u6210\u81EA\u52A8\u4E0B\u8F7D\u6216 setup --mirror\uFF09", fs5.existsSync(path.join(vrt.weightsDir, "dit.bin"))]
+    ];
+    let imageOk = true;
+    try {
+      const rt = resolveRuntime();
+      const checks = [
+        ["runtime root", fs5.existsSync(rt.root)],
+        ["pythonGen (.venv-train)", fs5.existsSync(rt.pythonGen)],
+        ["pythonFast (.venv)", fs5.existsSync(rt.pythonFast)],
+        ["[image] Qwen-Image-2512 \u5FEB\u7167", fs5.existsSync(rt.snapshot)],
+        ["[image] Qwen-Image-Edit-2511 \u5FEB\u7167", fs5.existsSync(rt.snapshotEdit)],
+        ["[image] Real-ESRGAN \u6743\u91CD", fs5.existsSync(resolveEsrganPath())]
+      ];
+      for (const [name, ok] of checks) console.log(`${ok ? "\u2713" : "\u2717"} ${name}`);
+      for (const l of loadRegistry()) {
+        console.log(`${fs5.existsSync(l.path) ? "\u2713" : "\u2717"} LoRA: ${l.name}`);
+      }
+      imageOk = checks.every(([, ok]) => ok);
+    } catch (e) {
+      imageOk = false;
+      console.error(e.message);
+    }
+    for (const m of ["gen", "edit"]) {
+      const st = await pingDaemon(m);
+      console.log(
+        `${st ? "\u2713" : "\xB7"} [image] daemon ${m}${st ? `: ${st.state}\uFF08pid ${st.pid}\uFF0Cjobs ${st.jobs}\uFF09` : ": \u672A\u8FD0\u884C\uFF08\u53EF\u9009\uFF0Clmedia image serve start --mode " + m + "\uFF09"}`
+      );
+    }
+    for (const [name, ok] of videoChecks) console.log(`${ok ? "\u2713" : "\u2717"} ${name}`);
+    const videoOk = videoChecks[0][1] && videoChecks[1][1];
+    const sfxChecks = sfxDoctorChecks();
+    for (const [name, ok] of sfxChecks) console.log(`${ok ? "\u2713" : "\u2717"} ${name}`);
+    const sfxOk = sfxChecks.every(([, ok]) => ok);
+    console.log(
+      `
+\u56FE\u50CF\u6A21\u6001${imageOk ? "\u5C31\u7EEA" : "\u672A\u5C31\u7EEA"}\u3002\u89C6\u9891\u6A21\u6001\uFF08\u672C\u5730 MiniMax-H3 / mmh3turbo\uFF09\uFF1A${videoOk ? "\u5C31\u7EEA" : "\u672A\u5C31\u7EEA\uFF08lmedia video setup\uFF09"}\u3002\u97F3\u6548\u6A21\u6001\uFF1A${sfxOk ? "\u5C31\u7EEA" : "\u672A\u5C31\u7EEA\uFF08lmedia sfx doctor \u770B\u4FEE\u590D\u6307\u5F15\uFF09"}`
+    );
+    if (!imageOk) process.exit(1);
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("lmedia").description("\u672C\u5730\u5A92\u4F53\u751F\u4EA7 CLI \u2014 \u56FE\u50CF/\u89C6\u9891\uFF08\u672C\u5730\u63A8\u7406\uFF0C\u96F6 API \u6210\u672C\uFF09+ LoRA \u6CE8\u518C\u8868\u3002Apple Silicon").version("0.1.0");
+registerImage(program);
+registerVideo(program);
+registerLora(program);
+registerDoctor(program);
+registerSfx(program);
+program.parse();