@outerlayer/cli 0.32.0 → 0.33.0-next.20261021171625

package/dist/emit-demo-cmd-JOVCVXIS.js

@@ -0,0 +1,888 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { runEmitArtifact } from './chunk-LRBOBYQI.js';
+import './chunk-XFS2TMOB.js';
+import './chunk-INCKTGMM.js';
+import './chunk-ESVW4MJY.js';
+import './chunk-TBT347UY.js';
+import { VOICE_PACK_FILES, VOICE_PACK_VERSION } from './chunk-LK2S5XZH.js';
+import { detectActiveSession, autoConnect } from './chunk-X2Y3B4JH.js';
+import './chunk-LESWVXRE.js';
+import './chunk-3H7NZPYG.js';
+import { resolveRepoIdentity } from './chunk-XT5SOJRC.js';
+import './chunk-ZAJKEHIE.js';
+import './chunk-6C3ZVE62.js';
+import './chunk-G2JWZDFA.js';
+import { C } from './chunk-ANPNT6PM.js';
+import { defaultFetch, resolveGatewayCredentials } from './chunk-F3EF56LQ.js';
+import './chunk-PJDQPF5N.js';
+import './chunk-APSYTJ6I.js';
+import './chunk-KP6R7CV3.js';
+import './chunk-HDSDUTX4.js';
+import './chunk-NHXJU7CM.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-2O5KA67H.js';
+import './chunk-BKO6JEZI.js';
+import './chunk-HCVLP7XA.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-YW4PEGLN.js';
+import './chunk-5BHIBJDA.js';
+import './chunk-CDDED64E.js';
+import './chunk-RA3O54FC.js';
+import { launchedItemForSession } from './chunk-T2Q7ISPE.js';
+import './chunk-WZBHBH3J.js';
+import './chunk-CRB3POP4.js';
+import './chunk-URIZRCRY.js';
+import './chunk-TUSYOL2O.js';
+import './chunk-JUXATN46.js';
+import { ARTIFACT_MAX_BYTES, ARTIFACT_MAX_CAPTION_LENGTH, DEMO_RECORD_MEDIA_TYPE, DemoManifestSchema } from './chunk-3WW2TL7V.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import './chunk-XD4ZCMA4.js';
+import './chunk-MESOOLF4.js';
+import './chunk-Z5GEFMRW.js';
+import { createHash } from 'crypto';
+import { mkdtempSync, statSync, readFileSync, writeFileSync, rmSync, mkdirSync, accessSync, constants, existsSync, renameSync, createReadStream, createWriteStream } from 'fs';
+import { tmpdir } from 'os';
+import { resolve, join, dirname, delimiter, normalize, sep } from 'path';
+import { execFileSync } from 'child_process';
+import { once } from 'events';
+import { createRequire as createRequire$1 } from 'module';
+import { createGunzip } from 'zlib';
+
+createRequire(import.meta.url);
+
+// src/demo/criteria.ts
+async function readRecordedCriteriaIds(params) {
+  const endpoint = new URL(`/v1/work-items/${params.item}`, params.url).toString();
+  const response = await params.fetchImpl(endpoint, {
+    method: "GET",
+    headers: { authorization: `Bearer ${params.apiKey}`, "x-outerlayer-app-id": params.appId }
+  });
+  if (!response.ok) throw new Error(`reading item ${params.item} failed (${response.status})`);
+  const body = await response.json();
+  const items = body.data?.criteria?.items;
+  if (!Array.isArray(items)) return void 0;
+  return new Set(items.flatMap((entry) => typeof entry.id === "string" ? [entry.id] : []));
+}
+
+// src/demo/fit.ts
+var MAX_TEMPO = 1.3;
+var SPEECH_LEAD_IN = 0.2;
+var SPEECH_TAIL = 0.2;
+var EPSILON = 1e-6;
+function fitSpeech(speechSeconds, chapterSeconds) {
+  const budget = chapterSeconds - SPEECH_LEAD_IN - SPEECH_TAIL;
+  if (budget > 0 && speechSeconds <= budget + EPSILON) return { ok: true, tempo: 1 };
+  if (budget > 0 && speechSeconds / budget <= MAX_TEMPO + EPSILON) {
+    return { ok: true, tempo: Math.min(MAX_TEMPO, speechSeconds / budget) };
+  }
+  return { ok: false, overrunSeconds: speechSeconds / MAX_TEMPO - budget };
+}
+
+// src/demo/manifest-checks.ts
+var END_TOLERANCE_SECONDS = 0.05;
+function chapterLabel(index, title) {
+  return `chapter ${index + 1} ("${title}")`;
+}
+function checkManifest(params) {
+  const { manifest, videoSeconds, recordedIds } = params;
+  const seen = /* @__PURE__ */ new Map();
+  let previousEnd = 0;
+  for (const [index, chapter] of manifest.chapters.entries()) {
+    const label = chapterLabel(index, chapter.title);
+    if (chapter.end > videoSeconds + END_TOLERANCE_SECONDS) {
+      return `${label} ends at ${chapter.end} s, but the video is ${videoSeconds.toFixed(1)} s long`;
+    }
+    if (chapter.start < previousEnd - END_TOLERANCE_SECONDS) {
+      return `${label} starts at ${chapter.start} s, before the previous chapter ends at ${previousEnd} s \u2014 chapters must be in order and must not overlap`;
+    }
+    previousEnd = chapter.end;
+    if (chapter.criterionId === null) {
+      if (index !== 0) {
+        return `${label} names no criterion \u2014 only the opening chapter may omit one`;
+      }
+      continue;
+    }
+    const first = seen.get(chapter.criterionId);
+    if (first !== void 0) {
+      return `${label} names criterion ${chapter.criterionId}, which chapter ${first + 1} already shows \u2014 one chapter proves each criterion`;
+    }
+    seen.set(chapter.criterionId, index);
+    if (recordedIds !== void 0 && !recordedIds.has(chapter.criterionId)) {
+      return `${label} names criterion ${chapter.criterionId}, which is not on the item's recorded criteria \u2014 record it with \`emit criteria\`, or fix the id`;
+    }
+  }
+  return void 0;
+}
+function findProgram(name, env, platform = process.platform) {
+  const dirs = (env.PATH ?? env.Path ?? "").split(platform === "win32" ? ";" : delimiter).filter((dir) => dir !== "");
+  const extensions = platform === "win32" ? ["", ...(env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((ext) => ext !== "")] : [""];
+  for (const dir of dirs) {
+    for (const extension of extensions) {
+      const candidate = join(dir, name + extension);
+      try {
+        if (!statSync(candidate).isFile()) continue;
+        if (platform !== "win32") accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+var INSTALL_HINT = {
+  ffmpeg: "ffmpeg (apt install ffmpeg, brew install ffmpeg, or winget install Gyan.FFmpeg)",
+  ffprobe: "ffmpeg, which includes ffprobe (apt install ffmpeg, brew install ffmpeg, or winget install Gyan.FFmpeg)",
+  "espeak-ng": "espeak-ng (apt install espeak-ng, brew install espeak-ng, or the eSpeak NG installer on Windows)"
+};
+function missingProgramMessage(name, narrated) {
+  const hint = INSTALL_HINT[name] ?? name;
+  const base = `install ${hint}, then run the command again`;
+  return name === "espeak-ng" && narrated ? `espeak-ng is not on PATH \u2014 ${base}, or pass --no-narration to store the clips without speech` : `${name} is not on PATH \u2014 ${base}`;
+}
+
+// src/demo/media.ts
+function clipArgs(plan) {
+  const duration = plan.end - plan.start;
+  const audio = plan.audio;
+  const delayMs = audio === void 0 ? 0 : Math.round(audio.delaySeconds * 1e3);
+  const speech = audio === void 0 ? [] : [
+    "-filter_complex",
+    `[1:a]${audio.tempo === 1 ? "" : `atempo=${audio.tempo.toFixed(4)},`}adelay=${delayMs}:all=1,aresample=48000[speech]`,
+    "-map",
+    "[speech]",
+    "-c:a",
+    "libopus",
+    "-b:a",
+    "48k"
+  ];
+  return [
+    "-y",
+    "-v",
+    "error",
+    // The cut sits before the input and the clip is re-encoded, so it starts on the exact frame, not the nearest key frame.
+    "-ss",
+    plan.start.toFixed(3),
+    "-t",
+    duration.toFixed(3),
+    "-i",
+    plan.video,
+    ...audio === void 0 ? [] : ["-i", audio.wavPath],
+    "-map",
+    "0:v:0",
+    ...audio === void 0 ? ["-an"] : speech,
+    "-c:v",
+    "libvpx-vp9",
+    "-b:v",
+    "0",
+    "-crf",
+    "38",
+    "-deadline",
+    "realtime",
+    "-cpu-used",
+    "6",
+    "-row-mt",
+    "1",
+    "-pix_fmt",
+    "yuv420p",
+    // Without these, the WebM muxer writes a random segment id, and the same cut gives different bytes on every run.
+    "-fflags",
+    "+bitexact",
+    "-flags:v",
+    "+bitexact",
+    "-flags:a",
+    "+bitexact",
+    "-t",
+    duration.toFixed(3),
+    plan.output
+  ];
+}
+function durationFromProbe(formatDuration, lastPacketLines) {
+  const declared = Number(formatDuration);
+  if (Number.isFinite(declared) && declared > 0) return declared;
+  const packets = lastPacketLines.split("\n").filter((line) => line.trim() !== "").map((line) => line.split(",").map(Number)).filter((fields) => Number.isFinite(fields[0]));
+  const last = packets.at(-1);
+  if (last === void 0) return void 0;
+  return last[0] + (Number.isFinite(last[1]) ? last[1] : 0);
+}
+var TOOL_TIMEOUT_MS = 10 * 60 * 1e3;
+function createMediaTools(env, exec = execFileSync) {
+  const ffmpeg = findProgram("ffmpeg", env) ?? "ffmpeg";
+  const ffprobe = findProgram("ffprobe", env) ?? "ffprobe";
+  const run = (program, args) => exec(program, args, {
+    encoding: "utf8",
+    env,
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: TOOL_TIMEOUT_MS
+  });
+  return {
+    probe(video) {
+      const format = run(ffprobe, ["-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", video]);
+      const declared = durationFromProbe(format, "");
+      if (declared !== void 0) return declared;
+      const lines = run(ffprobe, ["-v", "error", "-select_streams", "v:0", "-show_entries", "packet=pts_time,duration_time", "-of", "csv=p=0", video]);
+      const duration = durationFromProbe("", lines);
+      if (duration === void 0) throw new Error(`cannot read the length of ${video}`);
+      return duration;
+    },
+    renderClip(plan) {
+      run(ffmpeg, clipArgs(plan));
+    }
+  };
+}
+
+// src/demo/record.ts
+function chapterPassed(checks) {
+  return checks.length > 0 && checks.every((check) => check.passed);
+}
+function buildDemoRecord(manifest, clips) {
+  if (clips.length !== manifest.chapters.length) {
+    throw new Error(`the demo has ${manifest.chapters.length} chapters but ${clips.length} clips`);
+  }
+  return {
+    schemaVersion: 1,
+    chapters: manifest.chapters.map((chapter, index) => ({
+      criterionId: chapter.criterionId,
+      start: chapter.start,
+      end: chapter.end,
+      title: chapter.title,
+      narration: chapter.narration,
+      checks: chapter.checks,
+      clipArtifactId: clips[index].clipArtifactId,
+      bound: clips[index].bound
+    }))
+  };
+}
+var VoiceDownloadError = class extends Error {
+  constructor(message, retryable = false) {
+    super(message);
+    this.retryable = retryable;
+  }
+};
+async function sha256OfFile(path) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+function withoutCredentials(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.toString();
+  } catch {
+    return "(an invalid URL)";
+  }
+}
+var ATTEMPTS = 3;
+async function requestRest(params) {
+  const { url, part, name, fetchImpl, progress } = params;
+  const offset = existsSync(part) ? statSync(part).size : 0;
+  const response = await fetchImpl(url, offset > 0 ? { headers: { range: `bytes=${offset}-` } } : {});
+  if (response.status === 416 && offset > 0) {
+    await response.body?.cancel();
+    return;
+  }
+  if (!response.ok || response.body === null) {
+    await response.body?.cancel();
+    throw new VoiceDownloadError(`cannot download ${name} from ${withoutCredentials(url)}: the server answered ${response.status}`, response.status >= 500);
+  }
+  const resumed = response.status === 206;
+  const start = resumed ? offset : 0;
+  const total = Number(response.headers.get("content-length") ?? 0) + start;
+  const out = createWriteStream(part, { flags: resumed ? "a" : "w" });
+  let written = start;
+  let lastReport = 0;
+  try {
+    for await (const chunk of response.body) {
+      if (!out.write(chunk)) await once(out, "drain");
+      written += chunk.length;
+      const now = Date.now();
+      if (progress !== void 0 && now - lastReport >= 1e3) {
+        lastReport = now;
+        progress(`  downloading ${name}: ${(written / 1048576).toFixed(0)}${total > start ? ` of ${(total / 1048576).toFixed(0)}` : ""} MiB`);
+      }
+    }
+  } finally {
+    out.end();
+    await once(out, "close");
+  }
+}
+async function downloadPinned(params) {
+  const { url, dest, sha256, name } = params;
+  mkdirSync(dirname(dest), { recursive: true });
+  const part = `${dest}.part`;
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      await requestRest({ ...params, part });
+      break;
+    } catch (err) {
+      const refused = err instanceof VoiceDownloadError && !err.retryable;
+      if (refused || attempt === ATTEMPTS) {
+        throw err instanceof VoiceDownloadError ? err : new VoiceDownloadError(`cannot download ${name} from ${withoutCredentials(url)}: ${String(err)}`);
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, params.retryDelayMs ?? 500));
+    }
+  }
+  const digest = await sha256OfFile(part);
+  if (digest !== sha256) {
+    rmSync(part, { force: true });
+    throw new VoiceDownloadError(
+      `the downloaded ${name} has sha256 ${digest}, not the pinned ${sha256} \u2014 it was discarded and nothing was spoken`
+    );
+  }
+  renameSync(part, dest);
+}
+var PUNCTUATION = ';:,.!?\xA1\xBF\u2014\u2026"\xAB\xBB\u201C\u201D(){}[]';
+var PUNCTUATION_RUN = new RegExp(`(\\s*[${PUNCTUATION.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}]+\\s*)+`, "g");
+function splitYear(text) {
+  if (text.includes(".")) return text;
+  if (text.includes(":")) {
+    const [hours, minutes] = text.split(":").map(Number);
+    return minutes === 0 ? `${hours} o'clock` : minutes < 10 ? `${hours} oh ${minutes}` : `${hours} ${minutes}`;
+  }
+  const year = parseInt(text.slice(0, 4), 10);
+  if (year < 1100 || year % 1e3 < 10) return text;
+  const high = text.slice(0, 2);
+  const low = parseInt(text.slice(2, 4), 10);
+  const plural = text.endsWith("s") ? "s" : "";
+  if (low === 0) return `${high} hundred${plural}`;
+  if (low < 10) return `${high} oh ${low}${plural}`;
+  return `${high} ${low}${plural}`;
+}
+function spellMoney(text) {
+  const unit = text[0] === "$" ? "dollar" : "pound";
+  if (Number.isNaN(Number(text.slice(1)))) return `${text.slice(1)} ${unit}s`;
+  if (!text.includes(".")) return `${text.slice(1)} ${unit}${text.slice(1) === "1" ? "" : "s"}`;
+  const [whole, fraction] = text.slice(1).split(".");
+  const cents = parseInt(fraction.padEnd(2, "0"), 10);
+  const small = text[0] === "$" ? cents === 1 ? "cent" : "cents" : cents === 1 ? "penny" : "pence";
+  return `${whole} ${unit}${whole === "1" ? "" : "s"} and ${cents} ${small}`;
+}
+function spellDecimal(text) {
+  const [whole, fraction] = text.split(".");
+  return `${whole} point ${fraction.split("").join(" ")}`;
+}
+function prepareText(text) {
+  return text.replace(/[‘’]/g, "'").replace(/«/g, "\u201C").replace(/»/g, "\u201D").replace(/[“”]/g, '"').replace(/\(/g, "\xAB").replace(/\)/g, "\xBB").replace(/、/g, ", ").replace(/。/g, ". ").replace(/！/g, "! ").replace(/，/g, ", ").replace(/：/g, ": ").replace(/；/g, "; ").replace(/？/g, "? ").replace(/[^\S \n]/g, " ").replace(/ {2,}/g, " ").replace(/(?<=\n) +(?=\n)/g, "").replace(/\bD[Rr]\.(?= [A-Z])/g, "Doctor").replace(/\b(?:Mr\.|MR\.(?= [A-Z]))/g, "Mister").replace(/\b(?:Ms\.|MS\.(?= [A-Z]))/g, "Miss").replace(/\b(?:Mrs\.|MRS\.(?= [A-Z]))/g, "Mrs").replace(/\betc\.(?! [A-Z])/gi, "etc").replace(/\b(y)eah?\b/gi, "$1e'a").replace(/\d*\.\d+|\b\d{4}s?\b|(?<!:)\b(?:[1-9]|1[0-2]):[0-5]\d\b(?!:)/g, splitYear).replace(/(?<=\d),(?=\d)/g, "").replace(/[$£]\d+(?:\.\d+)?(?: hundred| thousand| (?:[bm]|tr)illion)*\b|[$£]\d+\.\d\d?\b/gi, spellMoney).replace(/\d*\.\d+/g, spellDecimal).replace(/(?<=\d)-(?=\d)/g, " to ").replace(/(?<=\d)S/g, " S").replace(/(?<=[BCDFGHJ-NP-TV-Z])'?s\b/g, "'S").replace(/(?<=X')S\b/g, "s").replace(/(?:[A-Za-z]\.){2,} [a-z]/g, (match) => match.replace(/\./g, "-")).replace(/(?<=[A-Z])\.(?=[A-Z])/gi, "-").trim();
+}
+function splitOnPunctuation(text) {
+  const parts = [];
+  let at = 0;
+  for (const match of text.matchAll(PUNCTUATION_RUN)) {
+    const index = match.index ?? 0;
+    if (at < index) parts.push({ punctuation: false, text: text.slice(at, index) });
+    parts.push({ punctuation: true, text: match[0] });
+    at = index + match[0].length;
+  }
+  if (at < text.length) parts.push({ punctuation: false, text: text.slice(at) });
+  return parts;
+}
+function normalizePhonemes(ipa) {
+  return ipa.replace(/kəkˈoːɹoʊ/g, "k\u02C8o\u028Ak\u0259\u0279o\u028A").replace(/kəkˈɔːɹəʊ/g, "k\u02C8\u0259\u028Ak\u0259\u0279\u0259\u028A").replace(/ʲ/g, "j").replace(/r/g, "\u0279").replace(/x/g, "k").replace(/ɬ/g, "l").replace(/(?<=[a-zɹː])(?=hˈʌndɹɪd)/g, " ").replace(/ z(?=[;:,.!?¡¿—…"«»“” ]|$)/g, "z").replace(/(?<=nˈaɪn)ti(?!ː)/g, "di").trim();
+}
+var ESPEAK_TIMEOUT_MS = 60 * 1e3;
+function espeakRunner(espeakPath, run = execFileSync) {
+  return (words) => run(espeakPath, ["-q", "--ipa", "-v", "en-us"], { input: words, encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: ESPEAK_TIMEOUT_MS }).split("\n").map((line) => line.trim()).filter((line) => line !== "").join(" ");
+}
+function phonemize(text, ipa) {
+  const parts = splitOnPunctuation(prepareText(text));
+  return normalizePhonemes(parts.map((part) => part.punctuation ? part.text : ipa(part.text)).join(""));
+}
+
+// src/demo/voice/kokoro.ts
+var SAMPLE_RATE = 24e3;
+var VOICE_ROWS = 510;
+var STYLE_SIZE = 256;
+var SENTENCE_GAP = 0.18;
+function tokenize(phonemes, vocab) {
+  const ids = [];
+  for (const symbol of phonemes) {
+    const id = vocab[symbol];
+    if (id !== void 0) ids.push(id);
+  }
+  return [0, ...ids, 0];
+}
+function styleRow(voice, tokenCount) {
+  const row = Math.min(Math.max(tokenCount - 2, 0), VOICE_ROWS - 1);
+  return voice.slice(row * STYLE_SIZE, (row + 1) * STYLE_SIZE);
+}
+function splitSentences(text) {
+  return text.split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter((sentence) => sentence !== "");
+}
+function encodeWav(samples, sampleRate = SAMPLE_RATE) {
+  const data = Buffer.alloc(samples.length * 2);
+  samples.forEach((sample, index) => data.writeInt16LE(Math.round(Math.max(-1, Math.min(1, sample)) * 32767), index * 2));
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + data.length, 4);
+  header.write("WAVEfmt ", 8);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(1, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(sampleRate * 2, 28);
+  header.writeUInt16LE(2, 32);
+  header.writeUInt16LE(16, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(data.length, 40);
+  return Buffer.concat([header, data]);
+}
+function createKokoroSpeaker(opts) {
+  const ipa = opts.ipa ?? espeakRunner(opts.espeakPath);
+  let loaded;
+  let counter = 0;
+  const load = async () => {
+    if (loaded !== void 0) return loaded;
+    const ort = createRequire$1(join(opts.runtimeDir, "package.json"))("onnxruntime-node");
+    const session = await ort.InferenceSession.create(join(opts.packDir, "model.onnx"));
+    const vocab = JSON.parse(readFileSync(join(opts.packDir, "tokenizer.json"), "utf8")).model.vocab;
+    const bytes = readFileSync(join(opts.packDir, "af_heart.bin"));
+    const voice = new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+    loaded = { ort, session, vocab, voice };
+    return loaded;
+  };
+  return async (text) => {
+    const { ort, session, vocab, voice } = await load();
+    const pieces = [];
+    for (const sentence of splitSentences(text)) {
+      const ids = tokenize(phonemize(sentence, ipa), vocab).slice(0, VOICE_ROWS + 1);
+      if (ids.length <= 2) continue;
+      const out = await session.run({
+        input_ids: new ort.Tensor("int64", BigInt64Array.from(ids.map(BigInt)), [1, ids.length]),
+        style: new ort.Tensor("float32", styleRow(voice, ids.length), [1, STYLE_SIZE]),
+        speed: new ort.Tensor("float32", Float32Array.of(1), [1])
+      });
+      if (pieces.length > 0) pieces.push(new Float32Array(Math.round(SENTENCE_GAP * SAMPLE_RATE)));
+      pieces.push(out.waveform.data);
+    }
+    const length = pieces.reduce((sum, piece) => sum + piece.length, 0);
+    if (length === 0) throw new Error(`the narration line "${text}" has nothing to say`);
+    const samples = new Float32Array(length);
+    let at = 0;
+    for (const piece of pieces) {
+      samples.set(piece, at);
+      at += piece.length;
+    }
+    counter += 1;
+    const wavPath = join(opts.workDir, `speech-${counter}.wav`);
+    writeFileSync(wavPath, encodeWav(samples));
+    return { wavPath, seconds: samples.length / SAMPLE_RATE };
+  };
+}
+var BLOCK = 512;
+function field(block, start, length) {
+  const raw = block.subarray(start, start + length);
+  const end = raw.indexOf(0);
+  return raw.subarray(0, end === -1 ? raw.length : end).toString("utf8");
+}
+function octal(block, start, length) {
+  return parseInt(field(block, start, length), 8) || 0;
+}
+function paxPath(data) {
+  let at = 0;
+  while (at < data.length) {
+    const space = data.indexOf(32, at);
+    if (space === -1) return void 0;
+    const length = Number(data.subarray(at, space).toString("utf8"));
+    if (!Number.isFinite(length) || length <= 0) return void 0;
+    const record = data.subarray(space + 1, at + length - 1).toString("utf8");
+    if (record.startsWith("path=")) return record.slice("path=".length);
+    at += length;
+  }
+  return void 0;
+}
+async function extractNpmTarball(tarball, destDir, keep = () => true) {
+  let pending = Buffer.alloc(0);
+  let header;
+  let longPath;
+  let remaining = 0;
+  let padding = 0;
+  let collected = [];
+  let sink;
+  const finished = [];
+  const closeSink = () => {
+    const done = sink;
+    sink = void 0;
+    if (done !== void 0) {
+      finished.push(new Promise((resolve2, reject) => done.on("close", resolve2).on("error", reject)));
+      done.end();
+    }
+  };
+  const startEntry = (entry) => {
+    header = entry;
+    remaining = entry.size;
+    padding = (BLOCK - entry.size % BLOCK) % BLOCK;
+    collected = [];
+    if (entry.type !== "0" && entry.type !== "\0") return;
+    const relative = entry.path.split("/").slice(1).join("/");
+    if (relative === "" || !keep(relative)) return;
+    const target = normalize(join(destDir, relative));
+    if (!target.startsWith(normalize(destDir) + sep)) throw new Error(`the archive has a path outside its folder: ${entry.path}`);
+    mkdirSync(dirname(target), { recursive: true });
+    sink = createWriteStream(target, { mode: 493 });
+  };
+  const consume = (chunk) => {
+    pending = Buffer.concat([pending, chunk]);
+    for (; ; ) {
+      if (header === void 0) {
+        if (pending.length < BLOCK) return;
+        const block = pending.subarray(0, BLOCK);
+        pending = pending.subarray(BLOCK);
+        const name = field(block, 0, 100);
+        const prefix = field(block, 345, 155);
+        const type = String.fromCharCode(block[156] ?? 48);
+        const path = longPath ?? (prefix === "" ? name : `${prefix}/${name}`);
+        longPath = void 0;
+        startEntry({ path, size: octal(block, 124, 12), type });
+        continue;
+      }
+      if (remaining > 0) {
+        if (pending.length === 0) return;
+        const take = Math.min(remaining, pending.length);
+        const part = pending.subarray(0, take);
+        pending = pending.subarray(take);
+        remaining -= take;
+        if (sink !== void 0) sink.write(part);
+        else if (header.type === "x") collected.push(Buffer.from(part));
+        continue;
+      }
+      if (pending.length < padding) return;
+      pending = pending.subarray(padding);
+      if (header.type === "x") longPath = paxPath(Buffer.concat(collected));
+      closeSink();
+      header = void 0;
+    }
+  };
+  await new Promise((resolve2, reject) => {
+    const input = createReadStream(tarball).on("error", reject);
+    const gunzip = createGunzip();
+    input.pipe(gunzip);
+    gunzip.on("data", (chunk) => {
+      try {
+        consume(chunk);
+      } catch (err) {
+        input.destroy();
+        reject(err);
+        return;
+      }
+      const writing = sink;
+      if (writing !== void 0 && writing.writableNeedDrain) {
+        gunzip.pause();
+        writing.once("drain", () => gunzip.resume());
+      }
+    }).on("end", resolve2).on("error", reject);
+  });
+  closeSink();
+  await Promise.all(finished);
+}
+
+// src/demo/voice/pack.ts
+var VoicePackError = class extends Error {
+};
+var DEFAULT_VOICE_PACK_PINS = { version: VOICE_PACK_VERSION, files: VOICE_PACK_FILES };
+var IMAGE_VOICE_ROOT = "/opt/outerlayer/voice";
+function voicePackHomeDir(home, version) {
+  return join(home, ".outerlayer", "voice", version);
+}
+function mismatch(file, actual, dir) {
+  return new VoicePackError(
+    `the voice pack file ${file.name} does not match its pinned sha256 (expected ${file.sha256}, found ${actual}). Delete ${join(dir, file.name)} to download it again. Nothing was spoken.`
+  );
+}
+async function verifyPresent(dir, pins) {
+  const missing = [];
+  for (const file of pins.files) {
+    const path = join(dir, file.name);
+    if (!existsSync(path)) {
+      missing.push(file.name);
+      continue;
+    }
+    const actual = await sha256OfFile(path);
+    if (actual !== file.sha256) throw mismatch(file, actual, dir);
+  }
+  return missing;
+}
+async function ensureVoicePack(opts) {
+  const pins = opts.pins ?? DEFAULT_VOICE_PACK_PINS;
+  const env = opts.env ?? process.env;
+  const log = opts.log ?? (() => void 0);
+  const installed = join(opts.installedRoot ?? IMAGE_VOICE_ROOT, pins.version);
+  if (existsSync(installed)) {
+    const missing2 = await verifyPresent(installed, pins);
+    if (missing2.length === 0) return { dir: installed, version: pins.version };
+  }
+  const dir = voicePackHomeDir(opts.home, pins.version);
+  const missing = await verifyPresent(dir, pins);
+  if (missing.length === 0) return { dir, version: pins.version };
+  const mirror = env.OUTERLAYER_VOICE_MIRROR?.replace(/\/+$/, "");
+  log(`Downloading the narration voice pack to ${dir} (first narrated run only; later runs use the copy there)`);
+  mkdirSync(dir, { recursive: true });
+  for (const file of pins.files.filter((entry) => missing.includes(entry.name))) {
+    await downloadPinned({
+      url: mirror !== void 0 ? `${mirror}/${encodeURIComponent(file.name)}` : file.url,
+      dest: join(dir, file.name),
+      sha256: file.sha256,
+      name: file.name,
+      fetchImpl: opts.fetchImpl ?? fetch,
+      progress: log
+    });
+  }
+  return { dir, version: pins.version };
+}
+var RUNTIME_PACKAGES = [
+  { prefix: "onnxruntime-node-", folder: "onnxruntime-node" },
+  { prefix: "onnxruntime-common-", folder: "onnxruntime-common" }
+];
+async function ensureVoiceRuntime(pack, pins, home) {
+  const dir = join(voicePackHomeDir(home, pack.version), "runtime", `${process.platform}-${process.arch}`);
+  const archives = RUNTIME_PACKAGES.map(({ prefix, folder }) => {
+    const file = pins.files.find((entry) => entry.name.startsWith(prefix) && entry.name.endsWith(".tgz"));
+    if (file === void 0) throw new VoicePackError(`the voice pack pins no ${folder} archive`);
+    return { file, folder };
+  });
+  const marker = join(dir, ".complete");
+  const wanted = JSON.stringify(archives.map(({ file }) => [file.name, file.sha256]));
+  if (existsSync(marker) && readFileSync(marker, "utf8") === wanted) return { dir };
+  rmSync(dir, { recursive: true, force: true });
+  mkdirSync(dir, { recursive: true });
+  const nativeDir = `bin/napi-v3/${process.platform}/${process.arch}/`;
+  for (const { file, folder } of archives) {
+    await extractNpmTarball(join(pack.dir, file.name), join(dir, "node_modules", folder), (path) => {
+      if (path.startsWith("bin/")) return path.startsWith(nativeDir);
+      return path === "package.json" || path === "LICENSE" || path.startsWith("dist/");
+    });
+  }
+  if (!existsSync(join(dir, "node_modules", "onnxruntime-node", nativeDir))) {
+    rmSync(dir, { recursive: true, force: true });
+    throw new VoicePackError(`the ONNX Runtime has no build for ${process.platform} ${process.arch}, so narration cannot run here; pass --no-narration`);
+  }
+  writeFileSync(join(dir, "package.json"), '{"private":true}\n');
+  writeFileSync(marker, wanted);
+  return { dir };
+}
+
+// src/emit-demo-cmd.ts
+var EmitDemoError = class extends Error {
+};
+var MIB = 1024 * 1024;
+function parseManifest(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    throw new EmitDemoError(`cannot read the manifest "${path}": ${String(err)}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    throw new EmitDemoError(`the manifest "${path}" is not valid JSON: ${String(err)}`);
+  }
+  const parsed = DemoManifestSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const where = issue.path.length > 0 ? ` at ${issue.path.join(".")}` : "";
+    throw new EmitDemoError(`the manifest "${path}" is not valid${where}: ${issue.message}`);
+  }
+  const videoPath = resolve(dirname(path), parsed.data.video);
+  try {
+    if (!statSync(videoPath).isFile()) throw new Error("not a file");
+  } catch {
+    throw new EmitDemoError(`the manifest names the video "${parsed.data.video}", but ${videoPath} does not exist`);
+  }
+  return { manifest: parsed.data, videoPath, text };
+}
+async function runEmitDemo(opts) {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+  const home = opts.home ?? homeFromEnv(env);
+  const say = (line) => {
+    if (!opts.quiet) process.stderr.write(`${line}
+`);
+  };
+  const { manifest, videoPath, text: manifestText } = parseManifest(resolve(cwd, opts.manifest));
+  const narrated = opts.noNarration !== true && manifest.chapters.some((chapter) => chapter.narration.trim() !== "");
+  for (const program of narrated ? ["ffmpeg", "ffprobe", "espeak-ng"] : ["ffmpeg", "ffprobe"]) {
+    if (findProgram(program, env) === void 0) throw new EmitDemoError(missingProgramMessage(program, narrated));
+  }
+  const fetchImpl = opts.fetchImpl ?? defaultFetch;
+  const media = opts.media ?? createMediaTools(env);
+  const recordedIds = await recordedCriteria({ opts, env, cwd, home, fetchImpl, say });
+  let videoSeconds;
+  try {
+    videoSeconds = media.probe(videoPath);
+  } catch (err) {
+    throw new EmitDemoError(`cannot read the video ${videoPath}: ${String(err)}`);
+  }
+  const problem = checkManifest({ manifest, videoSeconds, recordedIds });
+  if (problem !== void 0) throw new EmitDemoError(problem);
+  const work = mkdtempSync(join(tmpdir(), "outerlayer-demo-"));
+  try {
+    const speaker = narrated ? opts.speaker ?? await realSpeaker({ env, home, work, say }) : void 0;
+    const plans = [];
+    for (const [index, chapter] of manifest.chapters.entries()) {
+      const plan = {
+        video: videoPath,
+        start: chapter.start,
+        end: chapter.end,
+        output: join(work, `chapter-${String(index + 1).padStart(2, "0")}.webm`)
+      };
+      if (speaker !== void 0 && chapter.narration.trim() !== "") {
+        let speech;
+        try {
+          speech = await speaker(chapter.narration);
+        } catch (err) {
+          throw new EmitDemoError(`${chapterLabel(index, chapter.title)}: the narration could not be spoken: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const fit = fitSpeech(speech.seconds, chapter.end - chapter.start);
+        if (!fit.ok) {
+          throw new EmitDemoError(
+            `${chapterLabel(index, chapter.title)}: the narration runs ${fit.overrunSeconds.toFixed(1)} s too long even at 1.3 times speed \u2014 shorten the line or lengthen the chapter`
+          );
+        }
+        plan.audio = { wavPath: speech.wavPath, tempo: fit.tempo, delaySeconds: SPEECH_LEAD_IN };
+      }
+      plans.push(plan);
+    }
+    for (const [index, plan] of plans.entries()) {
+      const chapter = manifest.chapters[index];
+      try {
+        media.renderClip(plan);
+      } catch (err) {
+        throw new EmitDemoError(`${chapterLabel(index, chapter.title)}: ffmpeg could not cut the clip: ${String(err)}`);
+      }
+      const bytes = statSync(plan.output).size;
+      if (bytes > ARTIFACT_MAX_BYTES) {
+        throw new EmitDemoError(
+          `${chapterLabel(index, chapter.title)}: the clip is ${(bytes / MIB).toFixed(1)} MiB, over the ${ARTIFACT_MAX_BYTES / MIB} MiB limit \u2014 shorten the chapter or record a smaller window`
+        );
+      }
+    }
+    const seed = createHash("sha256").update(manifestText).update("\0").update(readFileSync(videoPath)).update(`\0${opts.item ?? ""}\0${opts.pr ?? ""}`).digest("hex");
+    const idFor = (label, file) => `demo-${createHash("sha256").update(seed).update("\0").update(label).update("\0").update(readFileSync(file)).digest("hex").slice(0, 40)}`;
+    const clipIds = plans.map((plan, index) => idFor(`clip-${index + 1}`, plan.output));
+    const plannedRecord = JSON.stringify(
+      buildDemoRecord(
+        manifest,
+        manifest.chapters.map((chapter, index) => ({ clipArtifactId: clipIds[index], bound: chapter.criterionId !== null && chapterPassed(chapter.checks) }))
+      )
+    );
+    const recordBytes = Buffer.byteLength(plannedRecord);
+    if (recordBytes > ARTIFACT_MAX_BYTES) {
+      throw new EmitDemoError(
+        `the demo record is ${(recordBytes / MIB).toFixed(1)} MiB, over the ${ARTIFACT_MAX_BYTES / MIB} MiB limit \u2014 shorten the checks, titles and narration`
+      );
+    }
+    const emit = opts.emitArtifact ?? runEmitArtifact;
+    const base = {
+      pr: opts.pr,
+      url: opts.url,
+      apiKey: opts.apiKey,
+      appId: opts.appId,
+      quiet: true,
+      json: true,
+      cwd,
+      home,
+      env,
+      fetchImpl: opts.fetchImpl
+    };
+    const clips = [];
+    const failures = [];
+    for (const [index, chapter] of manifest.chapters.entries()) {
+      const bound = chapter.criterionId !== null && chapterPassed(chapter.checks);
+      const failed = chapter.checks.filter((check) => !check.passed);
+      if (failed.length > 0) {
+        failures.push(`${chapterLabel(index, chapter.title)} failed: ${failed.map((check) => `"${check.text}"`).join(", ")}`);
+      } else if (chapter.criterionId !== null && chapter.checks.length === 0) {
+        say(`${C.yellow}!${C.reset} ${chapterLabel(index, chapter.title)} ran no checks, so its clip is not bound to ${chapter.criterionId}`);
+      }
+      const caption = `Demo chapter ${index + 1}: ${chapter.title}${failed.length > 0 ? ` (${failed.length} failed check${failed.length === 1 ? "" : "s"})` : ""}`;
+      const result = await emitOrExplain(emit, {
+        ...base,
+        file: plans[index].output,
+        artifactId: clipIds[index],
+        caption: caption.slice(0, ARTIFACT_MAX_CAPTION_LENGTH),
+        ...bound ? { criterionId: chapter.criterionId } : {}
+      }, clips.length, manifest.chapters.length);
+      clips.push({ clipArtifactId: artifactIdOf(result), bound, title: chapter.title });
+    }
+    const record = buildDemoRecord(manifest, clips);
+    const recordPath = join(work, "demo.json");
+    writeFileSync(recordPath, JSON.stringify(record));
+    const recorded = await emitOrExplain(emit, {
+      ...base,
+      file: recordPath,
+      artifactId: idFor("record", recordPath),
+      caption: `Demo record: ${clips.length} chapter${clips.length === 1 ? "" : "s"}, ${clips.filter((clip) => clip.bound).length} bound to a criterion`,
+      mediaType: DEMO_RECORD_MEDIA_TYPE
+    }, clips.length, manifest.chapters.length);
+    const recordArtifactId = artifactIdOf(recorded);
+    const exitCode = failures.length > 0 ? 1 : 0;
+    const output = opts.json ? JSON.stringify({ recordArtifactId, clips, failures, exitCode }) : `${C.green}\u2713${C.reset} demo emitted ${C.dim}\xB7${C.reset} ${clips.length} clip${clips.length === 1 ? "" : "s"}, ${clips.filter((clip) => clip.bound).length} bound to a criterion ${C.dim}\xB7${C.reset} record ${recordArtifactId}`;
+    if (!opts.quiet) process.stdout.write(output + "\n");
+    return { exitCode, output, failures, recordArtifactId, clips };
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+function artifactIdOf(result) {
+  const id = result.record?.artifactId ?? result.data?.clientArtifactId;
+  if (typeof id !== "string") throw new EmitDemoError("the artifact was emitted but its id was not returned");
+  return id;
+}
+async function emitOrExplain(emit, opts, emitted, total) {
+  try {
+    return await emit(opts);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new EmitDemoError(
+      emitted > 0 ? `${message} \u2014 ${emitted} of ${total} clips were already emitted; run the command again to emit the whole demo` : message
+    );
+  }
+}
+async function recordedCriteria(params) {
+  const { opts, env, cwd, home, fetchImpl, say } = params;
+  let item = opts.item;
+  if (item === void 0) {
+    const identity = resolveRepoIdentity(cwd);
+    const sessionId = detectActiveSession({
+      env,
+      home,
+      cwds: identity.repoRoot !== void 0 ? [identity.repoRoot, cwd] : [cwd],
+      nowMs: Date.now()
+    });
+    item = sessionId === void 0 ? void 0 : launchedItemForSession(sessionId, home);
+  }
+  if (item === void 0) {
+    say(`${C.yellow}!${C.reset} no work item, so the chapters' criterion ids are not checked against the recorded criteria (pass --item <number>)`);
+    return void 0;
+  }
+  try {
+    const refusal = await autoConnect({ url: opts.url, apiKey: opts.apiKey, appId: opts.appId, cwd, home, env, fetchImpl: opts.fetchImpl });
+    if (refusal !== void 0) throw new Error(refusal);
+    const resolved = resolveGatewayCredentials({ url: opts.url, apiKey: opts.apiKey, appId: opts.appId, cwd, home, env });
+    if (!resolved.ok) throw new Error(resolved.message);
+    const ids = await readRecordedCriteriaIds({ url: resolved.url, apiKey: resolved.credential, appId: resolved.appId, item, fetchImpl });
+    if (ids === void 0) say(`${C.yellow}!${C.reset} item ${item} has no recorded criteria, so the chapters' criterion ids are not checked`);
+    return ids;
+  } catch (err) {
+    say(`${C.yellow}!${C.reset} could not read the recorded criteria of item ${item}, so the chapters' criterion ids are not checked: ${err instanceof Error ? err.message : String(err)}`);
+    return void 0;
+  }
+}
+async function realSpeaker(params) {
+  const { env, home, work, say } = params;
+  try {
+    const pack = await ensureVoicePack({ home, env, log: say });
+    const runtime = await ensureVoiceRuntime(pack, DEFAULT_VOICE_PACK_PINS, home);
+    mkdirSync(work, { recursive: true });
+    return createKokoroSpeaker({ packDir: pack.dir, runtimeDir: runtime.dir, espeakPath: findProgram("espeak-ng", env) ?? "espeak-ng", workDir: work });
+  } catch (err) {
+    if (err instanceof VoicePackError || err instanceof VoiceDownloadError) throw new EmitDemoError(err.message);
+    throw err;
+  }
+}
+
+export { EmitDemoError, runEmitDemo };