hyperframes 0.8.142 → 0.8.144

package/dist/{timeline-N6ZASFNE.js → timeline-T3QSGT3A.js}

@@ -6,15 +6,15 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   resolveProject
-} from "./chunk-LJAU4TPS.js";
+} from "./chunk-KFKZ3ISO.js";
 import {
   readCompositionFps
-} from "./chunk-YEIFI443.js";
-import "./chunk-IHFUKJOR.js";
+} from "./chunk-WPNE5NEP.js";
+import "./chunk-K2FLNJVB.js";
 import {
   applyFileMutations,
   duplicateElementInHtml
-} from "./chunk-YHRZQJXH.js";
+} from "./chunk-XGFHYAYN.js";
 import {
   findSyncPartner,
   patchElementInHtml,
@@ -22,23 +22,30 @@ import {
   removeElementFromHtml,
   splitElementInHtml,
   syncOffsetFrames
-} from "./chunk-OKCR3JTO.js";
+} from "./chunk-YJXHMIZA.js";
 import {
   fileContentVersion
 } from "./chunk-QZ3AZTXI.js";
-import "./chunk-U7E736AJ.js";
-import "./chunk-6UM3R7PP.js";
+import "./chunk-DDIVWXN7.js";
+import "./chunk-ZOA2SC4P.js";
 import "./chunk-G75ENCEZ.js";
 import "./chunk-EOVYQ3IG.js";
 import {
   ensureDOMParser
-} from "./chunk-PFCFR3KZ.js";
+} from "./chunk-442JNXRM.js";
 import "./chunk-374QQGBQ.js";
-import "./chunk-XGMNQQTJ.js";
-import "./chunk-LBKDQKWV.js";
+import "./chunk-RG3QWWIE.js";
+import "./chunk-XU5GGV6R.js";
 import "./chunk-VWG7OQKU.js";
 import "./chunk-GQJZORQP.js";
 import "./chunk-AMKC3AXA.js";
+import {
+  resolveExtraPositionals
+} from "./chunk-GZVP4TWN.js";
+import "./chunk-K4WKGXRC.js";
+import {
+  assertKnownFlags
+} from "./chunk-UPFUC4DB.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -54,11 +61,11 @@ import {
   extractMediaMetadata,
   resolveReferencedDuration,
   resolveReferencedStart
-} from "./chunk-IDX52YJN.js";
-import "./chunk-DPHJKWP5.js";
+} from "./chunk-5VMR4WBS.js";
+import "./chunk-OUSLVRO4.js";
 import {
   ensureHfIds
-} from "./chunk-A4KQZXZI.js";
+} from "./chunk-NE55C6S5.js";
 import "./chunk-USDEMXXL.js";
 import {
   byStart,
@@ -68,47 +75,49 @@ import {
   resolveMediaStartSeconds,
   sameInstant,
   spansShareTime
-} from "./chunk-YFT3BL7N.js";
-import {
-  topLevelElements,
-  trackKindOf
-} from "./chunk-OZUQF4NB.js";
-import "./chunk-DPVXBVLL.js";
+} from "./chunk-3VYNNWVA.js";
 import {
   HF_AUDIO_AUTOMATION_ATTR,
   HF_AUDIO_FX_ATTR,
   parseAudioFxChain,
   parseAutomation,
   resolveAutomation
-} from "./chunk-J4UX3RS3.js";
+} from "./chunk-WJB7WI4J.js";
 import "./chunk-VC76R6W2.js";
 import "./chunk-YA62XGXS.js";
+import {
+  topLevelElements,
+  trackKindOf
+} from "./chunk-MQZVBHEY.js";
 import "./chunk-OFQWTKPW.js";
+import "./chunk-DPVXBVLL.js";
 import "./chunk-T76PLPD6.js";
 import "./chunk-FXMKHHPO.js";
 import "./chunk-RQVDTPGD.js";
 import "./chunk-TWWSYAKJ.js";
-import "./chunk-IW2CKH6A.js";
-import "./chunk-JFKL3WAE.js";
-import "./chunk-HBBJFK6I.js";
+import "./chunk-IEIJRMLZ.js";
+import "./chunk-IWFLMU2N.js";
+import "./chunk-APDLWWFG.js";
 import "./chunk-PJ3HDUCY.js";
 import {
-  parseNumeric,
+  parseNumeric
+} from "./chunk-3RM2ETQT.js";
+import {
   readMediaOffsetSeconds,
   readPlaybackRate,
   resolveMediaDuration
-} from "./chunk-TQFG7HTI.js";
-import "./chunk-GK4AIFIH.js";
+} from "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
 import "./chunk-2PSPARWP.js";
