video-editing 2.0.0 → 3.1.0

package/dist/{chunk-SSXAUKGV.js → chunk-2OM7WV4W.js}

@@ -1,126 +1,8 @@
 #!/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 { createWriteStream, mkdirSync, statSync, writeFileSync } from "fs";
+import { dirname, join as pathJoin } from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -131,8 +13,9 @@ function firstNonEmpty(...vals) {
   }
   return void 0;
 }
+var DEFAULT_API_BASE = "https://clipready-usewhip.vercel.app";
 function resolveApiBase(flag, env = process.env) {
-  return firstNonEmpty(flag, env.CLIPREADY_API_BASE, env.API_BASE);
+  return firstNonEmpty(flag, env.CLIPREADY_API_BASE, env.API_BASE) ?? DEFAULT_API_BASE;
 }
 function resolveApiKey(flag, env = process.env) {
   return firstNonEmpty(flag, env.CLIPREADY_API_KEY, env.RUN_TOKEN);
@@ -186,9 +69,19 @@ function projectsUrl(base) {
 function projectVideosUrl(base, projectId) {
   return `${stripTrailingSlash(base)}/api/v1/projects/${encodeURIComponent(projectId)}/videos`;
 }
+function webVideoUrl(base, projectId, videoId) {
+  return `${stripTrailingSlash(base)}/projects/${encodeURIComponent(projectId)}/videos/${encodeURIComponent(videoId)}`;
+}
 function runUrl(base, runId) {
   return `${stripTrailingSlash(base)}/api/v1/runs/${encodeURIComponent(runId)}`;
 }
+function multipartUrl(base, tail) {
+  const root = `${stripTrailingSlash(base)}/api/v1/uploads/multipart`;
+  return tail ? `${root}/${tail}` : root;
+}
+function multipartRelayUrl(base, uploadId, n, i, of) {
+  return `${multipartUrl(base, "relay")}?upload_id=${encodeURIComponent(uploadId)}&n=${n}&i=${i}&of=${of}`;
+}
 function videoUrl(base, videoId, tail) {
   return `${stripTrailingSlash(base)}/api/v1/videos/${encodeURIComponent(videoId)}/${tail}`;
 }
@@ -199,6 +92,9 @@ function filesUrl(base, videoId, path) {
 function transcribeUrl(base, videoId) {
   return videoUrl(base, videoId, "transcribe");
 }
+function ingestUrl(base, videoId) {
+  return videoUrl(base, videoId, "ingest");
+}
 function compileUrl(base, videoId) {
   return videoUrl(base, videoId, "compile");
 }
@@ -208,6 +104,9 @@ function resolveUrl(base, videoId) {
 function verifyUrl(base, videoId) {
   return videoUrl(base, videoId, "verify");
 }
+function smoothJoinsUrl(base, videoId) {
+  return videoUrl(base, videoId, "smooth-joins");
+}
 function composeUrl(base, videoId) {
   return videoUrl(base, videoId, "compose");
 }
@@ -279,6 +178,18 @@ function parseQaWaveform(data) {
   }) : [];
   return { url: o.url, words };
 }
+function parseQaInspect(data) {
+  const o = asRecord(data, "qa-inspect");
+  if (typeof o.url !== "string") throw new Error(`qa inspect response missing url: ${JSON.stringify(data)}`);
+  const cuts = Array.isArray(o.cuts) ? o.cuts.filter((c) => c !== null && typeof c === "object").map((c) => ({ start: Number(c.start ?? 0), end: Number(c.end ?? 0) })) : [];
+  return {
+    url: o.url,
+    tStart: Number(o.tStart ?? 0),
+    tEnd: Number(o.tEnd ?? 0),
+    cuts,
+    cached: o.cached === true
+  };
+}
 function parseFileList(data) {
   const o = asRecord(data, "file-list");
   const arr = o.files;
@@ -411,7 +322,10 @@ function extractErrorMessage(data) {
   }
   return void 0;
 }
-var CloudClient = class {
+function backoffDelayMs(attempt) {
+  return 500 * 2 ** (attempt - 1);
+}
+var CloudClient = class _CloudClient {
   constructor(cfg, opts = {}) {
     this.cfg = cfg;
     this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
@@ -425,6 +339,61 @@ var CloudClient = class {
     if (!this.cfg.videoId) throw new Error("missing video id \u2014 pass --video-id or set VIDEO_ID");
     return this.cfg.videoId;
   }
+  /** Same client (same fetch/timeout) bound to a video id — for flows that
+   *  create the video mid-run (init). */
+  withVideoId(videoId) {
+    return new _CloudClient({ ...this.cfg, videoId }, { fetchImpl: this.fetchImpl, timeoutMs: this.timeoutMs });
+  }
+  /** The injected fetch — for helpers outside the class (multipart part PUTs)
+   *  that need raw Response access (e.g. the ETag header). */
+  get fetch() {
+    return this.fetchImpl;
+  }
+  /** POST a JSON body to an absolute API URL with auth — public wrapper over
+   *  the private transport for helpers living outside the class (multipart). */
+  async postJson(url, body) {
+    return this.request("POST", url, body);
+  }
+  /** POST raw binary bytes to an authenticated API URL (multipart relay
+   *  sub-chunks). Content-Type application/octet-stream; JSON response. */
+  async postBinary(url, bytes, timeoutMs = DEFAULT_DOWNLOAD_TIMEOUT_MS) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+      const res = await this.fetchImpl(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.cfg.credential}`,
+          Accept: "application/json",
+          "Content-Type": "application/octet-stream"
+        },
+        body: bytes,
+        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, `POST ${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 ${timeoutMs}ms: POST ${url}`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   async request(method, url, body) {
     const ac = new AbortController();
     const timer = setTimeout(() => ac.abort(), this.timeoutMs);
@@ -491,6 +460,12 @@ var CloudClient = class {
     });
     return parseQaWaveform(data);
   }
+  async qaInspect(args) {
+    const body = { kind: "inspect", start: args.start, end: args.end };
+    if (args.nFrames !== void 0) body.n_frames = args.nFrames;
+    const data = await this.request("POST", qaUrl(this.cfg.base, this.requireVideoId()), body);
+    return parseQaInspect(data);
+  }
   // ---- artifacts ----------------------------------------------------------
   async listArtifacts() {
     const data = await this.request("GET", artifactsUrl(this.cfg.base, this.requireVideoId()));
@@ -512,28 +487,45 @@ var CloudClient = class {
     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}`);
+   *  signed URL carries its own credentials and may be a different host.
+   *  Mid-stream network failures (connection resets, TLS record errors) and
+   *  5xx responses are retried with exponential backoff — the whole body is
+   *  an in-memory buffer, so every attempt is a clean full replay. */
+  async upload(url, bytes, contentType, timeoutMs = DEFAULT_DOWNLOAD_TIMEOUT_MS, maxAttempts = 5) {
+    let lastErr;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      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) return;
+        const failure = new Error(`asset upload failed: HTTP ${res.status} ${res.statusText} for ${url}`);
+        if (res.status < 500 || attempt === maxAttempts) throw failure;
+        lastErr = failure;
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          throw new Error(`asset upload timed out after ${timeoutMs}ms: ${url}`);
+        }
+        const cause = err.cause;
+        const detail = cause?.code ?? cause?.message;
+        const network = err instanceof TypeError;
+        if (!network || attempt === maxAttempts) {
+          throw err instanceof TypeError ? new Error(
+            `upload network failure after ${attempt} attempt${attempt === 1 ? "" : "s"}${detail ? ` (${detail})` : ""} PUTting ${bytes.length} bytes to ${new URL(url).host}`
+          ) : err;
+        }
+        lastErr = err;
+      } finally {
+        clearTimeout(timer);
       }
-      throw err;
-    } finally {
-      clearTimeout(timer);
+      await new Promise((r) => setTimeout(r, backoffDelayMs(attempt)));
     }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
   }
   // ---- review session -----------------------------------------------------
   async getReview() {
@@ -641,8 +633,22 @@ var CloudClient = class {
     }
     return { runId: o.run_id };
   }
-  /** POST /videos/{id}/verify → 202 {run_id}. */
-  async verifyStart(body) {
+  /** POST /videos/{id}/ingest {stem?} → 202 {run_id}. Server-side probe + audio
+   *  extraction + transcription + screening over the uploaded source. The stem
+   *  names every derived artifact (transcripts/<stem>.json, audio/<stem>.wav) —
+   *  omit it and the server defaults to "source". */
+  async ingestStart(stem) {
+    const body = stem !== void 0 && stem !== "" ? { stem } : {};
+    const data = await this.request("POST", ingestUrl(this.cfg.base, this.requireVideoId()), body);
+    const o = asRecord(data, "ingest");
+    if (typeof o.run_id !== "string" || o.run_id === "") {
+      throw new Error(`ingest response missing run_id: ${JSON.stringify(data)}`);
+    }
+    return { runId: o.run_id };
+  }
+  /** POST /videos/{id}/verify {mode?, window_s?} → 202 {run_id}. The server
+   *  sources the preview audio itself — nothing is uploaded. */
+  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 === "") {
@@ -650,6 +656,18 @@ var CloudClient = class {
     }
     return { runId: o.run_id };
   }
+  async smoothJoinsStart(body = {}) {
+    const data = await this.request(
+      "POST",
+      smoothJoinsUrl(this.cfg.base, this.requireVideoId()),
+      body
+    );
+    const o = asRecord(data, "smooth-joins");
+    if (typeof o.run_id !== "string" || o.run_id === "") {
+      throw new Error(`smooth-joins 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));
@@ -686,14 +704,14 @@ async function downloadTo(url, dest, opts = {}) {
   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 });
+    mkdirSync(dirname(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));
+    await pipeline(Readable.fromWeb(body), createWriteStream(dest));
     return { path: dest, bytes: statSync(dest).size };
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
@@ -733,10 +751,10 @@ async function pollRender(client, renderId, opts = {}) {
 // 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 { dirname as dirname2, join as join2, relative, resolve } from "path";
 import { fileURLToPath } from "url";
 function bundledSkillDir() {
-  const here = dirname3(fileURLToPath(import.meta.url));
+  const here = dirname2(fileURLToPath(import.meta.url));
   const candidates = [
     join2(here, "skills", "video-editing"),
     join2(here, "..", "skills", "video-editing"),
@@ -770,13 +788,13 @@ function installSkill(opts = {}) {
 }
 
 // src/cloud/jobfile.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, 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 });
+  mkdirSync2(jobDir, { recursive: true });
   const path = jobJsonPath(jobDir);
   writeFileSync2(path, JSON.stringify(job, null, 2) + "\n", "utf8");
   return path;
@@ -792,7 +810,8 @@ function readJobFile(jobDir) {
       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
+      duration_s: typeof raw.duration_s === "number" ? raw.duration_s : 0,
+      ...typeof raw.source_path === "string" && raw.source_path !== "" ? { source_path: raw.source_path } : {}
     };
   } catch {
     return null;
@@ -805,184 +824,276 @@ function videoIdFromJob(jobDir, resolved) {
   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;
+// src/cloud/multipart.ts
+import { open } from "fs/promises";
+async function runPool(tasks, concurrency) {
+  let next = 0;
+  const workers = Array.from({ length: Math.min(concurrency, tasks.length) }, async () => {
+    while (next < tasks.length) {
+      const task = tasks[next++];
+      if (task) await task();
     }
-  }
-  const tags = stream.tags ?? {};
-  if ("rotate" in tags) {
-    const v = Number(tags.rotate);
-    return Number.isFinite(v) ? Math.trunc(v) : 0;
-  }
-  return 0;
+  });
+  await Promise.all(workers);
+}
+var MULTIPART_THRESHOLD_BYTES = 8 * 1024 * 1024;
+var PART_CONCURRENCY = 3;
+var PART_MAX_ATTEMPTS = 8;
+var RELAY_DIRECT_ATTEMPTS = 3;
+var RELAY_SUBCHUNK_BYTES = 3670016;
+function jitteredBackoffMs(attempt) {
+  const base = Math.min(500 * 2 ** (attempt - 1), 8e3);
+  return Math.round(base / 2 + Math.random() * (base / 2));
+}
+function shouldMultipart(sizeOrBytes) {
+  const size = typeof sizeOrBytes === "number" ? sizeOrBytes : sizeOrBytes.length;
+  return size > MULTIPART_THRESHOLD_BYTES;
+}
+function bytesSource(bytes) {
+  return {
+    size: bytes.length,
+    readSlice: async (offset, len) => Buffer.from(bytes.subarray(offset, Math.min(offset + len, bytes.length)))
+  };
+}
+async function openFileSource(path) {
+  const fh = await open(path, "r");
+  const size = (await fh.stat()).size;
+  return {
+    size,
+    async readSlice(offset, len) {
+      const want = Math.min(len, Math.max(0, size - offset));
+      const buf = Buffer.allocUnsafe(want);
+      let done = 0;
+      while (done < want) {
+        const { bytesRead } = await fh.read(buf, done, want - done, offset + done);
+        if (bytesRead <= 0) throw new Error(`short read at byte ${offset + done} of ${path}`);
+        done += bytesRead;
+      }
+      return buf;
+    },
+    close: () => fh.close()
+  };
 }
-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];
+function asRecord2(data, ctx) {
+  if (data === null || typeof data !== "object") throw new Error(`unexpected ${ctx} response: ${JSON.stringify(data)}`);
+  return data;
+}
+function parsePartUrls(data, ctx) {
+  const o = asRecord2(data, ctx);
+  if (!Array.isArray(o.parts)) throw new Error(`${ctx} response missing parts[]: ${JSON.stringify(data)}`);
+  return o.parts.filter((p) => p !== null && typeof p === "object").map((p) => ({ n: Number(p.n ?? 0), url: String(p.url ?? "") })).filter((p) => Number.isInteger(p.n) && p.n >= 1 && p.url !== "");
+}
+function parseMultipartCreate(data) {
+  const o = asRecord2(data, "multipart-create");
+  const uploadId = o.upload_id;
+  if (typeof uploadId !== "string" || uploadId === "") {
+    throw new Error(`multipart create response missing upload_id: ${JSON.stringify(data)}`);
   }
-  return [width, height, rotation];
+  const partSize = Number(o.part_size ?? 0);
+  if (!(partSize > 0)) throw new Error(`multipart create response missing part_size: ${JSON.stringify(data)}`);
+  return {
+    uploadId,
+    assetId: typeof o.asset_id === "string" && o.asset_id !== "" ? o.asset_id : void 0,
+    partSize,
+    parts: parsePartUrls(data, "multipart-create")
+  };
 }
-
-// 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);
+function isMultipartUnavailable(err) {
+  if (!(err instanceof CloudHttpError)) return false;
+  if (err.status === 404 || err.status === 405) return true;
+  if (err.status !== 503) return false;
+  const body = err.body;
+  return typeof body === "object" && body !== null && typeof body.error === "object" && body.error !== null ? body.error.code === "multipart_unavailable" : false;
+}
+function stripEtagQuotes(etag) {
+  return etag.trim().replace(/^"+|"+$/g, "");
+}
+function fmtMb(n) {
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function putPart(client, url, chunk, timeoutMs) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    return await client.fetch(url, { method: "PUT", body: chunk, signal: ac.signal });
+  } finally {
+    clearTimeout(timer);
   }
-  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;
+async function refreshPartUrl(client, uploadId, n) {
+  const data = await client.postJson(multipartUrl(client.cfg.base, "parts"), { upload_id: uploadId, ns: [n] });
+  const url = parsePartUrls(data, "multipart-parts").find((p) => p.n === n)?.url;
+  if (!url) throw new Error(`multipart parts refresh did not return a URL for part ${n}: ${JSON.stringify(data)}`);
+  return url;
 }
-
-// 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 relayOnePart(client, uploadId, n, chunk) {
+  const of = Math.max(1, Math.ceil(chunk.length / RELAY_SUBCHUNK_BYTES));
+  for (let i = 1; i <= of; i++) {
+    const sub = chunk.subarray((i - 1) * RELAY_SUBCHUNK_BYTES, Math.min(i * RELAY_SUBCHUNK_BYTES, chunk.length));
+    const data = await client.postBinary(multipartRelayUrl(client.cfg.base, uploadId, n, i, of), sub);
+    const o = data;
+    if (!o || o.ok !== true) {
+      throw new Error(`relay sub-chunk ${i}/${of} of part ${n} did not return {ok:true}: ${JSON.stringify(data)}`);
+    }
+  }
+  const done = asRecord2(
+    await client.postJson(multipartUrl(client.cfg.base, "relay-complete"), { upload_id: uploadId, n }),
+    "relay-complete"
+  );
+  if (typeof done.etag !== "string" || done.etag === "") {
+    throw new Error(`relay-complete for part ${n} returned no etag: ${JSON.stringify(done)}`);
+  }
+  return stripEtagQuotes(done.etag);
+}
+function isRelayUnavailable(err) {
+  return err instanceof CloudHttpError && (err.status === 404 || err.status === 405);
+}
+function transportDetail(err) {
+  const cause = err.cause;
+  return cause?.code ?? cause?.message;
+}
+async function uploadOnePart(client, uploadId, n, chunk, initialUrl, timeoutMs, backoffMs, diag) {
+  let url = initialUrl;
+  let lastErr;
+  let transportFailures = 0;
+  let relayUnavailable = false;
+  for (let attempt = 1; attempt <= PART_MAX_ATTEMPTS; attempt++) {
+    const useRelay = !relayUnavailable && transportFailures >= RELAY_DIRECT_ATTEMPTS;
+    const mode = useRelay ? "relay" : "direct";
+    const t0 = Date.now();
+    const report = (error) => {
+      if (!error && mode === "direct") return;
+      diag?.(
+        `part ${n} attempt ${attempt} mode ${mode} bytes ${chunk.length} elapsed ${Date.now() - t0}ms` + (error ? ` error ${error}` : " ok")
+      );
+    };
+    if (useRelay) {
+      try {
+        const etag = await relayOnePart(client, uploadId, n, chunk);
+        report();
+        return etag;
+      } catch (err) {
+        if (isRelayUnavailable(err)) {
+          relayUnavailable = true;
+          report("relay_unavailable");
+        } else {
+          lastErr = err instanceof Error ? err : new Error(String(err));
+          report(err instanceof CloudHttpError ? `http_${err.status}` : lastErr.message.slice(0, 80));
+        }
+      }
+    } else {
+      try {
+        if (!url) url = await refreshPartUrl(client, uploadId, n);
+        const res = await putPart(client, url, chunk, timeoutMs);
+        if (res.ok) {
+          const etag = res.headers.get("etag");
+          if (!etag) throw new Error(`part ${n} uploaded but the response had no ETag header \u2014 cannot complete the multipart upload`);
+          report();
+          return stripEtagQuotes(etag);
+        }
+        lastErr = new Error(`part ${n}: HTTP ${res.status} ${res.statusText}`);
+        report(`http_${res.status}`);
+        if (res.status >= 400 && res.status < 500) url = void 0;
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          lastErr = new Error(`part ${n}: timed out after ${timeoutMs}ms`);
+          transportFailures += 1;
+          report("timeout");
+        } else if (err instanceof TypeError) {
+          const detail = transportDetail(err);
+          lastErr = new Error(`part ${n}: network failure${detail ? ` (${detail})` : ""}`);
+          transportFailures += 1;
+          report(detail ?? "fetch_failed");
+        } else {
+          throw err;
+        }
+      }
+    }
+    if (attempt < PART_MAX_ATTEMPTS) await sleep2(backoffMs(attempt));
+  }
+  throw new Error(
+    `multipart upload failed at part ${n} (${chunk.length} bytes) after ${PART_MAX_ATTEMPTS} attempts: ${lastErr?.message ?? "unknown error"}`
+  );
 }
-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");
+async function uploadMultipart(client, opts, timeoutMs = DEFAULT_DOWNLOAD_TIMEOUT_MS) {
+  const source = opts.source ?? (opts.bytes !== void 0 ? bytesSource(opts.bytes) : void 0);
+  if (!source) throw new Error("uploadMultipart: pass exactly one of bytes or source");
+  const createBody = {
+    kind: opts.kind,
+    size: source.size,
+    content_type: opts.contentType
   };
-  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
+  if (opts.filename !== void 0) createBody.filename = opts.filename;
+  if (opts.videoId !== void 0) createBody.video_id = opts.videoId;
+  if (opts.path !== void 0) createBody.path = opts.path;
+  let session;
+  try {
+    session = parseMultipartCreate(await client.postJson(multipartUrl(client.cfg.base), createBody));
+  } catch (err) {
+    if (isMultipartUnavailable(err)) return "unavailable";
+    throw err;
+  }
+  const abort = async () => {
+    try {
+      await client.postJson(multipartUrl(client.cfg.base, "abort"), { upload_id: session.uploadId });
+    } catch {
+    }
   };
+  if (opts.kind === "asset" && !session.assetId) {
+    await abort();
+    throw new Error("multipart create (kind asset) returned no asset_id \u2014 cannot create the video afterwards");
+  }
+  const total = Math.max(1, Math.ceil(source.size / session.partSize));
+  const urls = new Map(session.parts.map((p) => [p.n, p.url]));
+  const marks = new Set([1, 2, 3, 4].map((k) => Math.ceil(total * k / 4)));
+  const etags = new Array(total);
+  let doneParts = 0;
+  let doneBytes = 0;
+  try {
+    await runPool(
+      Array.from({ length: total }, (_, i) => async () => {
+        const n = i + 1;
+        const offset = i * session.partSize;
+        const chunk = await source.readSlice(offset, session.partSize);
+        etags[i] = await uploadOnePart(
+          client,
+          session.uploadId,
+          n,
+          chunk,
+          urls.get(n),
+          timeoutMs,
+          opts.backoffMs ?? jitteredBackoffMs,
+          opts.log
+        );
+        doneParts += 1;
+        doneBytes += chunk.length;
+        if (opts.log && marks.has(doneParts)) {
+          opts.log(`upload: ${doneParts}/${total} parts (${fmtMb(doneBytes)} / ${fmtMb(source.size)})`);
+        }
+      }),
+      PART_CONCURRENCY
+    );
+    const completeBody = {
+      upload_id: session.uploadId,
+      parts: etags.map((etag, i) => ({ n: i + 1, etag }))
+    };
+    if (opts.kind === "jobfile") {
+      if (opts.sha256 !== void 0) completeBody.sha256 = opts.sha256;
+      completeBody.bytes = source.size;
+    }
+    await client.postJson(multipartUrl(client.cfg.base, "complete"), completeBody);
+  } catch (err) {
+    await abort();
+    throw err;
+  }
+  return opts.kind === "asset" ? { assetId: session.assetId } : {};
 }
 
 // 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";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join4, sep } from "path";
 var INLINE_MAX_BYTES = 5 * 1024 * 1024;
 function sha256Hex(bytes) {
   return createHash("sha256").update(bytes).digest("hex");
@@ -995,10 +1106,10 @@ function sameSha(a, 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);
+  return join4(jobDir, ...parts);
 }
 function toVfsPath(jobDir, localPath) {
-  const abs = localPath.startsWith(sep) ? localPath : join6(jobDir, localPath);
+  const abs = localPath.startsWith(sep) ? localPath : join4(jobDir, localPath);
   const rel = abs.startsWith(jobDir + sep) ? abs.slice(jobDir.length + 1) : localPath;
   return rel.split(sep).join("/");
 }
@@ -1036,18 +1147,18 @@ async function pullFiles(client, jobDir, opts = {}) {
     const entry = byPath.get(path);
     if (!entry) continue;
     const dest = vfsLocalPath(jobDir, path);
-    if (existsSync5(dest) && sameSha(sha256Hex(readFileSync3(dest)), entry.sha256)) {
+    if (existsSync3(dest) && sameSha(sha256Hex(readFileSync2(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 });
+    mkdirSync3(dirname3(dest), { recursive: true });
     let bytes;
     if (got.content !== void 0) {
       const buf = Buffer.from(got.content, "utf8");
-      writeFileSync4(dest, buf);
+      writeFileSync3(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`);
@@ -1055,7 +1166,7 @@ async function pullFiles(client, jobDir, opts = {}) {
     } else {
       const dl = await client.download(got.downloadUrl, dest);
       bytes = dl.bytes;
-      if (got.sha256 && !sameSha(sha256Hex(readFileSync3(dest)), got.sha256)) {
+      if (got.sha256 && !sameSha(sha256Hex(readFileSync2(dest)), got.sha256)) {
         throw new Error(`pulled ${path} but sha256 mismatch vs server (${got.sha256}) \u2014 refusing to trust the copy`);
       }
     }
@@ -1073,8 +1184,8 @@ async function pushFiles(client, jobDir, paths, opts = {}) {
   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);
+    if (!existsSync3(local)) throw new Error(`files push: local file not found: ${local}`);
+    const bytes = readFileSync2(local);
     const sha = sha256Hex(bytes);
     const existing = byPath.get(vfsPath);
     if (existing && sameSha(sha, existing.sha256)) {
@@ -1094,9 +1205,7 @@ async function pushFiles(client, jobDir, paths, opts = {}) {
       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);
+      await uploadVfsPayload(client, vfsPath, bytes, contentType, { sha256: sha, log: opts.log });
       const f = { path: vfsPath, bytes: bytes.length, skipped: false, mode: "presign" };
       out.push(f);
       opts.onFile?.(f);
@@ -1104,20 +1213,32 @@ async function pushFiles(client, jobDir, paths, opts = {}) {
   }
   return out;
 }
-async function uploadVfsBytes(client, vfsPath, bytes, contentType) {
-  const presign = await client.filesPresign({
-    path: vfsPath,
-    contentType,
-    bytes: bytes.length,
-    sha256: sha256Hex(bytes)
-  });
+async function uploadVfsPayload(client, vfsPath, bytes, contentType, opts = {}) {
+  const sha = opts.sha256 ?? sha256Hex(bytes);
+  if (shouldMultipart(bytes)) {
+    const res = await uploadMultipart(client, {
+      kind: "jobfile",
+      bytes,
+      contentType,
+      videoId: client.cfg.videoId,
+      path: vfsPath,
+      sha256: sha,
+      log: opts.log
+    });
+    if (res !== "unavailable") return;
+    opts.log?.("  chunked upload unavailable on this server; using single-request upload");
+  }
+  const presign = await client.filesPresign({ path: vfsPath, contentType, bytes: bytes.length, sha256: sha });
   await client.upload(presign.uploadUrl, bytes, contentType);
   await client.filesCommit(vfsPath);
 }
+async function uploadVfsBytes(client, vfsPath, bytes, contentType, log) {
+  await uploadVfsPayload(client, vfsPath, bytes, contentType, { log });
+}
 
 // src/cloud/runs.ts
 var MAX_RUN_POLL_MS = 30 * 60 * 1e3;
-var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep3 = (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 : "";
@@ -1126,7 +1247,7 @@ function formatRunEvent(ev) {
 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 nap = opts.sleepImpl ?? sleep3;
   const now = opts.now ?? Date.now;
   const start = now();
   let seen = 0;
@@ -1147,115 +1268,136 @@ function assertRunCompleted(state, what) {
   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"];
+// src/cloud/init.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join5, parse as parsePath, resolve as resolvePath } from "path";
+function sanitizeStem(name) {
+  const safe = name.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return safe === "" ? "source" : safe;
 }
-async function extractGuardedWav(media) {
-  const tmp = mkdtempSync(join7(tmpdir(), "ve-cloud-wav-"));
+function ingestArtifactSet(stem) {
+  return [`transcripts/${stem}.json`, "takes_packed.md", "flags.txt", "word_dump.txt", "coverage.json", "probe.json"];
+}
+function readProbeDuration(jobDir) {
+  const path = join5(jobDir, "probe.json");
+  if (!existsSync4(path)) throw new Error(`ingest completed but probe.json was not pulled: ${path}`);
+  let raw;
   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 });
+    raw = JSON.parse(readFileSync3(path, "utf8"));
+  } catch (err) {
+    throw new Error(`probe.json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
+  const durationS = Number(raw?.duration_s ?? NaN);
+  if (!(durationS > 0)) throw new Error(`probe.json has no usable duration_s: ${JSON.stringify(raw)}`);
+  return durationS;
 }
-async function transcribeCloud(client, jobDir, opts) {
-  const verbose = opts.verbose !== false;
+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 rawName = parsePath(source).name;
+  const stem = sanitizeStem(rawName);
+  const jobDir = resolvePath(opts.jobDir ?? join5(process.cwd(), `job_${stem}`));
+  mkdirSync4(jobDir, { recursive: true });
   const log = (line) => {
-    if (verbose) process.stderr.write(line + "\n");
+    if (opts.verbose !== false) 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, {
+  await client.me();
+  const title = opts.title ?? rawName;
+  const { projectId } = await client.createProject(title);
+  log(`  project: ${projectId}`);
+  const contentType = contentTypeFor(source);
+  const filename = parsePath(source).base;
+  let assetId;
+  let uploadedBytes = 0;
+  const fileSrc = await openFileSource(source);
+  try {
+    uploadedBytes = fileSrc.size;
+    log(`  uploading ${filename} (${(fileSrc.size / (1024 * 1024)).toFixed(1)} MB)`);
+    if (shouldMultipart(fileSrc.size)) {
+      const mp = await uploadMultipart(client, { kind: "asset", source: fileSrc, contentType, filename, log });
+      if (mp === "unavailable") {
+        log("  chunked upload unavailable on this server; using single-request upload");
+      } else {
+        assetId = mp.assetId;
+      }
+    }
+    if (!assetId) {
+      const bytes = await fileSrc.readSlice(0, fileSrc.size);
+      const asset = await client.createSourceAsset({ contentType, filename });
+      await client.upload(asset.uploadUrl, bytes, contentType);
+      assetId = asset.assetId;
+    }
+  } finally {
+    await fileSrc.close();
+  }
+  const video = await client.createVideo(projectId, { assetId, title });
+  log(`  video: ${video.videoId}`);
+  const videoClient = client.cfg.videoId ? client : client.withVideoId(video.videoId);
+  const { runId } = await videoClient.ingestStart(stem);
+  log(`  ingest run: ${runId}`);
+  const state = await pollRun(videoClient, 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 };
+  assertRunCompleted(state, "ingest");
+  const pulled = await pullFiles(videoClient, jobDir, { only: ingestArtifactSet(stem), prefixes: ["prompts/"] });
+  const durationS = readProbeDuration(jobDir);
+  const job = {
+    video_id: video.videoId,
+    project_id: video.projectId,
+    api_base: client.cfg.base,
+    stem,
+    duration_s: durationS,
+    source_path: source
+  };
+  const jobJson = writeJobFile(jobDir, job);
+  return {
+    jobDir,
+    jobJson,
+    videoId: video.videoId,
+    projectId: video.projectId,
+    stem,
+    durationS,
+    uploaded: source,
+    uploadedBytes,
+    runId,
+    pulled,
+    webUrl: webVideoUrl(client.cfg.base, video.projectId, video.videoId)
+  };
 }
 
-// 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",
-    "-"
-  ];
+// src/cloud/transcribe2.ts
+function transcribeArtifactSet(stem) {
+  return [`transcripts/${stem}.json`, "takes_packed.md", "flags.txt", "word_dump.txt", "coverage.json", "probe.json"];
 }
-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 });
+async function transcribeCloud(client, jobDir, opts) {
+  const verbose = opts.verbose !== false;
+  const log = (line) => {
+    if (verbose) process.stderr.write(line + "\n");
+  };
+  const transcriptPath = `transcripts/${opts.stem}.json`;
+  const listing = await client.filesList();
+  const haveTranscript = listing.some((f) => f.path === transcriptPath);
+  let runId = null;
+  if (haveTranscript) {
+    log(`  ${transcriptPath} already exists server-side \u2014 pulling artifacts`);
+  } else {
+    const started = await client.ingestStart(opts.stem);
+    runId = started.runId;
+    log(`  ingest run: ${runId}`);
+    const state = await pollRun(client, runId, {
+      intervalMs: opts.pollIntervalMs,
+      onEvent: (ev) => log(`  ${formatRunEvent(ev)}`)
+    });
+    assertRunCompleted(state, "ingest");
   }
-  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);
+  const pulled = await pullFiles(client, jobDir, { only: transcribeArtifactSet(opts.stem), prefixes: ["prompts/"] });
+  return { runId, pulled };
 }
 
 // src/timeline-v2/schema.ts
@@ -1728,20 +1870,20 @@ function checkCapabilities(uses, registry = CAPABILITIES) {
 }
 
 // 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";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { isAbsolute, join as join6, resolve as resolve2 } from "path";
 function timelineJsonPath2(jobDir) {
-  return join8(jobDir, "timeline.json");
+  return join6(jobDir, "timeline.json");
 }
 function planPath2(jobDir) {
-  return join8(jobDir, "resolved", "plan.json");
+  return join6(jobDir, "resolved", "plan.json");
 }
 function diagnosticsPath2(jobDir) {
-  return join8(jobDir, "resolved", "diagnostics.json");
+  return join6(jobDir, "resolved", "diagnostics.json");
 }
 function loadTimeline2(jobDir) {
   const path = timelineJsonPath2(jobDir);
-  if (!existsSync6(path)) {
+  if (!existsSync5(path)) {
     return {
       doc: null,
       raw: null,
@@ -1750,7 +1892,7 @@ function loadTimeline2(jobDir) {
   }
   let raw;
   try {
-    raw = JSON.parse(readFileSync5(path, "utf8"));
+    raw = JSON.parse(readFileSync4(path, "utf8"));
   } catch (err) {
     return {
       doc: null,
@@ -1775,22 +1917,11 @@ function validateLocal(doc) {
   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));
+      out[ref] = existsSync5(isAbsolute(ref) ? ref : resolve2(jobDir, ref));
     }
   };
   for (const ov of doc.overlays) statRef(ov.asset?.ref);
@@ -1799,60 +1930,37 @@ function statAssetsForDoc(jobDir, doc) {
 }
 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 dir = join6(jobDir, "resolved");
+  mkdirSync5(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");
+  writeFileSync4(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");
+    writeFileSync4(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");
+    out.edlPath = join6(jobDir, "edl.json");
+    writeFileSync4(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";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } 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 } : {}
+    ...opts.windowS !== void 0 ? { window_s: opts.windowS } : {}
   });
   log(`  verify run: ${runId}`);
   const state = await pollRun(client, runId, {
@@ -1861,12 +1969,12 @@ async function verifyCloud(client, jobDir, opts = {}) {
   });
   assertRunCompleted(state, "verify");
   await pullFiles(client, jobDir, { only: ["verify.json"] });
-  const verifyPath = join9(jobDir, "verify.json");
+  const verifyPath = join7(jobDir, "verify.json");
   let verdict = null;
   let findings = null;
-  if (existsSync7(verifyPath)) {
+  if (existsSync6(verifyPath)) {
     try {
-      const v = JSON.parse(readFileSync6(verifyPath, "utf8"));
+      const v = JSON.parse(readFileSync5(verifyPath, "utf8"));
       verdict = typeof v.verdict === "string" ? v.verdict : null;
       findings = Array.isArray(v.joins) ? v.joins.length : null;
     } catch {
@@ -1875,302 +1983,128 @@ async function verifyCloud(client, jobDir, opts = {}) {
   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)`
-      );
+// src/cloud/qa.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
+function qaDir(jobDir) {
+  return jobDir ? join8(jobDir, "qa") : join8(process.cwd(), "qa");
+}
+function tag(start, end) {
+  return `${start}_${end}`;
+}
+function framesPngPath(dir, start, end, suffix = "") {
+  return join8(dir, `frames_${tag(start, end)}${suffix}.png`);
+}
+function waveformPngPath(dir, start, end) {
+  return join8(dir, `waveform_${tag(start, end)}.png`);
+}
+function inspectPngPath(dir, start, end, suffix = "") {
+  return join8(dir, `inspect_${tag(start, end)}${suffix}.png`);
+}
+function waveformWordsPath(dir, start, end) {
+  return join8(dir, `waveform_${tag(start, end)}.words.json`);
+}
+function readPlanSegments(jobDir) {
+  const path = join8(jobDir, "resolved", "plan.json");
+  if (!existsSync7(path)) {
+    throw new Error(`no compiled plan at ${path} \u2014 run \`video-editing timeline compile\` first`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync6(path, "utf8"));
+  } catch (err) {
+    throw new Error(`resolved/plan.json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const segments = raw?.segments;
+  if (!Array.isArray(segments) || segments.length === 0) {
+    throw new Error(`resolved/plan.json has no segments[]: ${path}`);
+  }
+  return segments.map((s, i) => {
+    const r = s;
+    const seg = {
+      srcStart: Number(r.srcStart ?? NaN),
+      srcEnd: Number(r.srcEnd ?? NaN),
+      outStart: Number(r.outStart ?? NaN),
+      outEnd: Number(r.outEnd ?? NaN)
+    };
+    if (![seg.srcStart, seg.srcEnd, seg.outStart, seg.outEnd].every(Number.isFinite)) {
+      throw new Error(`plan segment ${i} is missing src/out times: ${JSON.stringify(s)}`);
     }
-    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
+    return seg;
+  });
+}
+var round3 = (n) => Math.round(n * 1e3) / 1e3;
+var SUFFIXES = "abcdefghijklmnopqrstuvwxyz";
+function suffixed(windows) {
+  return windows.map((w, i) => ({
+    start: round3(w.start),
+    end: round3(w.end),
+    suffix: windows.length > 1 ? `-${SUFFIXES[i] ?? String(i)}` : ""
+  }));
+}
+function joinSourceWindows(segments, joinIndex, spanS) {
+  if (!Number.isInteger(joinIndex) || joinIndex < 1 || joinIndex > segments.length - 1) {
+    throw new Error(
+      `--join must be a 1-based join index between 1 and ${segments.length - 1} (the plan has ${segments.length} segment(s))`
     );
-    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`");
+  if (!(spanS > 0)) throw new Error("--span must be > 0 seconds");
+  const a = segments[joinIndex - 1];
+  const b = segments[joinIndex];
+  return suffixed([
+    { start: Math.max(a.srcStart, a.srcEnd - spanS), end: a.srcEnd },
+    { start: b.srcStart, end: Math.min(b.srcEnd, b.srcStart + spanS) }
+  ]);
+}
+function joinSpanWindow(segments, joinIndex, spanS) {
+  if (!Number.isInteger(joinIndex) || joinIndex < 1 || joinIndex > segments.length - 1) {
+    throw new Error(
+      `--join must be a 1-based join index between 1 and ${segments.length - 1} (the plan has ${segments.length} segment(s))`
+    );
   }
-  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
-  ];
+  if (!(spanS > 0)) throw new Error("--span must be > 0 seconds");
+  const a = segments[joinIndex - 1];
+  const b = segments[joinIndex];
+  return { start: round3(Math.max(0, a.srcEnd - spanS)), end: round3(b.srcStart + spanS), suffix: "" };
 }
-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 });
+function outWindowToSourceWindows(segments, outStart, outEnd) {
+  if (!(outEnd > outStart)) throw new Error("--out-end must be greater than --out-start");
+  const windows = [];
+  for (const seg of segments) {
+    const s = Math.max(outStart, seg.outStart);
+    const e = Math.min(outEnd, seg.outEnd);
+    if (e - s <= 5e-4) continue;
+    windows.push({ start: seg.srcStart + (s - seg.outStart), end: seg.srcStart + (e - seg.outStart) });
   }
-  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;
+  if (windows.length === 0) {
+    const total = segments.length ? Math.max(...segments.map((s) => s.outEnd)) : 0;
+    throw new Error(`output window ${outStart}s\u2013${outEnd}s does not overlap the plan (output duration ${total}s)`);
   }
-  return result;
+  return suffixed(windows);
 }
 
 // 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";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { basename, isAbsolute as isAbsolute2, join as join9 } from "path";
 function reviewDir2(jobDir) {
-  return join12(jobDir, "review");
+  return join9(jobDir, "review");
 }
 function roundJsonPath2(jobDir) {
-  return join12(reviewDir2(jobDir), "round.json");
+  return join9(reviewDir2(jobDir), "round.json");
 }
 function instructionPath2(jobDir) {
-  return join12(reviewDir2(jobDir), "instruction.md");
+  return join9(reviewDir2(jobDir), "instruction.md");
 }
 function assetsCachePath2(jobDir) {
-  return join12(reviewDir2(jobDir), "assets.json");
+  return join9(reviewDir2(jobDir), "assets.json");
 }
 async function pullReview2(client, jobDir, opts = {}) {
   const session = await client.getReview();
-  mkdirSync9(reviewDir2(jobDir), { recursive: true });
+  mkdirSync6(reviewDir2(jobDir), { recursive: true });
   const round = session.activeRound;
   if (round) {
-    writeFileSync8(
+    writeFileSync5(
       roundJsonPath2(jobDir),
       JSON.stringify(
         {
@@ -2188,20 +2122,20 @@ async function pullReview2(client, jobDir, opts = {}) {
       ) + "\n",
       "utf8"
     );
-    writeFileSync8(instructionPath2(jobDir), round.instruction + "\n", "utf8");
+    writeFileSync5(instructionPath2(jobDir), round.instruction + "\n", "utf8");
   } else {
-    writeFileSync8(instructionPath2(jobDir), "No active review round for this video.\n", "utf8");
+    writeFileSync5(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");
+  if (session.timeline !== null && session.timeline !== void 0 && !existsSync8(tlPath)) {
+    writeFileSync5(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 dest = join9(jobDir, "source.mp4");
+    if (!existsSync8(dest)) {
       const dl = await client.download(session.sourceUrl, dest);
       downloadedSource = dl.path;
     }
@@ -2211,9 +2145,9 @@ async function pullReview2(client, jobDir, opts = {}) {
 function resolveRunId2(jobDir, flagOverride) {
   if (typeof flagOverride === "string" && flagOverride.trim() !== "") return flagOverride.trim();
   const path = roundJsonPath2(jobDir);
-  if (existsSync10(path)) {
+  if (existsSync8(path)) {
     try {
-      const runId = JSON.parse(readFileSync9(path, "utf8")).run_id;
+      const runId = JSON.parse(readFileSync7(path, "utf8")).run_id;
       if (typeof runId === "string" && runId !== "") return runId;
     } catch {
     }
@@ -2273,8 +2207,8 @@ async function syncAssets2(client, jobDir, 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)) {
+    const abs = isAbsolute2(ref) ? ref : join9(jobDir, ref);
+    if (!existsSync8(abs)) {
       throw new Error(
         `asset not found: ${ref} (expected at ${abs}) \u2014 asset refs are job-dir-relative paths; place the file before pushing`
       );
@@ -2282,9 +2216,9 @@ async function syncAssets2(client, jobDir, plan) {
     paths.set(ref, abs);
   }
   let cache = {};
-  if (existsSync10(assetsCachePath2(jobDir))) {
+  if (existsSync8(assetsCachePath2(jobDir))) {
     try {
-      const raw = JSON.parse(readFileSync9(assetsCachePath2(jobDir), "utf8"));
+      const raw = JSON.parse(readFileSync7(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") {
@@ -2298,7 +2232,7 @@ async function syncAssets2(client, jobDir, plan) {
   const manifest = {};
   let dirty = false;
   for (const ref of refs) {
-    const bytes = readFileSync9(paths.get(ref));
+    const bytes = readFileSync7(paths.get(ref));
     const sha256 = "sha256:" + createHash2("sha256").update(bytes).digest("hex");
     const hit = cache[ref];
     if (hit !== void 0 && hit.sha256 === sha256) {
@@ -2313,8 +2247,8 @@ async function syncAssets2(client, jobDir, plan) {
     dirty = true;
   }
   if (dirty) {
-    mkdirSync9(reviewDir2(jobDir), { recursive: true });
-    writeFileSync8(assetsCachePath2(jobDir), JSON.stringify(cache, null, 2) + "\n", "utf8");
+    mkdirSync6(reviewDir2(jobDir), { recursive: true });
+    writeFileSync5(assetsCachePath2(jobDir), JSON.stringify(cache, null, 2) + "\n", "utf8");
   }
   return manifest;
 }
@@ -2347,10 +2281,10 @@ async function pushTimeline2(client, jobDir, runId) {
   return { ok: true, plan: compiled.plan, timelineHash: compiled.timelineHash, assets };
 }
 function readOutcomesFile2(path) {
-  if (!existsSync10(path)) throw new Error(`outcomes file not found: ${path}`);
+  if (!existsSync8(path)) throw new Error(`outcomes file not found: ${path}`);
   let raw;
   try {
-    raw = JSON.parse(readFileSync9(path, "utf8"));
+    raw = JSON.parse(readFileSync7(path, "utf8"));
   } catch (err) {
     throw new Error(`outcomes file is not valid JSON: ${path}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -2387,16 +2321,16 @@ async function pushComplete2(client, jobDir, runId, opts) {
 }
 
 // src/public/config.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join13 } from "path";
+import { join as join10 } 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");
+  const base = xdg && xdg.trim() ? xdg : join10(homedir2(), ".config");
+  return join10(base, "video-editing");
 }
 function publicConfigEnvPath() {
-  return join13(publicConfigDir(), ".env");
+  return join10(publicConfigDir(), ".env");
 }
 function parseEnvLines(text) {
   return text.split(/\r?\n/).map((raw) => {
@@ -2412,10 +2346,10 @@ function parseEnvLines(text) {
 var MANAGED_KEYS = ["CLIPREADY_API_KEY", "CLIPREADY_API_BASE"];
 function loadPublicConfigEnv(env = process.env) {
   const path = publicConfigEnvPath();
-  if (!existsSync11(path)) return;
+  if (!existsSync9(path)) return;
   let text;
   try {
-    text = readFileSync10(path, "utf8");
+    text = readFileSync8(path, "utf8");
   } catch {
     return;
   }
@@ -2425,22 +2359,31 @@ function loadPublicConfigEnv(env = process.env) {
     if (!env[line.key] || !String(env[line.key]).trim()) env[line.key] = line.value;
   }
 }
+function removePublicConfigKey(key) {
+  const path = publicConfigEnvPath();
+  if (!existsSync9(path)) return path;
+  const lines = readFileSync8(path, "utf8").split(/\r?\n/).filter((l) => l.trim() !== "").filter((l) => {
+    const eq = l.indexOf("=");
+    return eq < 0 || l.slice(0, eq).trim() !== key;
+  });
+  writeFileSync6(path, lines.length ? lines.join("\n") + "\n" : "", { mode: 384 });
+  return path;
+}
 function savePublicConfigKey(key, value) {
-  mkdirSync10(publicConfigDir(), { recursive: true });
+  mkdirSync7(publicConfigDir(), { recursive: true });
   const path = publicConfigEnvPath();
-  const existing = existsSync11(path) ? readFileSync10(path, "utf8") : "";
+  const existing = existsSync9(path) ? readFileSync8(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 });
+  writeFileSync6(path, kept.join("\n") + "\n", { mode: 384 });
   return path;
 }
 
 export {
-  requireFfmpeg,
   DEFAULT_TIMEOUT_MS,
   DEFAULT_DOWNLOAD_TIMEOUT_MS,
   resolveApiBase,
@@ -2455,9 +2398,13 @@ export {
   meUrl,
   projectsUrl,
   projectVideosUrl,
+  webVideoUrl,
   runUrl,
+  multipartUrl,
+  multipartRelayUrl,
   filesUrl,
   transcribeUrl,
+  ingestUrl,
   compileUrl,
   resolveUrl,
   verifyUrl,
@@ -2483,7 +2430,13 @@ export {
   writeJobFile,
   readJobFile,
   videoIdFromJob,
-  initCloudJob,
+  MULTIPART_THRESHOLD_BYTES,
+  RELAY_DIRECT_ATTEMPTS,
+  RELAY_SUBCHUNK_BYTES,
+  shouldMultipart,
+  bytesSource,
+  openFileSource,
+  uploadMultipart,
   INLINE_MAX_BYTES,
   sha256Hex,
   sameSha,
@@ -2492,18 +2445,18 @@ export {
   vfsContentType,
   pullFiles,
   pushFiles,
+  uploadVfsPayload,
   uploadVfsBytes,
   MAX_RUN_POLL_MS,
   formatRunEvent,
   pollRun,
   assertRunCompleted,
+  sanitizeStem,
+  ingestArtifactSet,
+  readProbeDuration,
+  initCloudJob,
   transcribeArtifactSet,
-  extractGuardedWav,
   transcribeCloud,
-  DEFAULT_DESILENCE,
-  silenceDetectArgs,
-  parseSilenceDetect,
-  detectSilences,
   CAPTION_STYLE_DEFAULTS,
   timelineV2Schema,
   emptyDiagnostics,
@@ -2517,18 +2470,18 @@ export {
   diagnosticsPath2,
   loadTimeline2,
   validateLocal,
-  detectSilencesForDoc,
   statAssetsForDoc,
   compileRemote,
   verifyCloud,
-  buildMediaEntry,
-  composeCloud,
-  qaFramesArgs,
-  qaWaveformArgs,
-  qaWordsForWindow,
-  findLocalTranscript,
-  qaFramesLocal,
-  qaWaveformLocal,
+  qaDir,
+  framesPngPath,
+  waveformPngPath,
+  inspectPngPath,
+  waveformWordsPath,
+  readPlanSegments,
+  joinSourceWindows,
+  joinSpanWindow,
+  outWindowToSourceWindows,
   reviewDir2,
   roundJsonPath2,
   instructionPath2,
@@ -2545,5 +2498,6 @@ export {
   publicConfigDir,
   publicConfigEnvPath,
   loadPublicConfigEnv,
+  removePublicConfigKey,
   savePublicConfigKey
 };