video-editing 1.3.1 → 2.0.0

package/dist/chunk-SSXAUKGV.js

@@ -0,0 +1,2549 @@
+#!/usr/bin/env node
+
+// src/ffmpeg.ts
+import { spawn, spawnSync } from "child_process";
+import { createWriteStream, mkdirSync } from "fs";
+import { dirname } from "path";
+function shquote(value) {
+  if (value.length === 0) return "''";
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) return value;
+  return "'" + value.replace(/'/g, `'"'"'`) + "'";
+}
+function shown(cmd) {
+  return cmd.map(shquote).join(" ");
+}
+var CommandError = class extends Error {
+  constructor(message, code, result) {
+    super(message);
+    this.code = code;
+    this.result = result;
+    this.name = "CommandError";
+  }
+  code;
+  result;
+};
+function run(cmd, opts = {}) {
+  const { capture = false, stdoutPath, cwd, check = true, echo = true } = opts;
+  if (echo) process.stderr.write(`+ ${shown(cmd)}
+`);
+  return new Promise((resolve3, reject) => {
+    const [bin, ...args] = cmd;
+    if (!bin) {
+      reject(new Error("empty command"));
+      return;
+    }
+    let fileStream;
+    const outChunks = [];
+    const errChunks = [];
+    const stdio = ["ignore", "pipe", "pipe"];
+    if (!capture && !stdoutPath) {
+      stdio[1] = "inherit";
+      stdio[2] = "inherit";
+    }
+    if (stdoutPath) {
+      mkdirSync(dirname(stdoutPath), { recursive: true });
+      fileStream = createWriteStream(stdoutPath, { encoding: "utf8" });
+    }
+    const child = spawn(bin, args, { cwd, stdio });
+    child.stdout?.on("data", (d) => {
+      if (fileStream) fileStream.write(d);
+      else if (capture) outChunks.push(d);
+    });
+    child.stderr?.on("data", (d) => {
+      if (fileStream) fileStream.write(d);
+      else if (capture) errChunks.push(d);
+    });
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (fileStream) fileStream.end();
+      const result = {
+        code: code ?? -1,
+        stdout: Buffer.concat(outChunks).toString("utf8"),
+        stderr: Buffer.concat(errChunks).toString("utf8")
+      };
+      if (check && result.code !== 0) {
+        if (capture) {
+          if (result.stdout) process.stderr.write(result.stdout + "\n");
+          if (result.stderr) process.stderr.write(result.stderr + "\n");
+        }
+        reject(new CommandError(`command failed with exit ${result.code}: ${shown(cmd)}`, result.code, result));
+        return;
+      }
+      resolve3(result);
+    });
+  });
+}
+function runSync(cmd, opts = {}) {
+  const { check = true, echo = true } = opts;
+  if (echo) process.stderr.write(`+ ${shown(cmd)}
+`);
+  const [bin, ...args] = cmd;
+  const proc = spawnSync(bin, args, { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+  const result = { code: proc.status ?? -1, stdout: proc.stdout ?? "", stderr: proc.stderr ?? "" };
+  if (check && result.code !== 0) {
+    throw new CommandError(`command failed with exit ${result.code}: ${shown(cmd)}`, result.code, result);
+  }
+  return result;
+}
+var FFPROBE_ENTRIES = "stream=index,codec_type,codec_name,width,height,r_frame_rate,avg_frame_rate,duration,color_transfer:stream_side_data=rotation:format=duration,size,format_name";
+async function ffprobe(path) {
+  const res = await run(
+    ["ffprobe", "-v", "error", "-show_entries", FFPROBE_ENTRIES, "-of", "json", path],
+    { capture: true }
+  );
+  try {
+    return JSON.parse(res.stdout || "{}");
+  } catch (e) {
+    throw new Error(`ffprobe returned invalid JSON for ${path}: ${e.message}`);
+  }
+}
+function videoStream(probe) {
+  for (const s of probe.streams ?? []) {
+    if (s.codec_type === "video") return s;
+  }
+  throw new Error("no video stream found");
+}
+async function mediaDuration(path) {
+  const probe = await ffprobe(path);
+  const d = probe.format?.duration;
+  const n = d ? Number(d) : 0;
+  return Number.isFinite(n) ? n : 0;
+}
+function requireFfmpeg() {
+  for (const bin of ["ffmpeg", "ffprobe"]) {
+    const r = spawnSync(bin, ["-version"], { encoding: "utf8" });
+    if (r.error) {
+      throw new Error("ffmpeg and ffprobe must be on PATH");
+    }
+  }
+}
+
+// src/cloud/client.ts
+import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync2, statSync, writeFileSync } from "fs";
+import { dirname as dirname2, join as pathJoin } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_DOWNLOAD_TIMEOUT_MS = 3e5;
+function firstNonEmpty(...vals) {
+  for (const v of vals) {
+    if (typeof v === "string" && v.trim() !== "") return v.trim();
+  }
+  return void 0;
+}
+function resolveApiBase(flag, env = process.env) {
+  return firstNonEmpty(flag, env.CLIPREADY_API_BASE, env.API_BASE);
+}
+function resolveApiKey(flag, env = process.env) {
+  return firstNonEmpty(flag, env.CLIPREADY_API_KEY, env.RUN_TOKEN);
+}
+function resolveVideoId(flag, env = process.env) {
+  return firstNonEmpty(flag, env.VIDEO_ID);
+}
+function stripTrailingSlash(base) {
+  return base.replace(/\/+$/, "");
+}
+function resolveConfig(flags, opts = {}, env = process.env) {
+  const base = resolveApiBase(flags.apiBase, env);
+  if (!base) {
+    throw new Error("missing API base URL \u2014 pass --api-base or set CLIPREADY_API_BASE (or API_BASE)");
+  }
+  const credential = resolveApiKey(flags.apiKey, env);
+  if (!credential) {
+    throw new Error("missing API credential \u2014 pass --api-key or set CLIPREADY_API_KEY (or RUN_TOKEN)");
+  }
+  const videoId = resolveVideoId(flags.videoId, env);
+  if (opts.requireVideoId && !videoId) {
+    throw new Error("missing video id \u2014 pass --video-id or set VIDEO_ID");
+  }
+  return { base: stripTrailingSlash(base), credential, videoId };
+}
+function rendersUrl(base) {
+  return `${stripTrailingSlash(base)}/api/v1/renders`;
+}
+function renderUrl(base, renderId) {
+  return `${stripTrailingSlash(base)}/api/v1/renders/${encodeURIComponent(renderId)}`;
+}
+function qaUrl(base, videoId) {
+  return `${stripTrailingSlash(base)}/api/v1/videos/${encodeURIComponent(videoId)}/qa`;
+}
+function reviewUrl(base, videoId) {
+  return `${stripTrailingSlash(base)}/api/v1/videos/${encodeURIComponent(videoId)}/review`;
+}
+function artifactsUrl(base, videoId, name) {
+  const root = `${stripTrailingSlash(base)}/api/v1/videos/${encodeURIComponent(videoId)}/artifacts`;
+  return name ? `${root}?name=${encodeURIComponent(name)}` : root;
+}
+function assetsUrl(base) {
+  return `${stripTrailingSlash(base)}/api/v1/assets`;
+}
+function meUrl(base) {
+  return `${stripTrailingSlash(base)}/api/v1/me`;
+}
+function projectsUrl(base) {
+  return `${stripTrailingSlash(base)}/api/v1/projects`;
+}
+function projectVideosUrl(base, projectId) {
+  return `${stripTrailingSlash(base)}/api/v1/projects/${encodeURIComponent(projectId)}/videos`;
+}
+function runUrl(base, runId) {
+  return `${stripTrailingSlash(base)}/api/v1/runs/${encodeURIComponent(runId)}`;
+}
+function videoUrl(base, videoId, tail) {
+  return `${stripTrailingSlash(base)}/api/v1/videos/${encodeURIComponent(videoId)}/${tail}`;
+}
+function filesUrl(base, videoId, path) {
+  const root = videoUrl(base, videoId, "files");
+  return path !== void 0 ? `${root}?path=${encodeURIComponent(path)}` : root;
+}
+function transcribeUrl(base, videoId) {
+  return videoUrl(base, videoId, "transcribe");
+}
+function compileUrl(base, videoId) {
+  return videoUrl(base, videoId, "compile");
+}
+function resolveUrl(base, videoId) {
+  return videoUrl(base, videoId, "resolve");
+}
+function verifyUrl(base, videoId) {
+  return videoUrl(base, videoId, "verify");
+}
+function composeUrl(base, videoId) {
+  return videoUrl(base, videoId, "compose");
+}
+function asRecord(data, ctx) {
+  if (data === null || typeof data !== "object") throw new Error(`unexpected ${ctx} response: ${JSON.stringify(data)}`);
+  return data;
+}
+function parseRenderCreate(data) {
+  const o = asRecord(data, "render-create");
+  const renderId = o.render_id;
+  if (typeof renderId !== "string" || renderId === "") throw new Error(`render response missing render_id: ${JSON.stringify(data)}`);
+  return { renderId, status: o.status ?? "pending" };
+}
+function parseRenderState(data) {
+  const o = asRecord(data, "render-status");
+  const status = o.status;
+  if (typeof status !== "string") throw new Error(`render status response missing status: ${JSON.stringify(data)}`);
+  return {
+    status,
+    videoUrl: typeof o.video_url === "string" ? o.video_url : void 0,
+    error: o.error
+  };
+}
+function isTerminalStatus(s) {
+  return s === "completed" || s === "failed";
+}
+function parseArtifactList(data) {
+  const o = asRecord(data, "artifact-list");
+  const arr = o.artifacts;
+  if (!Array.isArray(arr)) throw new Error(`artifact list response missing artifacts[]: ${JSON.stringify(data)}`);
+  return arr.filter((n) => typeof n === "string");
+}
+function parseArtifactContent(data) {
+  const o = asRecord(data, "artifact");
+  const name = o.name;
+  if (typeof name !== "string") throw new Error(`artifact response missing name: ${JSON.stringify(data)}`);
+  return { name, content: o.content };
+}
+function parseAssetCreate(data) {
+  const o = asRecord(data, "asset-create");
+  const assetId = o.asset_id;
+  const uploadUrl = o.upload_url;
+  if (typeof assetId !== "string" || assetId === "") {
+    throw new Error(`asset create response missing asset_id: ${JSON.stringify(data)}`);
+  }
+  if (typeof uploadUrl !== "string" || uploadUrl === "") {
+    throw new Error(`asset create response missing upload_url: ${JSON.stringify(data)}`);
+  }
+  return { assetId, uploadUrl };
+}
+function parseQaFrames(data) {
+  const o = asRecord(data, "qa-frames");
+  if (typeof o.url !== "string") throw new Error(`qa frames response missing url: ${JSON.stringify(data)}`);
+  return {
+    url: o.url,
+    width: Number(o.width ?? 0),
+    height: Number(o.height ?? 0),
+    frames: Number(o.frames ?? 0),
+    tStart: Number(o.tStart ?? 0),
+    tEnd: Number(o.tEnd ?? 0)
+  };
+}
+function parseQaWaveform(data) {
+  const o = asRecord(data, "qa-waveform");
+  if (typeof o.url !== "string") throw new Error(`qa waveform response missing url: ${JSON.stringify(data)}`);
+  const words = Array.isArray(o.words) ? o.words.map((w) => {
+    const r = w;
+    return { t: Number(r.t ?? 0), end: Number(r.end ?? 0), text: String(r.text ?? "") };
+  }) : [];
+  return { url: o.url, words };
+}
+function parseFileList(data) {
+  const o = asRecord(data, "file-list");
+  const arr = o.files;
+  if (!Array.isArray(arr)) throw new Error(`file list response missing files[]: ${JSON.stringify(data)}`);
+  return arr.filter((f) => f !== null && typeof f === "object").map((f) => ({
+    path: String(f.path ?? ""),
+    backend: String(f.backend ?? ""),
+    content_type: typeof f.content_type === "string" ? f.content_type : null,
+    bytes: typeof f.bytes === "number" ? f.bytes : null,
+    sha256: typeof f.sha256 === "string" ? f.sha256 : null,
+    status: typeof f.status === "string" ? f.status : null,
+    updated_at: typeof f.updated_at === "string" ? f.updated_at : null,
+    updated_by: typeof f.updated_by === "string" ? f.updated_by : null
+  }));
+}
+function unwrapFileEnvelope(data, what) {
+  const o = asRecord(data, what);
+  const f = o.file;
+  return f && typeof f === "object" && !Array.isArray(f) ? { ...o, ...f } : o;
+}
+function parseFileContent(data) {
+  const o = unwrapFileEnvelope(data, "file");
+  if (typeof o.path !== "string") throw new Error(`file response missing path: ${JSON.stringify(data)}`);
+  const content = typeof o.content === "string" ? o.content : void 0;
+  const downloadUrl = typeof o.download_url === "string" ? o.download_url : typeof o.url === "string" ? o.url : void 0;
+  if (content === void 0 && downloadUrl === void 0) {
+    throw new Error(`file response has neither content nor download_url: ${o.path}`);
+  }
+  return {
+    path: o.path,
+    content,
+    downloadUrl,
+    sha256: typeof o.sha256 === "string" ? o.sha256 : null,
+    contentType: typeof o.content_type === "string" ? o.content_type : null
+  };
+}
+function parseFilePresign(data) {
+  const o = unwrapFileEnvelope(data, "file-presign");
+  if (typeof o.upload_url !== "string" || o.upload_url === "") {
+    throw new Error(`presign response missing upload_url: ${JSON.stringify(data)}`);
+  }
+  return {
+    uploadUrl: o.upload_url,
+    token: typeof o.token === "string" ? o.token : null,
+    expiresAt: typeof o.expires_at === "string" ? o.expires_at : null
+  };
+}
+function parseRunState(data) {
+  const o = asRecord(data, "run");
+  if (typeof o.status !== "string") throw new Error(`run response missing status: ${JSON.stringify(data)}`);
+  const events = Array.isArray(o.events) ? o.events.filter((e) => e !== null && typeof e === "object").map((e) => ({ ts: String(e.ts ?? ""), type: String(e.type ?? ""), payload: e.payload })) : [];
+  return {
+    id: String(o.id ?? ""),
+    status: o.status,
+    errorCode: typeof o.error_code === "string" ? o.error_code : null,
+    errorMessage: typeof o.error_message === "string" ? o.error_message : null,
+    events
+  };
+}
+function isTerminalRunStatus(s) {
+  return s === "completed" || s === "failed" || s === "timed_out";
+}
+function numOrNull(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function strOrNull(v) {
+  return typeof v === "string" ? v : null;
+}
+function parseReviewSession(data) {
+  const o = asRecord(data, "review-session");
+  const videoId = o.video_id;
+  if (typeof videoId !== "string" || videoId === "") {
+    throw new Error(`review session response missing video_id: ${JSON.stringify(data)}`);
+  }
+  let activeRound = null;
+  if (o.active_round !== null && o.active_round !== void 0) {
+    const r = asRecord(o.active_round, "review-session active_round");
+    const roundId = r.round_id;
+    const runId = r.run_id;
+    if (typeof roundId !== "string" || typeof runId !== "string") {
+      throw new Error(`review session active_round missing round_id/run_id: ${JSON.stringify(o.active_round)}`);
+    }
+    const changes = Array.isArray(r.changes) ? r.changes.filter((c) => c !== null && typeof c === "object").map((c) => ({
+      id: String(c.id ?? ""),
+      idx: Number(c.idx ?? 0),
+      kind: String(c.kind ?? ""),
+      t: numOrNull(c.t),
+      t2: numOrNull(c.t2),
+      x: numOrNull(c.x),
+      y: numOrNull(c.y),
+      text: strOrNull(c.text),
+      outcome: strOrNull(c.outcome)
+    })) : [];
+    activeRound = {
+      roundId,
+      runId,
+      seq: Number(r.seq ?? 0),
+      mode: String(r.mode ?? ""),
+      status: String(r.status ?? ""),
+      instruction: typeof r.instruction === "string" ? r.instruction : "",
+      changes
+    };
+  }
+  return {
+    videoId,
+    title: strOrNull(o.title),
+    latestVersionSeq: numOrNull(o.latest_version_seq),
+    activeRound,
+    timeline: o.timeline ?? null,
+    sourceUrl: strOrNull(o.source_url)
+  };
+}
+var CloudHttpError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "CloudHttpError";
+  }
+  status;
+  body;
+};
+function extractErrorMessage(data) {
+  if (typeof data === "string" && data.trim() !== "") return data;
+  if (data && typeof data === "object") {
+    const o = data;
+    if (typeof o.error === "string") return o.error;
+    if (typeof o.message === "string") return o.message;
+    if (o.error) return JSON.stringify(o.error);
+  }
+  return void 0;
+}
+var CloudClient = class {
+  constructor(cfg, opts = {}) {
+    this.cfg = cfg;
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!this.fetchImpl) throw new Error("global fetch is unavailable \u2014 Node 18+ required, or inject fetchImpl");
+  }
+  cfg;
+  fetchImpl;
+  timeoutMs;
+  requireVideoId() {
+    if (!this.cfg.videoId) throw new Error("missing video id \u2014 pass --video-id or set VIDEO_ID");
+    return this.cfg.videoId;
+  }
+  async request(method, url, body) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), this.timeoutMs);
+    try {
+      const res = await this.fetchImpl(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.cfg.credential}`,
+          Accept: "application/json",
+          ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: ac.signal
+      });
+      const text = await res.text();
+      let data = void 0;
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          data = text;
+        }
+      }
+      if (!res.ok) {
+        const detail = extractErrorMessage(data) ?? `${res.status} ${res.statusText}`;
+        throw new CloudHttpError(res.status, `${method} ${url} failed: ${detail}`, data);
+      }
+      return data;
+    } catch (err) {
+      if (err instanceof CloudHttpError) throw err;
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`request timed out after ${this.timeoutMs}ms: ${method} ${url}`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ---- render -------------------------------------------------------------
+  async createRender(mode) {
+    const data = await this.request("POST", rendersUrl(this.cfg.base), {
+      video_id: this.requireVideoId(),
+      mode
+    });
+    return parseRenderCreate(data);
+  }
+  async getRender(renderId) {
+    const data = await this.request("GET", renderUrl(this.cfg.base, renderId));
+    return parseRenderState(data);
+  }
+  // ---- qa -----------------------------------------------------------------
+  async qaFrames(args) {
+    const body = { kind: "frames", start: args.start, end: args.end };
+    if (args.cols !== void 0) body.cols = args.cols;
+    if (args.interval !== void 0) body.interval = args.interval;
+    const data = await this.request("POST", qaUrl(this.cfg.base, this.requireVideoId()), body);
+    return parseQaFrames(data);
+  }
+  async qaWaveform(args) {
+    const data = await this.request("POST", qaUrl(this.cfg.base, this.requireVideoId()), {
+      kind: "waveform",
+      start: args.start,
+      end: args.end
+    });
+    return parseQaWaveform(data);
+  }
+  // ---- artifacts ----------------------------------------------------------
+  async listArtifacts() {
+    const data = await this.request("GET", artifactsUrl(this.cfg.base, this.requireVideoId()));
+    return parseArtifactList(data);
+  }
+  async getArtifact(name) {
+    const data = await this.request("GET", artifactsUrl(this.cfg.base, this.requireVideoId(), name));
+    return parseArtifactContent(data);
+  }
+  // ---- assets -------------------------------------------------------------
+  /** POST /api/v1/assets: request an asset row + presigned upload URL
+   *  (clipready assets route: {kind, content_type?, video_id?, filename?} →
+   *  {asset_id, upload_url, upload_token, expires_at}). */
+  async createAsset(args) {
+    const body = { kind: args.kind, video_id: this.requireVideoId() };
+    if (args.contentType !== void 0) body.content_type = args.contentType;
+    if (args.filename !== void 0) body.filename = args.filename;
+    const data = await this.request("POST", assetsUrl(this.cfg.base), body);
+    return parseAssetCreate(data);
+  }
+  /** PUT raw bytes to a presigned upload URL. No Authorization header — the
+   *  signed URL carries its own credentials and may be a different host. */
+  async upload(url, bytes, contentType, timeoutMs = DEFAULT_DOWNLOAD_TIMEOUT_MS) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+      const res = await this.fetchImpl(url, {
+        method: "PUT",
+        headers: { "Content-Type": contentType },
+        body: bytes,
+        signal: ac.signal
+      });
+      if (!res.ok) {
+        throw new Error(`asset upload failed: HTTP ${res.status} ${res.statusText} for ${url}`);
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`asset upload timed out after ${timeoutMs}ms: ${url}`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ---- review session -----------------------------------------------------
+  async getReview() {
+    const data = await this.request("GET", reviewUrl(this.cfg.base, this.requireVideoId()));
+    return parseReviewSession(data);
+  }
+  /** POST a review-round event ({run_id, type, payload?}); expects {ok:true}. */
+  async pushReview(body) {
+    const data = await this.request("POST", reviewUrl(this.cfg.base, this.requireVideoId()), body);
+    const o = data;
+    if (!o || o.ok !== true) {
+      throw new Error(`review push (${body.type}) did not return {ok:true}: ${JSON.stringify(data)}`);
+    }
+  }
+  // ---- auth gate ----------------------------------------------------------
+  /** GET /v1/me — validates the credential; returns the raw payload. */
+  async me() {
+    const data = await this.request("GET", meUrl(this.cfg.base));
+    const o = data;
+    if (!o || typeof o !== "object" || typeof o.user_id !== "string") {
+      throw new Error(`/v1/me did not return a user: ${JSON.stringify(data)}`);
+    }
+    return o;
+  }
+  // ---- projects / videos (init flow) --------------------------------------
+  async createProject(title) {
+    const data = await this.request("POST", projectsUrl(this.cfg.base), { title });
+    const o = asRecord(data, "project-create");
+    const projectId = o.project_id;
+    if (typeof projectId !== "string" || projectId === "") {
+      throw new Error(`project create response missing project_id: ${JSON.stringify(data)}`);
+    }
+    return { projectId };
+  }
+  /** POST /v1/assets for a NEW source (no video yet): {kind:"source", ...}. */
+  async createSourceAsset(args) {
+    const body = { kind: "source", content_type: args.contentType };
+    if (args.filename !== void 0) body.filename = args.filename;
+    if (args.videoId !== void 0) body.video_id = args.videoId;
+    const data = await this.request("POST", assetsUrl(this.cfg.base), body);
+    return parseAssetCreate(data);
+  }
+  /** POST /v1/projects/{id}/videos {asset_id, title?, workflow:"cli"}. */
+  async createVideo(projectId, args) {
+    const body = { asset_id: args.assetId, workflow: "cli" };
+    if (args.title !== void 0) body.title = args.title;
+    const data = await this.request("POST", projectVideosUrl(this.cfg.base, projectId), body);
+    const o = asRecord(data, "video-create");
+    const videoId = o.video_id;
+    if (typeof videoId !== "string" || videoId === "") {
+      throw new Error(`video create response missing video_id: ${JSON.stringify(data)}`);
+    }
+    return { videoId, projectId: typeof o.project_id === "string" ? o.project_id : projectId };
+  }
+  // ---- virtual file system -------------------------------------------------
+  async filesList() {
+    const data = await this.request("GET", filesUrl(this.cfg.base, this.requireVideoId()));
+    return parseFileList(data);
+  }
+  async filesGet(path) {
+    const data = await this.request("GET", filesUrl(this.cfg.base, this.requireVideoId(), path));
+    return parseFileContent(data);
+  }
+  /** Inline PUT (≤5MB text payloads) → {path, sha256, bytes}. */
+  async filesPutInline(path, content, contentType) {
+    const body = { path, content };
+    if (contentType !== void 0) body.content_type = contentType;
+    const data = await this.request("PUT", filesUrl(this.cfg.base, this.requireVideoId()), body);
+    const o = unwrapFileEnvelope(data, "file-put");
+    return {
+      path: typeof o.path === "string" ? o.path : path,
+      sha256: typeof o.sha256 === "string" ? o.sha256 : null,
+      bytes: typeof o.bytes === "number" ? o.bytes : null
+    };
+  }
+  /** Presign PUT for large/binary payloads → {upload_url, token, expires_at}. */
+  async filesPresign(args) {
+    const data = await this.request("PUT", filesUrl(this.cfg.base, this.requireVideoId()), {
+      path: args.path,
+      content_type: args.contentType,
+      bytes: args.bytes,
+      sha256: args.sha256,
+      presign: true
+    });
+    return parseFilePresign(data);
+  }
+  /** Commit a presigned upload → {path, status:"ready"}. */
+  async filesCommit(path) {
+    const data = await this.request("PUT", filesUrl(this.cfg.base, this.requireVideoId()), { path, commit: true });
+    const o = unwrapFileEnvelope(data, "file-commit");
+    if (o.status !== "ready") {
+      throw new Error(`file commit for ${path} did not return status "ready": ${JSON.stringify(data)}`);
+    }
+  }
+  async filesDelete(path) {
+    await this.request("DELETE", filesUrl(this.cfg.base, this.requireVideoId(), path));
+  }
+  // ---- server-side pipeline verbs -----------------------------------------
+  /** POST /videos/{id}/transcribe → 202 {run_id}. */
+  async transcribeStart(body) {
+    const data = await this.request("POST", transcribeUrl(this.cfg.base, this.requireVideoId()), body);
+    const o = asRecord(data, "transcribe");
+    if (typeof o.run_id !== "string" || o.run_id === "") {
+      throw new Error(`transcribe response missing run_id: ${JSON.stringify(data)}`);
+    }
+    return { runId: o.run_id };
+  }
+  /** POST /videos/{id}/verify → 202 {run_id}. */
+  async verifyStart(body) {
+    const data = await this.request("POST", verifyUrl(this.cfg.base, this.requireVideoId()), body);
+    const o = asRecord(data, "verify");
+    if (typeof o.run_id !== "string" || o.run_id === "") {
+      throw new Error(`verify response missing run_id: ${JSON.stringify(data)}`);
+    }
+    return { runId: o.run_id };
+  }
+  /** GET /runs/{id} — run status + events. */
+  async getRun(runId) {
+    const data = await this.request("GET", runUrl(this.cfg.base, runId));
+    return parseRunState(data);
+  }
+  /** POST /videos/{id}/compile → {ok, plan, legacy_edl, diagnostics, uses}. */
+  async compileRemote(body) {
+    const data = await this.request("POST", compileUrl(this.cfg.base, this.requireVideoId()), body);
+    return asRecord(data, "compile");
+  }
+  /** POST /videos/{id}/resolve {phrase, source?, occurrence?}. */
+  async resolveRemote(body) {
+    const data = await this.request("POST", resolveUrl(this.cfg.base, this.requireVideoId()), body);
+    return asRecord(data, "resolve");
+  }
+  /** GET /videos/{id}/compose → {html, counts, media:[{src, role}]}. */
+  async getCompose() {
+    const data = await this.request("GET", composeUrl(this.cfg.base, this.requireVideoId()));
+    const o = asRecord(data, "compose");
+    if (typeof o.html !== "string") throw new Error(`compose response missing html: ${JSON.stringify(data)}`);
+    const media = Array.isArray(o.media) ? o.media.filter((m) => m !== null && typeof m === "object").map((m) => ({ src: String(m.src ?? ""), role: String(m.role ?? "") })) : [];
+    const counts = o.counts !== null && typeof o.counts === "object" ? o.counts : {};
+    return { html: o.html, counts, media };
+  }
+  // ---- download (signed URLs; no auth header) -----------------------------
+  async download(url, dest, timeoutMs = DEFAULT_DOWNLOAD_TIMEOUT_MS) {
+    return downloadTo(url, dest, { fetchImpl: this.fetchImpl, timeoutMs });
+  }
+};
+async function downloadTo(url, dest, opts = {}) {
+  const f = opts.fetchImpl ?? globalThis.fetch;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), opts.timeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS);
+  try {
+    const res = await f(url, { signal: ac.signal });
+    if (!res.ok) throw new Error(`download failed: HTTP ${res.status} ${res.statusText} for ${url}`);
+    mkdirSync2(dirname2(dest), { recursive: true });
+    const body = res.body;
+    if (!body) {
+      const buf = Buffer.from(await res.arrayBuffer());
+      writeFileSync(dest, buf);
+      return { path: dest, bytes: buf.length };
+    }
+    await pipeline(Readable.fromWeb(body), createWriteStream2(dest));
+    return { path: dest, bytes: statSync(dest).size };
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new Error(`download timed out after ${opts.timeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS}ms: ${url}`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/cloud/render.ts
+import { join } from "path";
+var MAX_POLL_MS = 30 * 60 * 1e3;
+function defaultRenderOut(jobDir, mode) {
+  return join(jobDir, mode === "final" ? "final.mp4" : "preview.mp4");
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function pollRender(client, renderId, opts = {}) {
+  const intervalMs = opts.intervalMs ?? 1e4;
+  const maxMs = opts.maxMs ?? MAX_POLL_MS;
+  const nap = opts.sleepImpl ?? sleep;
+  const now = opts.now ?? Date.now;
+  const start = now();
+  for (; ; ) {
+    const state = await client.getRender(renderId);
+    const elapsed = now() - start;
+    opts.onTick?.(state, elapsed);
+    if (isTerminalStatus(state.status)) return state;
+    if (elapsed + intervalMs >= maxMs) {
+      throw new Error(`render ${renderId} did not finish within ${Math.round(maxMs / 6e4)} min (last status: ${state.status})`);
+    }
+    await nap(intervalMs);
+  }
+}
+
+// src/cloud/skill.ts
+import { cpSync, existsSync, readdirSync, rmSync, statSync as statSync2 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, join as join2, relative, resolve } from "path";
+import { fileURLToPath } from "url";
+function bundledSkillDir() {
+  const here = dirname3(fileURLToPath(import.meta.url));
+  const candidates = [
+    join2(here, "skills", "video-editing"),
+    join2(here, "..", "skills", "video-editing"),
+    join2(here, "..", "..", "skills", "video-editing")
+  ];
+  for (const c of candidates) {
+    if (existsSync(join2(c, "SKILL.md"))) return resolve(c);
+  }
+  throw new Error(`bundled skill not found (looked in: ${candidates.map((c) => resolve(c)).join(", ")})`);
+}
+function defaultSkillTarget() {
+  return join2(homedir(), ".claude", "skills");
+}
+function listFilesRecursive(root) {
+  const out = [];
+  for (const entry of readdirSync(root)) {
+    const full = join2(root, entry);
+    if (statSync2(full).isDirectory()) out.push(...listFilesRecursive(full));
+    else out.push(full);
+  }
+  return out;
+}
+function installSkill(opts = {}) {
+  const source = bundledSkillDir();
+  const targetRoot = opts.target ? resolve(opts.target) : defaultSkillTarget();
+  const dest = join2(targetRoot, "video-editing");
+  rmSync(dest, { recursive: true, force: true });
+  cpSync(source, dest, { recursive: true });
+  const files = listFilesRecursive(dest).map((f) => relative(dest, f)).sort();
+  return { source, dest, files };
+}
+
+// src/cloud/jobfile.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+function jobJsonPath(jobDir) {
+  return join3(jobDir, "job.json");
+}
+function writeJobFile(jobDir, job) {
+  mkdirSync3(jobDir, { recursive: true });
+  const path = jobJsonPath(jobDir);
+  writeFileSync2(path, JSON.stringify(job, null, 2) + "\n", "utf8");
+  return path;
+}
+function readJobFile(jobDir) {
+  const path = jobJsonPath(jobDir);
+  if (!existsSync2(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof raw.video_id !== "string" || raw.video_id === "") return null;
+    return {
+      video_id: raw.video_id,
+      project_id: typeof raw.project_id === "string" ? raw.project_id : "",
+      api_base: typeof raw.api_base === "string" ? raw.api_base : "",
+      stem: typeof raw.stem === "string" ? raw.stem : "source",
+      duration_s: typeof raw.duration_s === "number" ? raw.duration_s : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function videoIdFromJob(jobDir, resolved) {
+  if (resolved) return resolved;
+  const job = readJobFile(jobDir);
+  if (job) return job.video_id;
+  throw new Error(`missing video id \u2014 pass --video-id, set VIDEO_ID, or run \`init\` first (no ${jobJsonPath(jobDir)})`);
+}
+
+// src/cloud/init.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync2 } from "fs";
+import { join as join5, parse as parsePath, resolve as resolvePath } from "path";
+
+// src/master.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+
+// src/probe.ts
+function rotationDegrees(stream) {
+  for (const sideData of stream.side_data_list ?? []) {
+    if (sideData && "rotation" in sideData) {
+      const v = Number(sideData.rotation);
+      return Number.isFinite(v) ? Math.trunc(v) : 0;
+    }
+  }
+  const tags = stream.tags ?? {};
+  if ("rotate" in tags) {
+    const v = Number(tags.rotate);
+    return Number.isFinite(v) ? Math.trunc(v) : 0;
+  }
+  return 0;
+}
+function displayedDimensions(stream) {
+  const width = Math.trunc(Number(stream.width ?? 0)) || 0;
+  const height = Math.trunc(Number(stream.height ?? 0)) || 0;
+  const rotation = rotationDegrees(stream);
+  if (Math.abs(rotation) % 180 === 90) {
+    return [height, width, rotation];
+  }
+  return [width, height, rotation];
+}
+
+// src/util.ts
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "+00:00");
+}
+function pyFixed(x, prec) {
+  if (!Number.isFinite(x)) return String(x);
+  const neg = x < 0 || Object.is(x, -0);
+  const a = Math.abs(x);
+  const m = Math.pow(10, prec);
+  const scaled = a * m;
+  const floor = Math.floor(scaled);
+  const diff = scaled - floor;
+  const EPS2 = 1e-9;
+  let rounded;
+  if (Math.abs(diff - 0.5) < EPS2) {
+    rounded = floor % 2 === 0 ? floor : floor + 1;
+  } else {
+    rounded = Math.round(scaled);
+  }
+  let s = (rounded / m).toFixed(prec);
+  if (neg && Number(s) !== 0) s = "-" + s;
+  return s;
+}
+
+// src/master.ts
+var X264_BAKE = [
+  "-c:v",
+  "libx264",
+  "-preset",
+  "medium",
+  "-crf",
+  "18",
+  "-pix_fmt",
+  "yuv420p",
+  "-c:a",
+  "aac",
+  "-b:a",
+  "192k",
+  "-movflags",
+  "+faststart"
+];
+async function ensureVerticalMaster(jobDir, source, opts = {}) {
+  const out = join4(jobDir, "vertical_src.mp4");
+  if (existsSync3(out) && !opts.force) return out;
+  const probe = await ffprobe(source);
+  const stream = videoStream(probe);
+  const [displayW, displayH, rotation] = displayedDimensions(stream);
+  const longEdge = Math.max(displayW, displayH);
+  let vf = displayH >= displayW && longEdge > 1920 ? "scale=-2:1920" : null;
+  if (displayW > displayH && longEdge > 1920) vf = "scale=1920:-2";
+  const cmd = ["ffmpeg", "-y", "-i", source];
+  if (vf) cmd.push("-vf", vf);
+  cmd.push(...X264_BAKE, out);
+  await run(cmd);
+  const outProbe = await ffprobe(out);
+  const outStream = videoStream(outProbe);
+  const outW = Math.trunc(Number(outStream.width ?? 0)) || 0;
+  const outH = Math.trunc(Number(outStream.height ?? 0)) || 0;
+  let retriedWith = null;
+  if (displayH > displayW && outW > outH) {
+    retriedWith = vf ? `transpose=1,${vf}` : "transpose=1";
+    await run(["ffmpeg", "-y", "-i", source, "-vf", retriedWith, ...X264_BAKE, out]);
+  }
+  writeFileSync3(
+    join4(jobDir, "master.json"),
+    JSON.stringify(
+      {
+        source,
+        master: out,
+        display_width: displayW,
+        display_height: displayH,
+        rotation,
+        scale_filter: vf,
+        retry_filter: retriedWith,
+        created: isoNow()
+      },
+      null,
+      2
+    ) + "\n",
+    "utf8"
+  );
+  return out;
+}
+
+// src/cloud/init.ts
+function contentTypeFor(path) {
+  const ext = parsePath(path).ext.toLowerCase();
+  const map = { ".mp4": "video/mp4", ".m4v": "video/mp4", ".mov": "video/quicktime", ".mkv": "video/x-matroska", ".avi": "video/x-msvideo" };
+  return map[ext] ?? "video/mp4";
+}
+async function initCloudJob(client, opts) {
+  const source = resolvePath(opts.source);
+  if (!existsSync4(source)) throw new Error(`source not found: ${source}`);
+  const stem = parsePath(source).name;
+  const jobDir = resolvePath(opts.jobDir ?? join5(process.cwd(), `job_${stem}`));
+  mkdirSync4(jobDir, { recursive: true });
+  const log = (line) => {
+    if (opts.verbose !== false) process.stderr.write(line + "\n");
+  };
+  await client.me();
+  const probe = await ffprobe(source);
+  const durationS = Number(probe.format?.duration ?? 0) || 0;
+  if (!(durationS > 0)) throw new Error(`could not read a duration from ${source} (is it a video?)`);
+  let uploadPath = source;
+  if (opts.master) {
+    log("  baking vertical 9:16 master (local ffmpeg)");
+    uploadPath = await ensureVerticalMaster(jobDir, source);
+  }
+  const title = opts.title ?? stem;
+  const { projectId } = await client.createProject(title);
+  log(`  project: ${projectId}`);
+  const asset = await client.createSourceAsset({
+    contentType: contentTypeFor(uploadPath),
+    filename: parsePath(uploadPath).base
+  });
+  const bytes = readFileSync2(uploadPath);
+  log(`  uploading ${parsePath(uploadPath).base} (${(bytes.length / (1024 * 1024)).toFixed(1)} MB)`);
+  await client.upload(asset.uploadUrl, bytes, contentTypeFor(uploadPath));
+  const video = await client.createVideo(projectId, { assetId: asset.assetId, title });
+  log(`  video: ${video.videoId}`);
+  const job = {
+    video_id: video.videoId,
+    project_id: video.projectId,
+    api_base: client.cfg.base,
+    stem,
+    duration_s: durationS
+  };
+  const jobJson = writeJobFile(jobDir, job);
+  return {
+    jobDir,
+    jobJson,
+    videoId: video.videoId,
+    projectId: video.projectId,
+    stem,
+    durationS,
+    uploaded: uploadPath,
+    uploadedBytes: bytes.length
+  };
+}
+
+// src/cloud/files.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync3, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname4, join as join6, sep } from "path";
+var INLINE_MAX_BYTES = 5 * 1024 * 1024;
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function sameSha(a, b) {
+  if (!a || !b) return false;
+  const norm = (s) => s.replace(/^sha256:/, "").toLowerCase();
+  return norm(a) === norm(b);
+}
+function vfsLocalPath(jobDir, path) {
+  const parts = path.split("/").filter((p) => p !== "" && p !== "." && p !== "..");
+  if (parts.length === 0) throw new Error(`bad VFS path: ${JSON.stringify(path)}`);
+  return join6(jobDir, ...parts);
+}
+function toVfsPath(jobDir, localPath) {
+  const abs = localPath.startsWith(sep) ? localPath : join6(jobDir, localPath);
+  const rel = abs.startsWith(jobDir + sep) ? abs.slice(jobDir.length + 1) : localPath;
+  return rel.split(sep).join("/");
+}
+var TEXT_TYPES = /^(text\/|application\/(json|xml|javascript|x-ndjson))/;
+function vfsContentType(path) {
+  const m = /\.[^./\\]+$/.exec(path.toLowerCase());
+  const ext = m ? m[0] : "";
+  const map = {
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".txt": "text/plain",
+    ".html": "text/html",
+    ".srt": "text/plain",
+    ".vtt": "text/vtt",
+    ".wav": "audio/wav",
+    ".m4a": "audio/mp4",
+    ".mp3": "audio/mpeg",
+    ".mp4": "video/mp4",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp"
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+async function pullFiles(client, jobDir, opts = {}) {
+  const listing = await client.filesList();
+  const byPath = new Map(listing.map((f) => [f.path, f]));
+  const prefixMatched = opts.prefixes?.length ? listing.map((f) => f.path).filter((path) => opts.prefixes.some((pre) => path.startsWith(pre))) : [];
+  const explicit = opts.only && opts.only.length > 0 ? opts.only : listing.map((f) => f.path);
+  const wanted = [.../* @__PURE__ */ new Set([...explicit, ...prefixMatched])];
+  const missing = explicit.filter((p) => !byPath.has(p));
+  const pulled = [];
+  for (const path of wanted) {
+    const entry = byPath.get(path);
+    if (!entry) continue;
+    const dest = vfsLocalPath(jobDir, path);
+    if (existsSync5(dest) && sameSha(sha256Hex(readFileSync3(dest)), entry.sha256)) {
+      const f2 = { path, localPath: dest, bytes: statSync3(dest).size, skipped: true };
+      pulled.push(f2);
+      opts.onFile?.(f2);
+      continue;
+    }
+    const got = await client.filesGet(path);
+    mkdirSync5(dirname4(dest), { recursive: true });
+    let bytes;
+    if (got.content !== void 0) {
+      const buf = Buffer.from(got.content, "utf8");
+      writeFileSync4(dest, buf);
+      bytes = buf.length;
+      if (got.sha256 && !sameSha(sha256Hex(buf), got.sha256)) {
+        throw new Error(`pulled ${path} but sha256 mismatch vs server (${got.sha256}) \u2014 refusing to trust the copy`);
+      }
+    } else {
+      const dl = await client.download(got.downloadUrl, dest);
+      bytes = dl.bytes;
+      if (got.sha256 && !sameSha(sha256Hex(readFileSync3(dest)), got.sha256)) {
+        throw new Error(`pulled ${path} but sha256 mismatch vs server (${got.sha256}) \u2014 refusing to trust the copy`);
+      }
+    }
+    const f = { path, localPath: dest, bytes, skipped: false };
+    pulled.push(f);
+    opts.onFile?.(f);
+  }
+  return { pulled, missing };
+}
+async function pushFiles(client, jobDir, paths, opts = {}) {
+  if (paths.length === 0) throw new Error("files push: pass at least one jobDir-relative path");
+  const listing = await client.filesList();
+  const byPath = new Map(listing.map((f) => [f.path, f]));
+  const out = [];
+  for (const rel of paths) {
+    const vfsPath = toVfsPath(jobDir, rel);
+    const local = vfsLocalPath(jobDir, vfsPath);
+    if (!existsSync5(local)) throw new Error(`files push: local file not found: ${local}`);
+    const bytes = readFileSync3(local);
+    const sha = sha256Hex(bytes);
+    const existing = byPath.get(vfsPath);
+    if (existing && sameSha(sha, existing.sha256)) {
+      const f = { path: vfsPath, bytes: bytes.length, skipped: true, mode: "skip" };
+      out.push(f);
+      opts.onFile?.(f);
+      continue;
+    }
+    const contentType = vfsContentType(vfsPath);
+    const isText = TEXT_TYPES.test(contentType);
+    if (isText && bytes.length <= INLINE_MAX_BYTES) {
+      const res = await client.filesPutInline(vfsPath, bytes.toString("utf8"), contentType);
+      if (res.sha256 && !sameSha(sha, res.sha256)) {
+        throw new Error(`pushed ${vfsPath} but the server stored different bytes (sha256 mismatch)`);
+      }
+      const f = { path: vfsPath, bytes: bytes.length, skipped: false, mode: "inline" };
+      out.push(f);
+      opts.onFile?.(f);
+    } else {
+      const presign = await client.filesPresign({ path: vfsPath, contentType, bytes: bytes.length, sha256: sha });
+      await client.upload(presign.uploadUrl, bytes, contentType);
+      await client.filesCommit(vfsPath);
+      const f = { path: vfsPath, bytes: bytes.length, skipped: false, mode: "presign" };
+      out.push(f);
+      opts.onFile?.(f);
+    }
+  }
+  return out;
+}
+async function uploadVfsBytes(client, vfsPath, bytes, contentType) {
+  const presign = await client.filesPresign({
+    path: vfsPath,
+    contentType,
+    bytes: bytes.length,
+    sha256: sha256Hex(bytes)
+  });
+  await client.upload(presign.uploadUrl, bytes, contentType);
+  await client.filesCommit(vfsPath);
+}
+
+// src/cloud/runs.ts
+var MAX_RUN_POLL_MS = 30 * 60 * 1e3;
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+function formatRunEvent(ev) {
+  const p = ev.payload;
+  const message = p !== null && typeof p === "object" && typeof p.message === "string" ? p.message : "";
+  return message ? `[${ev.type}] ${message}` : `[${ev.type}]`;
+}
+async function pollRun(client, runId, opts = {}) {
+  const intervalMs = opts.intervalMs ?? 5e3;
+  const maxMs = opts.maxMs ?? MAX_RUN_POLL_MS;
+  const nap = opts.sleepImpl ?? sleep2;
+  const now = opts.now ?? Date.now;
+  const start = now();
+  let seen = 0;
+  for (; ; ) {
+    const state = await client.getRun(runId);
+    for (; seen < state.events.length; seen++) opts.onEvent?.(state.events[seen]);
+    if (isTerminalRunStatus(state.status)) return state;
+    const elapsed = now() - start;
+    if (elapsed + intervalMs >= maxMs) {
+      throw new Error(`run ${runId} did not finish within ${Math.round(maxMs / 6e4)} min (last status: ${state.status})`);
+    }
+    await nap(intervalMs);
+  }
+}
+function assertRunCompleted(state, what) {
+  if (state.status === "completed") return;
+  const detail = state.errorMessage ?? state.errorCode ?? state.status;
+  throw new Error(`${what} run ${state.id || ""} ${state.status}: ${detail}`);
+}
+
+// src/cloud/transcribe2.ts
+import { mkdtempSync, readFileSync as readFileSync4, rmSync as rmSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join7 } from "path";
+function transcribeArtifactSet(stem) {
+  return [`transcripts/${stem}.json`, "takes_packed.md", "flags.txt", "word_dump.txt", "coverage.json"];
+}
+async function extractGuardedWav(media) {
+  const tmp = mkdtempSync(join7(tmpdir(), "ve-cloud-wav-"));
+  try {
+    const wav = join7(tmp, "audio.wav");
+    await run(
+      ["ffmpeg", "-y", "-i", media, "-vn", "-ac", "1", "-ar", "16000", "-c:a", "pcm_s16le", wav],
+      { capture: true, echo: false }
+    );
+    const audioS = await mediaDuration(wav);
+    const videoS = await mediaDuration(media);
+    if (Number.isFinite(audioS) && Number.isFinite(videoS) && Math.abs(audioS - videoS) > 0.15) {
+      throw new Error(
+        `source A/V clocks diverge: decoded audio is ${audioS.toFixed(3)}s but video is ${videoS.toFixed(3)}s (\u0394 ${(audioS - videoS).toFixed(3)}s). Word timestamps would drift against the picture by up to that much. Re-export the source with a clean muxer (e.g. \`ffmpeg -i in -c:v copy -af aresample=async=1 out.mp4\`) and retry.`
+      );
+    }
+    return { bytes: readFileSync4(wav), durationS: audioS };
+  } finally {
+    rmSync2(tmp, { recursive: true, force: true });
+  }
+}
+async function transcribeCloud(client, jobDir, opts) {
+  const verbose = opts.verbose !== false;
+  const log = (line) => {
+    if (verbose) process.stderr.write(line + "\n");
+  };
+  log(`  extracting audio from ${opts.media}`);
+  const { bytes, durationS } = await extractGuardedWav(opts.media);
+  const wavPath = `audio/${opts.stem}.wav`;
+  log(`  uploading ${wavPath} (${(bytes.length / (1024 * 1024)).toFixed(1)} MB)`);
+  await uploadVfsBytes(client, wavPath, bytes, "audio/wav");
+  const { runId } = await client.transcribeStart({
+    wav_path: wavPath,
+    stem: opts.stem,
+    duration_s: durationS,
+    ...opts.language !== void 0 ? { language: opts.language } : {},
+    ...opts.numSpeakers !== void 0 ? { num_speakers: opts.numSpeakers } : {}
+  });
+  log(`  transcribe run: ${runId}`);
+  const state = await pollRun(client, runId, {
+    intervalMs: opts.pollIntervalMs,
+    onEvent: (ev) => log(`  ${formatRunEvent(ev)}`)
+  });
+  assertRunCompleted(state, "transcribe");
+  const pulled = await pullFiles(client, jobDir, { only: transcribeArtifactSet(opts.stem), prefixes: ["prompts/"] });
+  return { runId, wavPath, durationS, pulled };
+}
+
+// src/silence-detect.ts
+var DEFAULT_DESILENCE = {
+  noiseDb: -36,
+  minSilence: 0.14,
+  targetGap: 0.09,
+  leadKeep: 0.04,
+  trailKeep: 0.05,
+  minSegment: 0.1
+};
+function f3(x) {
+  return pyFixed(x, 3);
+}
+function silenceDetectArgs(source, noiseDb, minSilenceS) {
+  return [
+    "ffmpeg",
+    "-hide_banner",
+    "-nostats",
+    "-i",
+    source,
+    "-af",
+    `silencedetect=noise=${noiseDb}dB:d=${f3(minSilenceS)}`,
+    "-vn",
+    "-f",
+    "null",
+    "-"
+  ];
+}
+function parseSilenceDetect(stderr, sourceDurationS = 0) {
+  const intervals = [];
+  let pendingStart = null;
+  for (const line of stderr.split(/\r?\n/)) {
+    const mStart = line.match(/silence_start:\s*(-?[0-9]+(?:\.[0-9]+)?)/);
+    if (mStart) {
+      pendingStart = Number(mStart[1]);
+      continue;
+    }
+    const mEnd = line.match(/silence_end:\s*(-?[0-9]+(?:\.[0-9]+)?)/);
+    if (mEnd && pendingStart !== null) {
+      const end = Number(mEnd[1]);
+      if (end > pendingStart) intervals.push({ start: pendingStart, end });
+      pendingStart = null;
+    }
+  }
+  if (pendingStart !== null && sourceDurationS > pendingStart) {
+    intervals.push({ start: pendingStart, end: sourceDurationS });
+  }
+  return intervals;
+}
+async function detectSilences(source, noiseDb, minSilenceS, sourceDurationS) {
+  const res = await run(silenceDetectArgs(source, noiseDb, minSilenceS), {
+    capture: true,
+    check: false,
+    echo: false
+  });
+  return parseSilenceDetect(res.stderr, sourceDurationS);
+}
+
+// src/timeline-v2/schema.ts
+import { z } from "zod";
+var provenanceSchema = z.object({
+  round: z.number().int().nullable().default(null),
+  changeId: z.string().nullable().default(null),
+  actor: z.enum(["agent", "user"]).default("agent")
+}).strict().default({ round: null, changeId: null, actor: "agent" });
+var wordsAnchorSchema = z.object({
+  type: z.literal("words"),
+  source: z.string().min(1),
+  phrase: z.string().min(1),
+  /** 1-based occurrence index when the phrase appears more than once. */
+  occurrence: z.number().int().min(1).optional(),
+  /** Cached resolution in SOURCE seconds. */
+  resolved: z.object({ start: z.number().min(0), end: z.number().min(0) }).strict().optional(),
+  /** Collapse the span to one instant (phrase start or end). */
+  edge: z.enum(["start", "end"]).optional()
+}).strict();
+var sourceAnchorSchema = z.object({
+  type: z.literal("source"),
+  source: z.string().min(1),
+  start: z.number().min(0),
+  end: z.number().min(0)
+}).strict();
+var outputAnchorSchema = z.object({
+  type: z.literal("output"),
+  at: z.union([z.enum(["start", "end", "full"]), z.object({ after: z.string().min(1) }).strict()]),
+  durationS: z.number().positive().optional()
+}).strict();
+var anchorSchema = z.discriminatedUnion("type", [
+  wordsAnchorSchema,
+  sourceAnchorSchema,
+  outputAnchorSchema
+]);
+var timelineSourceSchema = z.object({
+  /** Path (absolute or job-dir-relative) to the media file. */
+  path: z.string().min(1),
+  durationS: z.number().positive().optional(),
+  /** "sha256:<hex>" of the transcript JSON this doc's cached anchor
+   *  resolutions were computed against. */
+  transcriptHash: z.string().optional()
+}).strict();
+var desilenceSettingsSchema = z.object({
+  noiseDb: z.number(),
+  minSilence: z.number().positive(),
+  targetGap: z.number().min(0),
+  leadKeep: z.number().min(0),
+  trailKeep: z.number().min(0),
+  minSegment: z.number().min(0)
+}).partial().strict();
+var gradeSettingSchema = z.object({ preset: z.string(), intensity: z.number().min(0).max(1).optional() }).strict();
+var settingsSchema = z.object({
+  canvas: z.object({ w: z.number().int().positive(), h: z.number().int().positive() }).strict().default({ w: 1080, h: 1920 }),
+  /** "none" | preset name | raw ffmpeg filter | "auto" (same as EDL grade),
+   *  or a declarative {preset, intensity?} grade for the composition path. */
+  grade: z.union([z.string(), gradeSettingSchema]).default("none"),
+  loudnorm: z.boolean().default(true),
+  /** Optional DesilenceOptions subset; merged over DEFAULT_DESILENCE. */
+  desilence: desilenceSettingsSchema.optional()
+}).strict().default({ canvas: { w: 1080, h: 1920 }, grade: "none", loudnorm: true });
+var cutRangeSchema = z.object({
+  id: z.string().min(1),
+  source: z.string().min(1),
+  start: z.number().min(0),
+  end: z.number().min(0),
+  beat: z.string().optional(),
+  quote: z.string().optional(),
+  reason: z.string().optional(),
+  /** Optional per-range grade override (kept for v1 EDL round-trips). */
+  grade: z.string().optional(),
+  provenance: provenanceSchema
+}).strict();
+var cutSchema = z.object({ ranges: z.array(cutRangeSchema).default([]) }).strict().default({ ranges: [] });
+var CSS_COLOR_RE = /^(#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})|[a-zA-Z]+)$/;
+var captionOverrideSchema = z.object({
+  id: z.string().min(1),
+  anchor: wordsAnchorSchema,
+  op: z.enum(["replace-text", "hide", "break-line", "style"]),
+  text: z.string().optional(),
+  /** op:"style" — per-word color (hex or simple CSS color name). */
+  color: z.string().regex(CSS_COLOR_RE, "must be a hex color or a simple CSS color name").optional(),
+  /** op:"style" — per-word animated emphasis at the word's onset. */
+  emphasis: z.enum(["pop", "highlight"]).optional(),
+  provenance: provenanceSchema
+}).strict();
+var captionPresetSchema = z.enum(["grouped", "opus-karaoke"]);
+var captionStyleSchema = z.object({
+  /** Max words per grouped cue (preset "grouped" only). */
+  maxWords: z.number().int().min(1).max(20).optional(),
+  /** Inter-word gap (seconds) that ends a phrase — a hard cue boundary
+   *  (preset "grouped" only). */
+  gapBreakS: z.number().min(0).max(5).optional(),
+  /** Seconds each cue's display start is shifted EARLIER (clamped to the
+   *  previous cue's end / the segment's outStart). */
+  leadS: z.number().min(0).max(1).optional(),
+  /** Max seconds a cue is held past its last word to bridge the gap to the
+   *  next cue (never past the segment's outEnd). */
+  holdS: z.number().min(0).max(5).optional(),
+  /** Per-word highlight sweep within grouped cues (karaoke-style). */
+  karaoke: z.boolean().optional()
+}).passthrough();
+var CAPTION_STYLE_DEFAULTS = { maxWords: 4, gapBreakS: 0.6, leadS: 0.08, holdS: 0.9 };
+var captionsSchema = z.object({
+  enabled: z.boolean().default(false),
+  preset: captionPresetSchema.default("grouped"),
+  style: captionStyleSchema.default({}),
+  overrides: z.array(captionOverrideSchema).default([])
+}).strict().default({ enabled: false, preset: "grouped", style: {}, overrides: [] });
+var onCutSchema = z.enum(["clip", "drop", "error"]);
+var zoomRectSchema = z.object({
+  x: z.number().min(0).max(1),
+  y: z.number().min(0).max(1),
+  w: z.number().min(0).max(1),
+  h: z.number().min(0).max(1)
+}).strict();
+var zoomSchema = z.object({
+  id: z.string().min(1),
+  anchor: anchorSchema,
+  onCut: onCutSchema.default("clip"),
+  rect: zoomRectSchema,
+  scale: z.number().gt(1).lte(3),
+  /** Ramp target: when present, the zoom animates from the base rect/scale
+   *  to `to` over the zoom window (`ease` shapes the ramp). */
+  to: z.object({
+    rect: zoomRectSchema.optional(),
+    scale: z.number().gt(1).lte(3).optional()
+  }).strict().optional(),
+  ease: z.object({ in: z.number().min(0), out: z.number().min(0) }).strict().default({ in: 0.25, out: 0.25 }),
+  provenance: provenanceSchema
+}).strict();
+var assetRefSchema = z.object({ ref: z.string().min(1) }).strict();
+var overlayFxSchema = z.object({
+  preset: z.enum(["fade", "pop", "slide-up", "slide-down", "scale-in"]),
+  durationS: z.number().positive().max(2)
+}).strict();
+var overlaySchema = z.object({
+  id: z.string().min(1),
+  kind: z.enum(["text", "title-card", "image", "sticker"]),
+  anchor: anchorSchema,
+  onCut: onCutSchema.default("drop"),
+  layout: z.object({
+    x: z.number().min(0).max(1).default(0.5),
+    y: z.number().min(0).max(1).default(0.82),
+    align: z.enum(["left", "center", "right"]).default("center"),
+    safeArea: z.boolean().default(true)
+  }).strict().default({ x: 0.5, y: 0.82, align: "center", safeArea: true }),
+  text: z.string().optional(),
+  style: z.object({ preset: z.string().optional() }).passthrough().default({}),
+  durationS: z.number().positive().optional(),
+  asset: assetRefSchema.optional(),
+  /** Entrance/exit presets (image/sticker overlays). */
+  enter: overlayFxSchema.optional(),
+  exit: overlayFxSchema.optional(),
+  /** Size as canvas fractions (w of canvas width, h of canvas height). */
+  size: z.object({
+    w: z.number().min(0).max(1).optional(),
+    h: z.number().min(0).max(1).optional()
+  }).strict().optional(),
+  /** Stacking order (CSS z-index); temporal lanes stay non-overlapping. */
+  z: z.number().int().min(0).max(50).optional(),
+  provenance: provenanceSchema
+}).strict();
+var audioSchema = z.object({
+  id: z.string().min(1),
+  kind: z.enum(["music", "sfx"]),
+  asset: assetRefSchema,
+  anchor: anchorSchema,
+  gainDb: z.number().default(-18),
+  duckToSpeech: z.boolean().default(true),
+  fadeOutS: z.number().min(0).optional(),
+  provenance: provenanceSchema
+}).strict();
+var timelineV2Schema = z.object({
+  version: z.literal(2),
+  id: z.string().regex(/^tl_/, 'timeline id must start with "tl_"'),
+  sources: z.record(timelineSourceSchema).refine((s) => Object.keys(s).length > 0, {
+    message: "at least one source is required"
+  }),
+  settings: settingsSchema,
+  cut: cutSchema,
+  captions: captionsSchema,
+  zooms: z.array(zoomSchema).default([]),
+  overlays: z.array(overlaySchema).default([]),
+  audio: z.array(audioSchema).default([])
+}).strict();
+function emptyDiagnostics() {
+  return { errors: [], warnings: [], dropped: [] };
+}
+function parseTimeline(raw) {
+  if (raw !== null && typeof raw === "object" && typeof raw.captions === "object" && raw.captions !== null && "cues" in raw.captions) {
+    return {
+      doc: null,
+      errors: [
+        {
+          path: "captions.cues",
+          code: "captions-authored-cues",
+          message: "caption cues are derived by compile and must never be stored in timeline.json",
+          suggestion: "remove captions.cues; author only enabled/preset/style/overrides"
+        }
+      ]
+    };
+  }
+  const parsed = timelineV2Schema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      doc: null,
+      errors: parsed.error.issues.map((iss) => ({
+        path: iss.path.map((p) => typeof p === "number" ? `[${p}]` : p).join(".").replace(/\.\[/g, "["),
+        code: `schema:${iss.code}`,
+        message: iss.message
+      }))
+    };
+  }
+  return { doc: parsed.data, errors: [] };
+}
+var EPS = 1e-6;
+function itemIds(doc) {
+  return [
+    ...doc.cut.ranges.map((r) => r.id),
+    ...doc.captions.overrides.map((o) => o.id),
+    ...doc.zooms.map((zm) => zm.id),
+    ...doc.overlays.map((ov) => ov.id),
+    ...doc.audio.map((a) => a.id)
+  ];
+}
+function checkAnchorSource(anchor, doc, path, errors) {
+  if (anchor.type === "output") return;
+  if (!(anchor.source in doc.sources)) {
+    errors.push({
+      path: `${path}.source`,
+      code: "unknown-source",
+      message: `anchor references unknown source "${anchor.source}"`,
+      suggestion: `known sources: ${Object.keys(doc.sources).join(", ")}`
+    });
+  }
+  if (anchor.type === "source" && anchor.end <= anchor.start) {
+    errors.push({
+      path,
+      code: "bad-anchor-span",
+      message: `source anchor end (${anchor.end}) must be greater than start (${anchor.start})`
+    });
+  }
+}
+function validateTimeline(doc) {
+  const errors = [];
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const id of itemIds(doc)) seen.set(id, (seen.get(id) ?? 0) + 1);
+  for (const [id, count] of seen) {
+    if (count > 1) {
+      errors.push({
+        path: "(items)",
+        code: "duplicate-id",
+        message: `item id "${id}" is used ${count} times; ids must be unique across all items`
+      });
+    }
+  }
+  const lastEndBySource = /* @__PURE__ */ new Map();
+  doc.cut.ranges.forEach((r, i) => {
+    const path = `cut.ranges[${i}]`;
+    if (!(r.source in doc.sources)) {
+      errors.push({
+        path: `${path}.source`,
+        code: "unknown-source",
+        message: `cut range "${r.id}" references unknown source "${r.source}"`,
+        suggestion: `known sources: ${Object.keys(doc.sources).join(", ")}`
+      });
+      return;
+    }
+    if (r.end <= r.start) {
+      errors.push({
+        path,
+        code: "bad-range",
+        message: `cut range "${r.id}" has end (${r.end}) <= start (${r.start})`
+      });
+      return;
+    }
+    const dur = doc.sources[r.source].durationS;
+    if (dur !== void 0 && r.end > dur + EPS) {
+      errors.push({
+        path: `${path}.end`,
+        code: "range-out-of-bounds",
+        message: `cut range "${r.id}" ends at ${r.end}s but source "${r.source}" is ${dur}s long`
+      });
+    }
+    const prev = lastEndBySource.get(r.source);
+    if (prev !== void 0) {
+      if (r.start < prev.end - EPS) {
+        const code = r.start <= doc.cut.ranges[prev.index].start + EPS ? "range-order" : "range-overlap";
+        errors.push({
+          path,
+          code,
+          message: code === "range-order" ? `cut range "${r.id}" is out of order: ranges of source "${r.source}" must be sorted by start` : `cut range "${r.id}" overlaps the previous range of source "${r.source}" (starts at ${r.start} before previous end ${prev.end})`
+        });
+      }
+    }
+    lastEndBySource.set(r.source, { end: r.end, index: i });
+  });
+  doc.captions.overrides.forEach((o, i) => {
+    checkAnchorSource(o.anchor, doc, `captions.overrides[${i}].anchor`, errors);
+    if (o.op === "replace-text" && (o.text === void 0 || o.text.length === 0)) {
+      errors.push({
+        path: `captions.overrides[${i}].text`,
+        code: "missing-text",
+        message: `caption override "${o.id}" has op "replace-text" but no text`
+      });
+    }
+    if (o.op === "style" && o.color === void 0 && o.emphasis === void 0) {
+      errors.push({
+        path: `captions.overrides[${i}]`,
+        code: "missing-style",
+        message: `caption override "${o.id}" has op "style" but neither color nor emphasis`,
+        suggestion: 'set color (e.g. "#ff5c5c") and/or emphasis ("pop" | "highlight")'
+      });
+    }
+  });
+  doc.zooms.forEach((zm, i) => {
+    const path = `zooms[${i}]`;
+    checkAnchorSource(zm.anchor, doc, `${path}.anchor`, errors);
+    if (zm.rect.x + zm.rect.w > 1 + EPS || zm.rect.y + zm.rect.h > 1 + EPS) {
+      errors.push({
+        path: `${path}.rect`,
+        code: "bad-rect",
+        message: `zoom "${zm.id}" rect exceeds the unit canvas (x+w=${zm.rect.x + zm.rect.w}, y+h=${zm.rect.y + zm.rect.h})`,
+        suggestion: "keep x+w <= 1 and y+h <= 1"
+      });
+    }
+    if (zm.to !== void 0) {
+      if (zm.to.rect === void 0 && zm.to.scale === void 0) {
+        errors.push({
+          path: `${path}.to`,
+          code: "empty-ramp",
+          message: `zoom "${zm.id}" has a ramp target "to" with neither rect nor scale`,
+          suggestion: "set to.rect and/or to.scale, or remove to"
+        });
+      }
+      const tr = zm.to.rect;
+      if (tr && (tr.x + tr.w > 1 + EPS || tr.y + tr.h > 1 + EPS)) {
+        errors.push({
+          path: `${path}.to.rect`,
+          code: "bad-rect",
+          message: `zoom "${zm.id}" to.rect exceeds the unit canvas (x+w=${tr.x + tr.w}, y+h=${tr.y + tr.h})`,
+          suggestion: "keep x+w <= 1 and y+h <= 1"
+        });
+      }
+    }
+  });
+  doc.overlays.forEach((ov, i) => {
+    const path = `overlays[${i}]`;
+    checkAnchorSource(ov.anchor, doc, `${path}.anchor`, errors);
+    if ((ov.kind === "image" || ov.kind === "sticker") && !ov.asset) {
+      errors.push({
+        path: `${path}.asset`,
+        code: "missing-asset",
+        message: `overlay "${ov.id}" has kind "${ov.kind}" but no asset`
+      });
+    }
+    if ((ov.kind === "text" || ov.kind === "title-card") && (ov.text === void 0 || ov.text.length === 0)) {
+      errors.push({
+        path: `${path}.text`,
+        code: "missing-text",
+        message: `overlay "${ov.id}" has kind "${ov.kind}" but no text`
+      });
+    }
+  });
+  doc.audio.forEach((a, i) => {
+    checkAnchorSource(a.anchor, doc, `audio[${i}].anchor`, errors);
+  });
+  const fullAudio = doc.audio.filter((a) => a.anchor.type === "output" && a.anchor.at === "full");
+  if (fullAudio.length > 1) {
+    errors.push({
+      path: "audio",
+      code: "multiple-full-audio",
+      message: `at most one audio item may use at:"full" (found ${fullAudio.length}: ${fullAudio.map((a) => a.id).join(", ")})`
+    });
+  }
+  const ids = new Set(itemIds(doc));
+  const checkAfter = (anchor, ownerId, path) => {
+    if (anchor.type !== "output" || typeof anchor.at === "string") return;
+    const target = anchor.at.after;
+    if (!ids.has(target)) {
+      errors.push({
+        path,
+        code: "unknown-after-target",
+        message: `after:"${target}" does not reference any existing item id`
+      });
+    } else if (target === ownerId) {
+      errors.push({
+        path,
+        code: "after-cycle",
+        message: `item "${ownerId}" cannot be anchored after itself`
+      });
+    }
+  };
+  doc.zooms.forEach((zm, i) => checkAfter(zm.anchor, zm.id, `zooms[${i}].anchor.at.after`));
+  doc.overlays.forEach((ov, i) => checkAfter(ov.anchor, ov.id, `overlays[${i}].anchor.at.after`));
+  doc.audio.forEach((a, i) => checkAfter(a.anchor, a.id, `audio[${i}].anchor.at.after`));
+  return { errors, warnings };
+}
+
+// src/timeline-v2/capabilities.ts
+var CAPABILITIES = {
+  cut: { status: "ready" },
+  "captions.karaoke": { status: "ready" },
+  // Per-word color/emphasis styling — rendered by composeHtml (render-proven).
+  "captions.word-style": { status: "ready" },
+  // Karaoke per-word sweep compiles + composes, but the sweep itself has not
+  // been through a validation render yet.
+  "captions.karaoke-highlight": { status: "staged" },
+  zoom: { status: "ready" },
+  // Animated zoom ramps (base → to over the window) — render-proven GSAP path.
+  "zoom.ramp": { status: "ready" },
+  "overlay.text": { status: "ready" },
+  "overlay.title-card": { status: "ready" },
+  "overlay.image": { status: "ready" },
+  "overlay.sticker": { status: "ready" },
+  "overlay.enter-exit": { status: "ready" },
+  // Audio beds/sfx are schema-complete but the render integration is staged.
+  "audio.music": { status: "staged" },
+  "audio.sfx": { status: "staged" },
+  // Declarative color grade (data-color-grading) — not yet render-proven.
+  grade: { status: "staged" }
+};
+function usesFromDoc(doc) {
+  const uses = [];
+  const add = (k) => {
+    if (!uses.includes(k)) uses.push(k);
+  };
+  if (doc.cut.ranges.length > 0) add("cut");
+  if (doc.captions.enabled) {
+    add("captions.karaoke");
+    if (doc.captions.overrides.some((o) => o.op === "style")) add("captions.word-style");
+    if (doc.captions.style.karaoke === true) add("captions.karaoke-highlight");
+  }
+  if (doc.zooms.length > 0) add("zoom");
+  if (doc.zooms.some((zm) => zm.to !== void 0)) add("zoom.ramp");
+  for (const ov of doc.overlays) {
+    add(`overlay.${ov.kind}`);
+    if (ov.enter !== void 0 || ov.exit !== void 0) add("overlay.enter-exit");
+  }
+  for (const a of doc.audio) add(`audio.${a.kind}`);
+  if (typeof doc.settings.grade === "object") add("grade");
+  return uses;
+}
+function checkCapabilities(uses, registry = CAPABILITIES) {
+  const errors = [];
+  const warnings = [];
+  for (const key of uses) {
+    const status = registry[key]?.status ?? "none";
+    if (status === "none") {
+      errors.push({
+        path: "(capabilities)",
+        code: "capability-none",
+        message: `feature "${key}" is used by this timeline but is not available in this build`,
+        suggestion: "remove the items using it, or upgrade the renderer",
+        context: { feature: key, status }
+      });
+    } else if (status === "staged") {
+      warnings.push({
+        path: "(capabilities)",
+        code: "capability-staged",
+        message: `feature "${key}" is staged: it compiles into the plan but the render path may not honor it yet`,
+        context: { feature: key, status }
+      });
+    }
+  }
+  return { errors, warnings };
+}
+
+// src/cloud/compile2.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { isAbsolute, join as join8, resolve as resolve2 } from "path";
+function timelineJsonPath2(jobDir) {
+  return join8(jobDir, "timeline.json");
+}
+function planPath2(jobDir) {
+  return join8(jobDir, "resolved", "plan.json");
+}
+function diagnosticsPath2(jobDir) {
+  return join8(jobDir, "resolved", "diagnostics.json");
+}
+function loadTimeline2(jobDir) {
+  const path = timelineJsonPath2(jobDir);
+  if (!existsSync6(path)) {
+    return {
+      doc: null,
+      raw: null,
+      errors: [{ path: "(file)", code: "missing-file", message: `timeline not found: ${path}` }]
+    };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync5(path, "utf8"));
+  } catch (err) {
+    return {
+      doc: null,
+      raw: null,
+      errors: [
+        {
+          path: "(file)",
+          code: "invalid-json",
+          message: `timeline.json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ]
+    };
+  }
+  const parsed = parseTimeline(raw);
+  return { doc: parsed.doc, raw, errors: parsed.errors };
+}
+function validateLocal(doc) {
+  const sem = validateTimeline(doc);
+  const uses = usesFromDoc(doc);
+  const cap = checkCapabilities(uses);
+  const errors = [...sem.errors, ...cap.errors];
+  const warnings = [...sem.warnings, ...cap.warnings];
+  return { ok: errors.length === 0, uses, errors, warnings };
+}
+async function detectSilencesForDoc(jobDir, doc) {
+  const dopts = { ...DEFAULT_DESILENCE, ...doc.settings.desilence ?? {} };
+  const out = {};
+  for (const [name, src] of Object.entries(doc.sources)) {
+    const srcPath = isAbsolute(src.path) ? src.path : resolve2(jobDir, src.path);
+    if (!existsSync6(srcPath)) continue;
+    const dur = src.durationS ?? await mediaDuration(srcPath);
+    out[name] = await detectSilences(srcPath, dopts.noiseDb, dopts.minSilence, dur);
+  }
+  return out;
+}
+function statAssetsForDoc(jobDir, doc) {
+  const out = {};
+  const statRef = (ref) => {
+    if (ref !== void 0 && !(ref in out)) {
+      out[ref] = existsSync6(isAbsolute(ref) ? ref : resolve2(jobDir, ref));
+    }
+  };
+  for (const ov of doc.overlays) statRef(ov.asset?.ref);
+  for (const a of doc.audio) statRef(a.asset.ref);
+  return out;
+}
+async function compileRemote(client, jobDir, loaded) {
+  if (!loaded.doc) throw new Error("compileRemote requires a parsed timeline");
+  const silences = await detectSilencesForDoc(jobDir, loaded.doc);
+  const assets = statAssetsForDoc(jobDir, loaded.doc);
+  const res = await client.compileRemote({
+    timeline: loaded.raw,
+    ...Object.keys(silences).length > 0 ? { silences_by_source: silences } : {},
+    ...Object.keys(assets).length > 0 ? { assets_present: assets } : {}
+  });
+  const dir = join8(jobDir, "resolved");
+  mkdirSync6(dir, { recursive: true });
+  const out = { ok: res.ok === true, diagnosticsPath: diagnosticsPath2(jobDir), response: res };
+  writeFileSync5(out.diagnosticsPath, JSON.stringify(res.diagnostics ?? { errors: [], warnings: [], dropped: [] }, null, 2) + "\n", "utf8");
+  if (res.ok === true && res.plan !== void 0 && res.plan !== null) {
+    out.planPath = planPath2(jobDir);
+    writeFileSync5(out.planPath, JSON.stringify(res.plan, null, 2) + "\n", "utf8");
+  }
+  if (res.ok === true && res.legacy_edl !== void 0 && res.legacy_edl !== null) {
+    out.edlPath = join8(jobDir, "edl.json");
+    writeFileSync5(out.edlPath, JSON.stringify(res.legacy_edl, null, 2) + "\n", "utf8");
+  }
+  return out;
+}
+
+// src/cloud/verify2.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join9 } from "path";
+async function verifyCloud(client, jobDir, opts = {}) {
+  const verbose = opts.verbose !== false;
+  const log = (line) => {
+    if (verbose) process.stderr.write(line + "\n");
+  };
+  const preview = join9(jobDir, "preview.mp4");
+  if (!existsSync7(preview)) {
+    throw new Error(`preview not found (render first, e.g. \`video-editing cloud render --mode preview --wait\`): ${preview}`);
+  }
+  log("  extracting preview audio");
+  const { bytes, durationS } = await extractGuardedWav(preview);
+  const wavPath = "audio/preview.wav";
+  log(`  uploading ${wavPath} (${(bytes.length / (1024 * 1024)).toFixed(1)} MB)`);
+  await uploadVfsBytes(client, wavPath, bytes, "audio/wav");
+  let edl;
+  const edlPath = join9(jobDir, "edl.json");
+  if (existsSync7(edlPath)) {
+    try {
+      edl = JSON.parse(readFileSync6(edlPath, "utf8"));
+    } catch {
+      edl = void 0;
+    }
+  }
+  const { runId } = await client.verifyStart({
+    wav_path: wavPath,
+    preview_duration_s: durationS,
+    ...opts.full ? { mode: "full" } : {},
+    ...opts.windowS !== void 0 ? { window_s: opts.windowS } : {},
+    ...edl !== void 0 ? { edl } : {}
+  });
+  log(`  verify run: ${runId}`);
+  const state = await pollRun(client, runId, {
+    intervalMs: opts.pollIntervalMs,
+    onEvent: (ev) => log(`  ${formatRunEvent(ev)}`)
+  });
+  assertRunCompleted(state, "verify");
+  await pullFiles(client, jobDir, { only: ["verify.json"] });
+  const verifyPath = join9(jobDir, "verify.json");
+  let verdict = null;
+  let findings = null;
+  if (existsSync7(verifyPath)) {
+    try {
+      const v = JSON.parse(readFileSync6(verifyPath, "utf8"));
+      verdict = typeof v.verdict === "string" ? v.verdict : null;
+      findings = Array.isArray(v.joins) ? v.joins.length : null;
+    } catch {
+    }
+  }
+  return { runId, verifyPath, verdict, findings };
+}
+
+// src/cloud/compose2.ts
+import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync7, statSync as statSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5, join as join10, resolve as resolvePath2 } from "path";
+function stale(out, src) {
+  return !existsSync8(out) || statSync4(out).mtimeMs < statSync4(src).mtimeMs;
+}
+async function buildMediaEntry(jobDir, compDir, entry, opts) {
+  const dest = join10(compDir, ...entry.src.split("/").filter((p) => p !== "" && p !== "." && p !== ".."));
+  mkdirSync7(dirname5(dest), { recursive: true });
+  if (entry.role === "video" || entry.role === "source") {
+    const master = join10(jobDir, "vertical_src.mp4");
+    if (!existsSync8(master)) {
+      throw new Error(
+        `vertical master not found: ${master} \u2014 bake it locally (\`video-editing init --source <video> --master\`) or pull it`
+      );
+    }
+    if (stale(dest, master)) {
+      await run([
+        "ffmpeg",
+        "-y",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-stats",
+        "-i",
+        master,
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        String(opts.proxyCrf),
+        // Dense keyframes: HyperFrames frame-extracts per clip; sparse GOPs
+        // (default ~8s) break seeks on sub-second segments.
+        "-r",
+        "30",
+        "-g",
+        "30",
+        "-keyint_min",
+        "30",
+        "-movflags",
+        "+faststart",
+        "-maxrate",
+        "6M",
+        "-bufsize",
+        "12M",
+        "-c:a",
+        "aac",
+        "-b:a",
+        "160k",
+        "-movflags",
+        "+faststart",
+        dest
+      ]);
+    } else {
+      process.stderr.write("  proxy up to date; skipping re-encode\n");
+    }
+    return dest;
+  }
+  if (entry.role === "audio") {
+    const preview = join10(jobDir, "preview.mp4");
+    if (existsSync8(preview)) {
+      if (stale(dest, preview)) {
+        await run([
+          "ffmpeg",
+          "-y",
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-stats",
+          "-i",
+          preview,
+          "-vn",
+          "-c:a",
+          "aac",
+          "-b:a",
+          "160k",
+          dest
+        ]);
+      } else {
+        process.stderr.write("  cut audio up to date; skipping re-extract\n");
+      }
+      return dest;
+    }
+    const master = join10(jobDir, "vertical_src.mp4");
+    const planPath = join10(jobDir, "resolved", "plan.json");
+    if (!existsSync8(master) || !existsSync8(planPath)) {
+      throw new Error(
+        `cut audio needs either <job>/preview.mp4 or vertical_src.mp4 + resolved/plan.json (compile first)`
+      );
+    }
+    const plan = JSON.parse(readFileSync7(planPath, "utf8"));
+    const segs = (plan.segments ?? []).filter(
+      (x) => typeof x.srcStart === "number" && typeof x.srcEnd === "number" && x.srcEnd > x.srcStart
+    );
+    if (segs.length === 0) throw new Error("resolved/plan.json has no usable segments for cut audio");
+    const trims = segs.map((x, i) => `[0:a]atrim=start=${x.srcStart}:end=${x.srcEnd},asetpts=PTS-STARTPTS[a${i}]`).join(";");
+    const labels = segs.map((_, i) => `[a${i}]`).join("");
+    const filter = `${trims};${labels}concat=n=${segs.length}:v=0:a=1[out]`;
+    await run([
+      "ffmpeg",
+      "-y",
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-stats",
+      "-i",
+      master,
+      "-filter_complex",
+      filter,
+      "-map",
+      "[out]",
+      "-c:a",
+      "aac",
+      "-b:a",
+      "160k",
+      dest
+    ]);
+    return dest;
+  }
+  const ref = entry.src.replace(/^media\//, "");
+  const srcPath = resolvePath2(jobDir, ref);
+  if (!existsSync8(srcPath)) {
+    throw new Error(`asset not found: ${ref} (expected at ${srcPath}) \u2014 asset refs are job-dir-relative paths`);
+  }
+  copyFileSync(srcPath, dest);
+  return dest;
+}
+async function composeCloud(client, jobDir, opts = {}) {
+  const quality = opts.quality ?? "standard";
+  if (!["draft", "standard", "high"].includes(quality)) throw new Error("--quality must be draft|standard|high");
+  const fps = opts.fps ?? 30;
+  const proxyCrf = opts.proxyCrf ?? 23;
+  const res = await client.getCompose();
+  const compDir = join10(jobDir, "composition");
+  mkdirSync7(join10(compDir, "media"), { recursive: true });
+  const entry = join10(compDir, "index.html");
+  writeFileSync6(entry, res.html, "utf8");
+  for (const m of res.media) {
+    await buildMediaEntry(jobDir, compDir, m, { proxyCrf });
+  }
+  const out = resolvePath2(opts.out ?? join10(jobDir, "preview.mp4"));
+  const renderCmd = ["hyperframes", "render", "--quality", quality, "--fps", String(fps), "--output", out];
+  const result = {
+    compositionDir: compDir,
+    entry,
+    counts: res.counts,
+    media: res.media,
+    renderCmd,
+    rendered: false
+  };
+  if (!opts.render) {
+    if (opts.verbose !== false) {
+      process.stderr.write(`render locally: cd ${shown([compDir])} && ${shown(renderCmd)}
+`);
+    }
+    return result;
+  }
+  const probe = runSync(["hyperframes", "--version"], { check: false, echo: false });
+  if (probe.code !== 0) {
+    throw new Error("`hyperframes` CLI not found on PATH \u2014 install it with `npm install -g hyperframes`");
+  }
+  const render = await run(renderCmd, { cwd: compDir, check: false });
+  result.renderExit = render.code;
+  result.rendered = render.code === 0;
+  if (render.code === 0) result.out = out;
+  return result;
+}
+
+// src/cloud/qa-local.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync8, readdirSync as readdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join11 } from "path";
+function qaFramesArgs(win, opts = {}) {
+  const dur = Math.max(0.05, win.end - win.start);
+  const frames = Math.max(1, Math.round(opts.frames ?? 10));
+  const cols = Math.max(1, Math.round(opts.cols ?? 5));
+  const rows = Math.ceil(frames / cols);
+  const fps = frames / dur;
+  const width = Math.max(64, Math.round(opts.frameWidth ?? 216));
+  return [
+    "ffmpeg",
+    "-y",
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-ss",
+    win.start.toFixed(3),
+    "-t",
+    dur.toFixed(3),
+    "-i",
+    win.video,
+    "-frames:v",
+    "1",
+    "-vf",
+    `fps=${fps.toFixed(6)},scale=${width}:-2,tile=${cols}x${rows}`,
+    win.output
+  ];
+}
+function qaWaveformArgs(win, opts = {}) {
+  const dur = Math.max(0.05, win.end - win.start);
+  const w = Math.max(64, Math.round(opts.width ?? 1200));
+  const h = Math.max(32, Math.round(opts.height ?? 240));
+  return [
+    "ffmpeg",
+    "-y",
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-ss",
+    win.start.toFixed(3),
+    "-t",
+    dur.toFixed(3),
+    "-i",
+    win.video,
+    "-filter_complex",
+    `showwavespic=s=${w}x${h}:split_channels=0`,
+    "-frames:v",
+    "1",
+    win.output
+  ];
+}
+function qaWordsForWindow(transcriptJson, start, end) {
+  const data = JSON.parse(transcriptJson);
+  const out = [];
+  for (const w of data.words ?? []) {
+    if ((w.type ?? "word") !== "word") continue;
+    if (typeof w.start !== "number" || typeof w.end !== "number") continue;
+    if (w.end < start || w.start > end) continue;
+    const text = typeof w.text === "string" ? w.text.trim() : "";
+    if (!text) continue;
+    out.push({ t: w.start, end: w.end, text });
+  }
+  return out;
+}
+function findLocalTranscript(jobDir, stem) {
+  const dir = join11(jobDir, "transcripts");
+  if (stem) {
+    const direct = join11(dir, `${stem}.json`);
+    if (existsSync9(direct)) return direct;
+  }
+  if (!existsSync9(dir)) return null;
+  const all = readdirSync2(dir).filter((f) => f.endsWith(".json"));
+  return all.length === 1 ? join11(dir, all[0]) : null;
+}
+async function qaFramesLocal(jobDir, args) {
+  const dir = join11(jobDir, "qa");
+  mkdirSync8(dir, { recursive: true });
+  const png = join11(dir, `frames_${args.start}_${args.end}.png`);
+  await run(qaFramesArgs({ video: args.video, start: args.start, end: args.end, output: png }, args), {
+    capture: true,
+    echo: false
+  });
+  return { png };
+}
+async function qaWaveformLocal(jobDir, args) {
+  const dir = join11(jobDir, "qa");
+  mkdirSync8(dir, { recursive: true });
+  const png = join11(dir, `waveform_${args.start}_${args.end}.png`);
+  await run(qaWaveformArgs({ video: args.video, start: args.start, end: args.end, output: png }), {
+    capture: true,
+    echo: false
+  });
+  const result = { png };
+  const tpath = findLocalTranscript(jobDir, args.stem);
+  if (tpath) {
+    const words = qaWordsForWindow(readFileSync8(tpath, "utf8"), args.start, args.end);
+    const wordsPath = join11(dir, `waveform_${args.start}_${args.end}.words.json`);
+    writeFileSync7(wordsPath, JSON.stringify(words, null, 2) + "\n", "utf8");
+    result.wordsPath = wordsPath;
+    result.words = words.length;
+  }
+  return result;
+}
+
+// src/cloud/review2.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync10, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { basename, isAbsolute as isAbsolute2, join as join12 } from "path";
+function reviewDir2(jobDir) {
+  return join12(jobDir, "review");
+}
+function roundJsonPath2(jobDir) {
+  return join12(reviewDir2(jobDir), "round.json");
+}
+function instructionPath2(jobDir) {
+  return join12(reviewDir2(jobDir), "instruction.md");
+}
+function assetsCachePath2(jobDir) {
+  return join12(reviewDir2(jobDir), "assets.json");
+}
+async function pullReview2(client, jobDir, opts = {}) {
+  const session = await client.getReview();
+  mkdirSync9(reviewDir2(jobDir), { recursive: true });
+  const round = session.activeRound;
+  if (round) {
+    writeFileSync8(
+      roundJsonPath2(jobDir),
+      JSON.stringify(
+        {
+          video_id: session.videoId,
+          round_id: round.roundId,
+          run_id: round.runId,
+          seq: round.seq,
+          mode: round.mode,
+          status: round.status,
+          pulled_at: (/* @__PURE__ */ new Date()).toISOString(),
+          changes: round.changes
+        },
+        null,
+        2
+      ) + "\n",
+      "utf8"
+    );
+    writeFileSync8(instructionPath2(jobDir), round.instruction + "\n", "utf8");
+  } else {
+    writeFileSync8(instructionPath2(jobDir), "No active review round for this video.\n", "utf8");
+  }
+  let wroteTimeline = false;
+  const tlPath = timelineJsonPath2(jobDir);
+  if (session.timeline !== null && session.timeline !== void 0 && !existsSync10(tlPath)) {
+    writeFileSync8(tlPath, JSON.stringify(session.timeline, null, 2) + "\n", "utf8");
+    wroteTimeline = true;
+  }
+  let downloadedSource = null;
+  if (opts.withSource && session.sourceUrl) {
+    const dest = join12(jobDir, "source.mp4");
+    if (!existsSync10(dest)) {
+      const dl = await client.download(session.sourceUrl, dest);
+      downloadedSource = dl.path;
+    }
+  }
+  return { jobDir, round, wroteTimeline, downloadedSource };
+}
+function resolveRunId2(jobDir, flagOverride) {
+  if (typeof flagOverride === "string" && flagOverride.trim() !== "") return flagOverride.trim();
+  const path = roundJsonPath2(jobDir);
+  if (existsSync10(path)) {
+    try {
+      const runId = JSON.parse(readFileSync9(path, "utf8")).run_id;
+      if (typeof runId === "string" && runId !== "") return runId;
+    } catch {
+    }
+  }
+  throw new Error(`missing run id \u2014 pass --run-id, or run \`review pull\` first (no run_id in ${path})`);
+}
+var REVIEW_STAGES2 = [
+  "provisioning",
+  "transcribing",
+  "edl",
+  "render_preview",
+  "qc",
+  "render_final",
+  "uploading",
+  "log"
+];
+async function pushStage2(client, runId, stage, message) {
+  if (!REVIEW_STAGES2.includes(stage)) {
+    throw new Error(`invalid --stage "${stage}" \u2014 expected one of: ${REVIEW_STAGES2.join(", ")}`);
+  }
+  await client.pushReview({
+    run_id: runId,
+    type: stage,
+    ...message !== void 0 ? { payload: { message } } : {}
+  });
+}
+var ASSET_CONTENT_TYPES2 = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mp4",
+  ".wav": "audio/wav"
+};
+function assetContentType2(ref) {
+  const m = /\.[^./\\]+$/.exec(ref.toLowerCase());
+  return (m !== null ? ASSET_CONTENT_TYPES2[m[0]] : void 0) ?? "application/octet-stream";
+}
+function collectPlanAssetRefs2(plan) {
+  const refs = [];
+  const events = plan?.events;
+  if (!Array.isArray(events)) return refs;
+  for (const ev of events) {
+    const e = ev;
+    if (!e || typeof e !== "object") continue;
+    let ref;
+    if (e.kind === "overlay") ref = e.overlay?.asset?.ref;
+    else if (e.kind === "audio") ref = e.audio?.asset?.ref;
+    if (typeof ref === "string" && ref !== "" && !refs.includes(ref)) refs.push(ref);
+  }
+  return refs;
+}
+async function syncAssets2(client, jobDir, plan) {
+  const refs = collectPlanAssetRefs2(plan);
+  if (refs.length === 0) return {};
+  const paths = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const abs = isAbsolute2(ref) ? ref : join12(jobDir, ref);
+    if (!existsSync10(abs)) {
+      throw new Error(
+        `asset not found: ${ref} (expected at ${abs}) \u2014 asset refs are job-dir-relative paths; place the file before pushing`
+      );
+    }
+    paths.set(ref, abs);
+  }
+  let cache = {};
+  if (existsSync10(assetsCachePath2(jobDir))) {
+    try {
+      const raw = JSON.parse(readFileSync9(assetsCachePath2(jobDir), "utf8"));
+      for (const [ref, v] of Object.entries(raw ?? {})) {
+        const e = v;
+        if (e && typeof e.sha256 === "string" && typeof e.asset_id === "string") {
+          cache[ref] = { sha256: e.sha256, asset_id: e.asset_id };
+        }
+      }
+    } catch {
+      cache = {};
+    }
+  }
+  const manifest = {};
+  let dirty = false;
+  for (const ref of refs) {
+    const bytes = readFileSync9(paths.get(ref));
+    const sha256 = "sha256:" + createHash2("sha256").update(bytes).digest("hex");
+    const hit = cache[ref];
+    if (hit !== void 0 && hit.sha256 === sha256) {
+      manifest[ref] = hit.asset_id;
+      continue;
+    }
+    const contentType = assetContentType2(ref);
+    const created = await client.createAsset({ kind: "timeline", contentType, filename: basename(ref) });
+    await client.upload(created.uploadUrl, bytes, contentType);
+    cache[ref] = { sha256, asset_id: created.assetId };
+    manifest[ref] = created.assetId;
+    dirty = true;
+  }
+  if (dirty) {
+    mkdirSync9(reviewDir2(jobDir), { recursive: true });
+    writeFileSync8(assetsCachePath2(jobDir), JSON.stringify(cache, null, 2) + "\n", "utf8");
+  }
+  return manifest;
+}
+async function compileViaServer(client, jobDir) {
+  const loaded = loadTimeline2(jobDir);
+  if (!loaded.doc) return { ok: false, errors: loaded.errors, diagnostics: null };
+  const res = await compileRemote(client, jobDir, loaded);
+  if (!res.ok) {
+    const diag = res.response.diagnostics;
+    return { ok: false, errors: diag?.errors ?? [], diagnostics: res.response.diagnostics ?? null };
+  }
+  const plan = res.response.plan;
+  const timelineHash = plan !== null && typeof plan === "object" && typeof plan.timelineHash === "string" ? plan.timelineHash : null;
+  return { ok: true, raw: loaded.raw, plan, legacyEdl: res.response.legacy_edl ?? null, timelineHash };
+}
+async function pushTimeline2(client, jobDir, runId) {
+  const compiled = await compileViaServer(client, jobDir);
+  if (!compiled.ok) return compiled;
+  const assets = await syncAssets2(client, jobDir, compiled.plan);
+  await client.pushReview({
+    run_id: runId,
+    type: "timeline_update",
+    payload: {
+      timeline: compiled.raw,
+      plan: compiled.plan,
+      ...compiled.timelineHash !== null ? { timeline_hash: compiled.timelineHash } : {},
+      ...Object.keys(assets).length > 0 ? { assets } : {}
+    }
+  });
+  return { ok: true, plan: compiled.plan, timelineHash: compiled.timelineHash, assets };
+}
+function readOutcomesFile2(path) {
+  if (!existsSync10(path)) throw new Error(`outcomes file not found: ${path}`);
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync9(path, "utf8"));
+  } catch (err) {
+    throw new Error(`outcomes file is not valid JSON: ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const arr = Array.isArray(raw) ? raw : raw?.outcomes;
+  if (!Array.isArray(arr)) {
+    throw new Error(`outcomes file must be an array (or {outcomes: [...]}) of {change_id, ok, note?}: ${path}`);
+  }
+  return arr.map((o, i) => {
+    const r = o ?? {};
+    if (typeof r.change_id !== "string" || typeof r.ok !== "boolean" || r.note !== void 0 && typeof r.note !== "string") {
+      throw new Error(`outcomes[${i}] must be {change_id: string, ok: boolean, note?: string}: ${JSON.stringify(o)}`);
+    }
+    return { change_id: r.change_id, ok: r.ok, ...r.note !== void 0 ? { note: r.note } : {} };
+  });
+}
+async function pushComplete2(client, jobDir, runId, opts) {
+  const outcomes = opts.outcomesPath ? readOutcomesFile2(opts.outcomesPath) : void 0;
+  const compiled = await compileViaServer(client, jobDir);
+  if (!compiled.ok) return compiled;
+  const assets = await syncAssets2(client, jobDir, compiled.plan);
+  await client.pushReview({
+    run_id: runId,
+    type: "completed",
+    payload: {
+      edl: compiled.legacyEdl,
+      timeline: compiled.raw,
+      plan: compiled.plan,
+      duration_s: opts.durationS,
+      ...outcomes !== void 0 ? { outcomes } : {},
+      ...Object.keys(assets).length > 0 ? { assets } : {}
+    }
+  });
+  return { ok: true, plan: compiled.plan, durationS: opts.durationS, outcomes, assets };
+}
+
+// src/public/config.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join13 } from "path";
+function publicConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && xdg.trim() ? xdg : join13(homedir2(), ".config");
+  return join13(base, "video-editing");
+}
+function publicConfigEnvPath() {
+  return join13(publicConfigDir(), ".env");
+}
+function parseEnvLines(text) {
+  return text.split(/\r?\n/).map((raw) => {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || !line.includes("=")) return { raw };
+    const eq = line.indexOf("=");
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    value = value.replace(/^"|"$/g, "").replace(/^'|'$/g, "").trim();
+    return { raw, key, value };
+  });
+}
+var MANAGED_KEYS = ["CLIPREADY_API_KEY", "CLIPREADY_API_BASE"];
+function loadPublicConfigEnv(env = process.env) {
+  const path = publicConfigEnvPath();
+  if (!existsSync11(path)) return;
+  let text;
+  try {
+    text = readFileSync10(path, "utf8");
+  } catch {
+    return;
+  }
+  for (const line of parseEnvLines(text)) {
+    if (!line.key || line.value === void 0) continue;
+    if (!MANAGED_KEYS.includes(line.key)) continue;
+    if (!env[line.key] || !String(env[line.key]).trim()) env[line.key] = line.value;
+  }
+}
+function savePublicConfigKey(key, value) {
+  mkdirSync10(publicConfigDir(), { recursive: true });
+  const path = publicConfigEnvPath();
+  const existing = existsSync11(path) ? readFileSync10(path, "utf8") : "";
+  const lines = existing.split(/\r?\n/).filter((l) => l.trim() !== "");
+  const kept = lines.filter((l) => {
+    const eq = l.indexOf("=");
+    return eq < 0 || l.slice(0, eq).trim() !== key;
+  });
+  kept.push(`${key}=${value}`);
+  writeFileSync9(path, kept.join("\n") + "\n", { mode: 384 });
+  return path;
+}
+
+export {
+  requireFfmpeg,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_DOWNLOAD_TIMEOUT_MS,
+  resolveApiBase,
+  resolveApiKey,
+  resolveVideoId,
+  stripTrailingSlash,
+  resolveConfig,
+  rendersUrl,
+  renderUrl,
+  reviewUrl,
+  assetsUrl,
+  meUrl,
+  projectsUrl,
+  projectVideosUrl,
+  runUrl,
+  filesUrl,
+  transcribeUrl,
+  compileUrl,
+  resolveUrl,
+  verifyUrl,
+  composeUrl,
+  parseRenderCreate,
+  parseRenderState,
+  isTerminalStatus,
+  parseFileList,
+  parseFileContent,
+  parseFilePresign,
+  parseRunState,
+  isTerminalRunStatus,
+  CloudHttpError,
+  CloudClient,
+  downloadTo,
+  MAX_POLL_MS,
+  defaultRenderOut,
+  pollRender,
+  bundledSkillDir,
+  defaultSkillTarget,
+  installSkill,
+  jobJsonPath,
+  writeJobFile,
+  readJobFile,
+  videoIdFromJob,
+  initCloudJob,
+  INLINE_MAX_BYTES,
+  sha256Hex,
+  sameSha,
+  vfsLocalPath,
+  toVfsPath,
+  vfsContentType,
+  pullFiles,
+  pushFiles,
+  uploadVfsBytes,
+  MAX_RUN_POLL_MS,
+  formatRunEvent,
+  pollRun,
+  assertRunCompleted,
+  transcribeArtifactSet,
+  extractGuardedWav,
+  transcribeCloud,
+  DEFAULT_DESILENCE,
+  silenceDetectArgs,
+  parseSilenceDetect,
+  detectSilences,
+  CAPTION_STYLE_DEFAULTS,
+  timelineV2Schema,
+  emptyDiagnostics,
+  parseTimeline,
+  validateTimeline,
+  CAPABILITIES,
+  usesFromDoc,
+  checkCapabilities,
+  timelineJsonPath2,
+  planPath2,
+  diagnosticsPath2,
+  loadTimeline2,
+  validateLocal,
+  detectSilencesForDoc,
+  statAssetsForDoc,
+  compileRemote,
+  verifyCloud,
+  buildMediaEntry,
+  composeCloud,
+  qaFramesArgs,
+  qaWaveformArgs,
+  qaWordsForWindow,
+  findLocalTranscript,
+  qaFramesLocal,
+  qaWaveformLocal,
+  reviewDir2,
+  roundJsonPath2,
+  instructionPath2,
+  pullReview2,
+  resolveRunId2,
+  REVIEW_STAGES2,
+  pushStage2,
+  assetContentType2,
+  collectPlanAssetRefs2,
+  syncAssets2,
+  pushTimeline2,
+  readOutcomesFile2,
+  pushComplete2,
+  publicConfigDir,
+  publicConfigEnvPath,
+  loadPublicConfigEnv,
+  savePublicConfigKey
+};