-import "./chunk-PMRBLBUP.js";
+import "./chunk-T42U2W2R.js";
 import {
   withMeta
-} from "./chunk-JLKMWY2T.js";
+} from "./chunk-P6WH6QTV.js";
 import "./chunk-K4WIOZFP.js";
 import "./chunk-XUXGIA7H.js";
 import "./chunk-WERLJGIC.js";
 import "./chunk-ISN5GRYI.js";
-import "./chunk-DZEVA7DI.js";
+import "./chunk-4OC7MQNB.js";
 import "./chunk-KNU5COPB.js";
 import "./chunk-3GXQPCJC.js";
 import "./chunk-ZTZA4UWZ.js";
@@ -394,7 +403,7 @@ var n = (v) => String(Math.round(v * 1e3) / 1e3);
 function bar(row, total) {
   if (total <= 0) return " ".repeat(BAR_WIDTH);
   const known = row.durationAuthored || row.duration > 0;
-  const from = Math.min(BAR_WIDTH - 1, Math.floor(row.absStart / total * BAR_WIDTH));
+  const from = Math.max(0, Math.min(BAR_WIDTH - 1, Math.floor(row.absStart / total * BAR_WIDTH)));
   const to = known ? row.absEnd / total * BAR_WIDTH : BAR_WIDTH;
   const width = Math.max(1, Math.min(BAR_WIDTH, Math.ceil(to)) - from);
   const fill = known ? "\u2588" : "\u2591";
@@ -1060,16 +1069,10 @@ async function runApply(args) {
       `${plan ? "planned" : "applied"} ${inputs.length} file${inputs.length === 1 ? "" : "s"}`
     );
 }
-async function runUndo(args) {
-  const project = resolveProject(typeof args.dir === "string" ? args.dir : void 0);
-  const json = args.json === true;
-  const input = typeof args.receipt === "string" ? args.receipt : positional(args)[1];
-  if (!input)
-    return refuse(
-      "timeline undo",
-      { reason: "an undo receipt is required", fix: "pass the receipt JSON or its file" },
-      json
-    );
+function isUndoReceipt(value) {
+  return isRecord(value) && typeof value.file === "string" && typeof value.version === "string" && typeof value.backupPath === "string";
+}
+function readUndoInput(input) {
   let raw;
   try {
     raw = readFileSync3(input, "utf-8");
@@ -1080,37 +1083,63 @@ async function runUndo(args) {
   try {
     parsed = JSON.parse(raw);
   } catch {
-    return refuse(
-      "timeline undo",
-      { reason: "undo receipt is not valid JSON", fix: "pass the applied JSON receipt" },
-      json
-    );
+    return {
+      ok: false,
+      reason: "undo receipt is not valid JSON",
+      fix: "pass the applied JSON receipt"
+    };
+  }
+  const value = isRecord(parsed) && "receipt" in parsed ? parsed.receipt : parsed;
+  const values = Array.isArray(value) ? value : [value];
+  if (!values.every(isUndoReceipt)) {
+    return {
+      ok: false,
+      reason: "undo receipt is missing file, version, or backupPath",
+      fix: "pass an applied timeline receipt"
+    };
   }
-  const value = isRecord(parsed) && isRecord(parsed.receipt) ? parsed.receipt : parsed;
-  if (!isRecord(value) || typeof value.file !== "string" || typeof value.version !== "string" || typeof value.backupPath !== "string") {
+  return { ok: true, receipts: values, batch: Array.isArray(value) };
+}
+async function runUndo(args) {
+  const project = resolveProject(typeof args.dir === "string" ? args.dir : void 0);
+  const json = args.json === true;
+  const input = typeof args.receipt === "string" ? args.receipt : positional(args)[1];
+  if (!input)
     return refuse(
       "timeline undo",
-      {
-        reason: "undo receipt is missing file, version, or backupPath",
-        fix: "pass an applied timeline receipt"
-      },
+      { reason: "an undo receipt is required", fix: "pass the receipt JSON or its file" },
       json
     );
+  const undo = readUndoInput(input);
+  if (!undo.ok) return refuse("timeline undo", undo, json);
+  const inputs = undo.receipts.map((receipt) => {
+    const target = join(project.dir, receipt.file);
+    return {
+      sourceFile: receipt.file,
+      absPath: target,
+      before: readFileSync3(target, "utf-8"),
+      after: readFileSync3(join(project.dir, receipt.backupPath), "utf-8"),
+      expectedVersion: receipt.version
+    };
+  });
+  let receipts;
+  try {
+    receipts = applyFileMutations(project.dir, inputs);
+  } catch (error) {
+    if (isFileChanged(error))
+      return refusal(error.message, "read the latest timeline before retrying undo", json);
+    throw error;
   }
-  const backup = join(project.dir, value.backupPath);
-  const target = join(project.dir, value.file);
-  const before = readFileSync3(target, "utf-8");
-  const after = readFileSync3(backup, "utf-8");
-  const receipts = applyFileMutations(project.dir, [
-    { sourceFile: value.file, absPath: target, before, after, expectedVersion: value.version }
-  ]);
   const result = {
     ok: true,
     receipt: receipts.map((receipt) => publicReceipt(receipt)),
-    file: value.file
+    file: undo.batch ? undo.receipts.map((receipt) => receipt.file) : undo.receipts[0].file
   };
   if (json) console.log(JSON.stringify(withMeta(result), null, 2));
-  else console.log(`undid ${value.file}`);
+  else
+    console.log(
+      undo.batch ? `undid ${receipts.length} file${receipts.length === 1 ? "" : "s"}` : `undid ${undo.receipts[0].file}`
+    );
 }
 
 // src/timeline/a2MutationCommand.ts
@@ -1326,52 +1355,67 @@ function mutationCommand(verb) {
     }
   });
 }
+var subCommands = {
+  move: () => mutationCommand("move"),
+  trim: () => mutationCommand("trim"),
+  split: () => mutationCommand("split"),
+  delete: () => mutationCommand("delete"),
+  set: () => mutationCommand("set"),
+  duplicate: () => mutationCommand("duplicate"),
+  ids: () => defineCommand({
+    meta: { name: "ids", description: "Stamp stable ids on timeline clips" },
+    args: { dir: { type: "string" }, json: { type: "boolean", default: false } },
+    async run({ args }) {
+      await runIds(args);
+    }
+  }),
+  apply: () => defineCommand({
+    meta: { name: "apply", description: "Apply an atomic timeline edit plan" },
+    args: {
+      file: { type: "positional", required: true },
+      dir: { type: "string" },
+      json: { type: "boolean", default: false },
+      plan: { type: "boolean", default: false }
+    },
+    async run({ args }) {
+      await runApply(args);
+    }
+  }),
+  undo: () => defineCommand({
+    meta: { name: "undo", description: "Restore a timeline mutation receipt" },
+    args: {
+      receipt: { type: "positional", required: true },
+      dir: { type: "string" },
+      json: { type: "boolean", default: false }
+    },
+    async run({ args }) {
+      await runUndo(args);
+    }
+  })
+};
+function isTimelineSubcommand(first, rawArgs) {
+  if (!first || !Object.hasOwn(subCommands, first)) return false;
+  const separator = rawArgs.indexOf("--");
+  return separator < 0 || rawArgs.indexOf(first) < separator;
+}
 var timeline_default = defineCommand({
   meta: { name: "timeline", description: "Print and edit the project's tracks and clips" },
   args: {
     dir: { type: "positional", description: "Project directory", required: false },
     json: { type: "boolean", description: "Output as JSON", default: false }
   },
-  subCommands: {
-    move: () => mutationCommand("move"),
-    trim: () => mutationCommand("trim"),
-    split: () => mutationCommand("split"),
-    delete: () => mutationCommand("delete"),
-    set: () => mutationCommand("set"),
-    duplicate: () => mutationCommand("duplicate"),
-    ids: () => defineCommand({
-      meta: { name: "ids", description: "Stamp stable ids on timeline clips" },
-      args: { dir: { type: "string" }, json: { type: "boolean", default: false } },
-      async run({ args }) {
-        await runIds(args);
-      }
-    }),
-    apply: () => defineCommand({
-      meta: { name: "apply", description: "Apply an atomic timeline edit plan" },
-      args: {
-        file: { type: "positional", required: true },
-        dir: { type: "string" },
-        json: { type: "boolean", default: false },
-        plan: { type: "boolean", default: false }
-      },
-      async run({ args }) {
-        await runApply(args);
-      }
-    }),
-    undo: () => defineCommand({
-      meta: { name: "undo", description: "Restore a timeline mutation receipt" },
-      args: {
-        receipt: { type: "positional", required: true },
-        dir: { type: "string" },
-        json: { type: "boolean", default: false }
-      },
-      async run({ args }) {
-        await runUndo(args);
-      }
-    })
+  subCommands,
+  setup({ args, rawArgs, cmd }) {
+    const first = args._[0];
+    if (!first || isTimelineSubcommand(first, rawArgs)) return;
+    assertKnownFlags({ args: cmd.args }, rawArgs);
+    const separator = rawArgs.indexOf("--");
+    const directoryIndex = rawArgs.indexOf(first);
+    if (separator < 0 || directoryIndex < separator) rawArgs.splice(directoryIndex, 0, "--");
   },
-  async run({ args }) {
-    if (args._?.[0]) return;
+  async run({ args, rawArgs, cmd }) {
+    if (isTimelineSubcommand(args._[0], rawArgs)) return;
+    resolveExtraPositionals({ args: cmd.args }, "timeline", args);
     const project = resolveProject(args.dir);
     ensureDOMParser();
     const timeline = await describeProject(project.indexPath);

package/dist/{tokens-2OIIBBCW.js → tokens-RT5HWA6C.js}

@@ -11,14 +11,14 @@ import {
   tokensToVariables,
   upsertBindings,
   withFigmaErrors
-} from "./chunk-R2JEKLDZ.js";
-import "./chunk-IHFUKJOR.js";
+} from "./chunk-2DA2BBNY.js";
+import "./chunk-K2FLNJVB.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
 import "./chunk-PBN6GBJE.js";
 import "./chunk-VC76R6W2.js";
-import "./chunk-GK4AIFIH.js";
+import "./chunk-SDYDNHEE.js";
 import "./chunk-ZTZA4UWZ.js";
 import "./chunk-M2WBOQ2Q.js";
 
@@ -76,7 +76,7 @@ var tokens_default = defineCommand({
         console.log("add to data-composition-variables:");
         console.log(JSON.stringify(result.entries, null, 2));
       }
-      const { trackFigmaImport } = await import("./telemetry-FQDKR5XA.js");
+      const { trackFigmaImport } = await import("./telemetry-A23PPRD6.js");
       trackFigmaImport({
         phase: "tokens",
         tokensMode: result.mode,

package/dist/{transcribe-7YTUCXDX.js → transcribe-FOLNOC5G.js}

@@ -10,13 +10,13 @@ import {
 import {
   DEFAULT_MODEL,
   isWhisperUnavailable
-} from "./chunk-PXSM4HPB.js";
-import "./chunk-WCJGTLPF.js";
-import "./chunk-TVCRUG2S.js";
+} from "./chunk-MAYCCGMQ.js";
+import "./chunk-BHVFTYSI.js";
+import "./chunk-ZEUONDQG.js";
 import {
   trackTranscribeUnavailable
-} from "./chunk-XGMNQQTJ.js";
-import "./chunk-LBKDQKWV.js";
+} from "./chunk-RG3QWWIE.js";
+import "./chunk-XU5GGV6R.js";
 import "./chunk-VWG7OQKU.js";
 import "./chunk-GQJZORQP.js";
 import "./chunk-AMKC3AXA.js";
@@ -34,30 +34,33 @@ import {
 import "./chunk-USDEMXXL.js";
 import "./chunk-T76PLPD6.js";
 import "./chunk-FXMKHHPO.js";
-import "./chunk-LCSMOLGX.js";
+import "./chunk-BYSBRF24.js";
 import "./chunk-PJ3HDUCY.js";
 import "./chunk-K4WIOZFP.js";
 import "./chunk-XUXGIA7H.js";
 import "./chunk-WERLJGIC.js";
 import "./chunk-ISN5GRYI.js";
-import "./chunk-DZEVA7DI.js";
+import "./chunk-4OC7MQNB.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
 import {
+  PARAKEET_INSTALL_COMMAND,
   PARAKEET_LANGUAGES,
-  findParakeet,
   parakeetSpeaks,
   transcribeWithParakeet
-} from "./chunk-KDPYVTEU.js";
+} from "./chunk-KBB4RG6F.js";
+import {
+  TRANSCRIPT_FILE
+} from "./chunk-IR35BCLK.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
 import "./chunk-M2WBOQ2Q.js";
 
 // src/commands/transcribe.ts
-import { existsSync, rmSync, writeFileSync } from "fs";
-import { resolve, join, extname, dirname } from "path";
+import { existsSync, realpathSync, rmSync, statSync, writeFileSync } from "fs";
+import { resolve, join, extname, dirname, basename } from "path";
 var examples = [
   ["Transcribe an audio file", "hyperframes transcribe audio.mp3"],
   ["Transcribe a video file", "hyperframes transcribe video.mp4"],
@@ -66,6 +69,7 @@ var examples = [
   ["Import an existing SRT file", "hyperframes transcribe subtitles.srt"],
   ["Import an OpenAI Whisper JSON response", "hyperframes transcribe response.json"],
   ["Export captions to SRT", "hyperframes transcribe transcript.json --to srt"],
+  ["Transcribe a video straight to VTT captions", "hyperframes transcribe video.mp4 --to vtt"],
   [
     "Export single-word/CJK captions without re-grouping",
     "hyperframes transcribe transcript.json --to vtt --preserve-cues"
@@ -110,7 +114,7 @@ var transcribe_default = defineCommand({
     },
     to: {
       type: "string",
-      description: "Export transcript sidecar format: srt or vtt"
+      description: "Write an srt or vtt caption sidecar: exported from a transcript file, or written after transcribing audio/video"
     },
     output: {
       type: "string",
@@ -147,15 +151,9 @@ var transcribe_default = defineCommand({
     const dir = resolve(args.dir ?? dirname(inputPath));
     const ext = extname(inputPath).toLowerCase();
     const isImport = ext === ".json" || ext === ".srt" || ext === ".vtt";
-    const to = parseExportFormat(args.to, args.json);
-    if (to) {
-      if (!isImport) {
-        failWith(
-          "--to can only export from transcript files (.json, .srt, .vtt). Run transcribe first.",
-          args.json
-        );
-      }
-      return exportTranscript(inputPath, dir, to, args.output, args.json, args["preserve-cues"]);
+    const sidecar = parseSidecar(args, inputPath, dir);
+    if (sidecar && isImport) {
+      return exportTranscript(inputPath, sidecar, args.json);
     }
     if (isImport) {
       return importTranscript(inputPath, dir, args.json);
@@ -168,7 +166,8 @@ var transcribe_default = defineCommand({
       json: args.json,
       optional: args.optional,
       installRuntime: args["runtime-install"],
-      timeoutMs
+      timeoutMs,
+      sidecar
     });
   }
 });
@@ -199,14 +198,47 @@ function parseExportFormat(value, json) {
   if (normalized === "srt" || normalized === "vtt") return normalized;
   failWith(`Unsupported caption export format: ${value}. Use srt or vtt.`, json);
 }
+function parseSidecar(args, inputPath, dir) {
+  const to = parseExportFormat(args.to, args.json);
+  if (!to) return void 0;
+  const outPath = resolve(args.output ?? join(dir, `transcript.${to}`));
+  const keep = [inputPath, join(dir, TRANSCRIPT_FILE)];
+  const problem = args.output !== void 0 && outputProblem(args.output, outPath, to) || overwriteProblem(outPath, keep);
+  if (problem) failWith(problem, args.json);
+  return { to, outPath, preserveCues: args["preserve-cues"], keep };
+}
+function outputProblem(output, outPath, to) {
+  if (!output) return "--output needs a file path";
+  const folder = dirname(outPath);
+  if (!existsSync(folder) || !statSync(folder).isDirectory()) {
+    return `Output folder not found: ${folder}`;
+  }
+  if (/[\\/]$/.test(output) || existsSync(outPath) && statSync(outPath).isDirectory()) {
+    return `--output is a folder; give a file path such as ${join(outPath, `transcript.${to}`)}`;
+  }
+  return void 0;
+}
+function overwriteProblem(outPath, keep) {
+  const hit = keep.find((file) => sameFile(outPath, file));
+  return hit && `The caption file would overwrite ${hit}; choose another file with --output`;
+}
+function sameFile(out, file) {
+  if (existsSync(out) && existsSync(file)) {
+    const [a, b] = [statSync(out, { bigint: true }), statSync(file, { bigint: true })];
+    if (a.ino !== 0n && b.ino !== 0n) return a.dev === b.dev && a.ino === b.ino;
+    return realpathSync.native(out) === realpathSync.native(file);
+  }
+  const realDir = (p) => existsSync(dirname(p)) ? realpathSync.native(dirname(p)) : dirname(p);
+  return realDir(out) === realDir(file) && basename(out).toLowerCase() === basename(file).toLowerCase();
+}
 function exitNoWords(json) {
   failWith("No words found in transcript.", json);
 }
 async function importTranscript(inputPath, dir, json) {
-  const { loadTranscript, patchCaptionHtml } = await import("./normalize-IGLHCWTF.js");
+  const { loadTranscript, patchCaptionHtml } = await import("./normalize-U3SL5VG3.js");
   const { words, format } = loadTranscript(inputPath);
   if (words.length === 0) exitNoWords(json);
-  const outPath = join(dir, "transcript.json");
+  const outPath = join(dir, TRANSCRIPT_FILE);
   writeFileSync(outPath, JSON.stringify(words, null, 2));
   patchCaptionHtml(dir, words);
   if (json) {
@@ -219,49 +251,62 @@ async function importTranscript(inputPath, dir, json) {
     );
   }
 }
-async function exportTranscript(inputPath, dir, to, output, json, preserveCues) {
-  const { loadTranscript, formatSrt, formatVtt } = await import("./normalize-IGLHCWTF.js");
-  const { words, format } = loadTranscript(inputPath);
-  if (words.length === 0) exitNoWords(json);
-  const preGrouped = preserveCues || format === "srt" || format === "vtt" || void 0;
-  const outPath = resolve(output ?? join(dir, `transcript.${to}`));
+async function writeCaptionSidecar(words, { to, outPath, preserveCues, keep }, phraseLevelSource) {
+  const hit = keep.find((file) => sameFile(outPath, file));
+  if (hit) throw new Error(`it is the same file as ${hit}`);
+  const { formatSrt, formatVtt } = await import("./normalize-U3SL5VG3.js");
+  const preGrouped = preserveCues || phraseLevelSource;
   const content = to === "srt" ? formatSrt(words, { preGrouped }) : formatVtt(words, { preGrouped });
   writeFileSync(outPath, content);
+}
+function reportSidecar(to, wordCount, outPath) {
+  console.log(
+    `${c.success("\u25C7")}  Exported ${c.accent(String(wordCount))} words to ${c.accent(to.toUpperCase())} \u2192 ${c.accent(outPath)}`
+  );
+}
+async function exportTranscript(inputPath, sidecar, json) {
+  const { loadTranscript } = await import("./normalize-U3SL5VG3.js");
+  const { words, format } = loadTranscript(inputPath);
+  if (words.length === 0) exitNoWords(json);
+  const { outPath } = sidecar;
+  try {
+    await writeCaptionSidecar(words, sidecar, format === "srt" || format === "vtt" || void 0);
+  } catch (err) {
+    failWith(
+      `The caption file ${outPath} could not be written: ${normalizeErrorMessage(err)}`,
+      json
+    );
+  }
   if (json) {
     console.log(
-      JSON.stringify({ ok: true, format: to, wordCount: words.length, outputPath: outPath })
+      JSON.stringify({
+        ok: true,
+        format: sidecar.to,
+        wordCount: words.length,
+        outputPath: outPath
+      })
     );
   } else {
-    console.log(
-      `${c.success("\u25C7")}  Exported ${c.accent(String(words.length))} words to ${c.accent(to.toUpperCase())} \u2192 ${c.accent(outPath)}`
-    );
+    reportSidecar(sidecar.to, words.length, outPath);
   }
 }
-var PARAKEET_INSTALL_COMMAND = "hyperframes models install parakeet";
-function pickRunner(engine, sherpaUsable, language) {
+function pickRunner(engine, parakeet, language) {
   if (engine === "whisper" || !parakeetSpeaks(language)) return "whisper";
-  if (sherpaUsable()) return "sherpa";
-  return findParakeet() ? "parakeet-mlx" : "whisper";
+  return parakeet() ?? "whisper";
 }
 var parakeetFallsBack = (engine) => engine === "auto";
 async function transcribeAudio(inputPath, dir, opts) {
-  const { transcribe } = await import("./transcribe-4F6MK73N.js");
-  const { loadTranscript, patchCaptionHtml } = await import("./normalize-IGLHCWTF.js");
-  const {
-    DecodeCancelled,
-    prepareSherpaWav,
-    sherpaParakeetInstalled,
-    sherpaUnsupportedReason,
-    transcribeWithSherpa
-  } = await import("./sherpa-ZYTNFHD5.js");
-  const { createRenderCancellationScope, stoppedByCancelSignal } = await import("./renderCancellation-X5BEHAZU.js");
+  const { transcribe } = await import("./transcribe-HCF64LQK.js");
+  const { loadTranscript, patchCaptionHtml } = await import("./normalize-U3SL5VG3.js");
+  const { DecodeCancelled, prepareSherpaWav, sherpaUnsupportedReason, transcribeWithSherpa } = await import("./sherpa-LDUB5NLY.js");
+  const { parakeetRunner } = await import("./parakeetRunner-IHLYYMTZ.js");
+  const { createRenderCancellationScope, stoppedByCancelSignal } = await import("./renderCancellation-XF7M7IUP.js");
   const engine = (opts.engine ?? "auto").toLowerCase();
   if (engine !== "auto" && engine !== "parakeet" && engine !== "whisper") {
     failWith(`Unknown --engine: ${opts.engine}. Use auto, parakeet, or whisper.`, !!opts.json);
   }
   const unsupported = sherpaUnsupportedReason();
-  const sherpaUsable = () => !unsupported && sherpaParakeetInstalled();
-  let runner = pickRunner(engine, sherpaUsable, opts.language);
+  let runner = pickRunner(engine, () => parakeetRunner({ unsupported }), opts.language);
   if (engine === "parakeet" && runner === "whisper") {
     failWith(
       !parakeetSpeaks(opts.language) ? `Parakeet does not transcribe --language ${opts.language}; it covers ${PARAKEET_LANGUAGES.split(" ").join(", ")}. Use --engine whisper.` : unsupported ?? `Parakeet is not installed. Install it with: ${PARAKEET_INSTALL_COMMAND} (or use --engine whisper)`,
@@ -320,7 +365,11 @@ async function transcribeAudio(inputPath, dir, opts) {
       const reason = normalizeErrorMessage(err).replace(/\.+$/, "");
       const parakeetError = `Parakeet failed: ${reason}. To repair it, run: ${PARAKEET_INSTALL_COMMAND}`;
       if (!parakeetFallsBack(engine)) throw new Error(parakeetError);
-      runner = pickRunner(engine, () => false, opts.language);
+      runner = pickRunner(
+        engine,
+        () => parakeetRunner({ unsupported, skipSherpa: true }),
+        opts.language
+      );
       spin?.clear();
       console.error(c.warn(`${parakeetError}. Using ${runner} for this run.`));
       spin?.start(`Transcribing with ${label(runner)}...`);
@@ -337,6 +386,19 @@ async function transcribeAudio(inputPath, dir, opts) {
     const { words } = loadTranscript(result.transcriptPath);
     writeFileSync(result.transcriptPath, JSON.stringify(words, null, 2));
     patchCaptionHtml(dir, words);
+    const { sidecar } = opts;
+    if (sidecar) {
+      try {
+        await writeCaptionSidecar(words, sidecar, false);
+      } catch (err) {
+        const message = `Transcript saved to ${result.transcriptPath}, but the caption file ${sidecar.outPath} could not be written: ${normalizeErrorMessage(err)}`;
+        if (opts.json) console.log(JSON.stringify({ ok: false, error: message }));
+        else spin?.stop(c.error(message));
+        setCommandExitCode(1);
+        return;
+      }
+    }
+    const exported = sidecar && { format: sidecar.to, outputPath: sidecar.outPath };
     if (opts.json) {
       console.log(
         JSON.stringify({
@@ -347,7 +409,8 @@ async function transcribeAudio(inputPath, dir, opts) {
           wordCount: words.length,
           durationSeconds: result.durationSeconds,
           speechOnsetSeconds: result.speechOnsetSeconds,
-          transcriptPath: result.transcriptPath
+          transcriptPath: result.transcriptPath,
+          ...exported
         })
       );
     } else {
@@ -357,6 +420,7 @@ async function transcribeAudio(inputPath, dir, opts) {
           `Transcribed ${c.accent(String(words.length))} words (${result.durationSeconds.toFixed(1)}s${onsetNote})`
         )
       );
+      if (exported) reportSidecar(exported.format, words.length, exported.outputPath);
     }
   } catch (err) {
     if (err instanceof DecodeCancelled || cancellation?.signal.aborted) {