video-editing 1.3.1 → 3.0.0

package/dist/chunk-W4IIL2T2.js

@@ -0,0 +1,2488 @@
+#!/usr/bin/env node
+
+// src/cloud/client.ts
+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;
+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;
+}
+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) ?? DEFAULT_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 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}`;
+}
+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 ingestUrl(base, videoId) {
+  return videoUrl(base, videoId, "ingest");
+}
+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 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;
+  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;
+}
+function backoffDelayMs(attempt) {
+  return 500 * 2 ** (attempt - 1);
+}
+var CloudClient = class _CloudClient {
+  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;
+  }
+  /** 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);
+    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);
+  }
+  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()));
+    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.
+   *  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);
+      }
+      await new Promise((r) => setTimeout(r, backoffDelayMs(attempt)));
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+  }
+  // ---- 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}/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 === "") {
+      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}`);
+    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), createWriteStream(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 dirname2, join as join2, relative, resolve } from "path";
+import { fileURLToPath } from "url";
+function bundledSkillDir() {
+  const here = dirname2(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 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) {
+  mkdirSync2(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,
+      ...typeof raw.source_path === "string" && raw.source_path !== "" ? { source_path: raw.source_path } : {}
+    };
+  } 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/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();
+    }
+  });
+  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 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)}`);
+  }
+  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")
+  };
+}
+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);
+  }
+}
+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;
+}
+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 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
+  };
+  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 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");
+}
+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 join4(jobDir, ...parts);
+}
+function toVfsPath(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("/");
+}
+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 (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);
+    mkdirSync3(dirname3(dest), { recursive: true });
+    let bytes;
+    if (got.content !== void 0) {
+      const buf = Buffer.from(got.content, "utf8");
+      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`);
+      }
+    } else {
+      const dl = await client.download(got.downloadUrl, dest);
+      bytes = dl.bytes;
+      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`);
+      }
+    }
+    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 (!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)) {
+      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 {
+      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);
+    }
+  }
+  return out;
+}
+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 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 : "";
+  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 ?? sleep3;
+  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/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;
+}
+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 {
+    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;
+}
+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 (opts.verbose !== false) process.stderr.write(line + "\n");
+  };
+  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, "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/cloud/transcribe2.ts
+function transcribeArtifactSet(stem) {
+  return [`transcripts/${stem}.json`, "takes_packed.md", "flags.txt", "word_dump.txt", "coverage.json", "probe.json"];
+}
+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");
+  }
+  const pulled = await pullFiles(client, jobDir, { only: transcribeArtifactSet(opts.stem), prefixes: ["prompts/"] });
+  return { runId, pulled };
+}
+
+// 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 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 join6(jobDir, "timeline.json");
+}
+function planPath2(jobDir) {
+  return join6(jobDir, "resolved", "plan.json");
+}
+function diagnosticsPath2(jobDir) {
+  return join6(jobDir, "resolved", "diagnostics.json");
+}
+function loadTimeline2(jobDir) {
+  const path = timelineJsonPath2(jobDir);
+  if (!existsSync5(path)) {
+    return {
+      doc: null,
+      raw: null,
+      errors: [{ path: "(file)", code: "missing-file", message: `timeline not found: ${path}` }]
+    };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync4(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 };
+}
+function statAssetsForDoc(jobDir, doc) {
+  const out = {};
+  const statRef = (ref) => {
+    if (ref !== void 0 && !(ref in out)) {
+      out[ref] = existsSync5(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 assets = statAssetsForDoc(jobDir, loaded.doc);
+  const res = await client.compileRemote({
+    timeline: loaded.raw,
+    ...Object.keys(assets).length > 0 ? { assets_present: assets } : {}
+  });
+  const dir = join6(jobDir, "resolved");
+  mkdirSync5(dir, { recursive: true });
+  const out = { ok: res.ok === true, diagnosticsPath: diagnosticsPath2(jobDir), response: res };
+  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);
+    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 = 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 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 { runId } = await client.verifyStart({
+    ...opts.full ? { mode: "full" } : {},
+    ...opts.windowS !== void 0 ? { window_s: opts.windowS } : {}
+  });
+  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 = join7(jobDir, "verify.json");
+  let verdict = null;
+  let findings = null;
+  if (existsSync6(verifyPath)) {
+    try {
+      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 {
+    }
+  }
+  return { runId, verifyPath, verdict, findings };
+}
+
+// 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)}`);
+    }
+    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 (!(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))`
+    );
+  }
+  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 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) });
+  }
+  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 suffixed(windows);
+}
+
+// src/cloud/review2.ts
+import { createHash as createHash2 } from "crypto";
+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 join9(jobDir, "review");
+}
+function roundJsonPath2(jobDir) {
+  return join9(reviewDir2(jobDir), "round.json");
+}
+function instructionPath2(jobDir) {
+  return join9(reviewDir2(jobDir), "instruction.md");
+}
+function assetsCachePath2(jobDir) {
+  return join9(reviewDir2(jobDir), "assets.json");
+}
+async function pullReview2(client, jobDir, opts = {}) {
+  const session = await client.getReview();
+  mkdirSync6(reviewDir2(jobDir), { recursive: true });
+  const round = session.activeRound;
+  if (round) {
+    writeFileSync5(
+      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"
+    );
+    writeFileSync5(instructionPath2(jobDir), round.instruction + "\n", "utf8");
+  } else {
+    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 && !existsSync8(tlPath)) {
+    writeFileSync5(tlPath, JSON.stringify(session.timeline, null, 2) + "\n", "utf8");
+    wroteTimeline = true;
+  }
+  let downloadedSource = null;
+  if (opts.withSource && session.sourceUrl) {
+    const dest = join9(jobDir, "source.mp4");
+    if (!existsSync8(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 (existsSync8(path)) {
+    try {
+      const runId = JSON.parse(readFileSync7(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 : 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`
+      );
+    }
+    paths.set(ref, abs);
+  }
+  let cache = {};
+  if (existsSync8(assetsCachePath2(jobDir))) {
+    try {
+      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") {
+          cache[ref] = { sha256: e.sha256, asset_id: e.asset_id };
+        }
+      }
+    } catch {
+      cache = {};
+    }
+  }
+  const manifest = {};
+  let dirty = false;
+  for (const ref of refs) {
+    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) {
+      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) {
+    mkdirSync6(reviewDir2(jobDir), { recursive: true });
+    writeFileSync5(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 (!existsSync8(path)) throw new Error(`outcomes file not found: ${path}`);
+  let raw;
+  try {
+    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)}`);
+  }
+  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 existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join10 } from "path";
+function publicConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && xdg.trim() ? xdg : join10(homedir2(), ".config");
+  return join10(base, "video-editing");
+}
+function publicConfigEnvPath() {
+  return join10(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 (!existsSync9(path)) return;
+  let text;
+  try {
+    text = readFileSync8(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 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) {
+  mkdirSync7(publicConfigDir(), { recursive: true });
+  const path = publicConfigEnvPath();
+  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}`);
+  writeFileSync6(path, kept.join("\n") + "\n", { mode: 384 });
+  return path;
+}
+
+export {
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_DOWNLOAD_TIMEOUT_MS,
+  resolveApiBase,
+  resolveApiKey,
+  resolveVideoId,
+  stripTrailingSlash,
+  resolveConfig,
+  rendersUrl,
+  renderUrl,
+  reviewUrl,
+  assetsUrl,
+  meUrl,
+  projectsUrl,
+  projectVideosUrl,
+  webVideoUrl,
+  runUrl,
+  multipartUrl,
+  multipartRelayUrl,
+  filesUrl,
+  transcribeUrl,
+  ingestUrl,
+  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,
+  MULTIPART_THRESHOLD_BYTES,
+  RELAY_DIRECT_ATTEMPTS,
+  RELAY_SUBCHUNK_BYTES,
+  shouldMultipart,
+  bytesSource,
+  openFileSource,
+  uploadMultipart,
+  INLINE_MAX_BYTES,
+  sha256Hex,
+  sameSha,
+  vfsLocalPath,
+  toVfsPath,
+  vfsContentType,
+  pullFiles,
+  pushFiles,
+  uploadVfsPayload,
+  uploadVfsBytes,
+  MAX_RUN_POLL_MS,
+  formatRunEvent,
+  pollRun,
+  assertRunCompleted,
+  sanitizeStem,
+  ingestArtifactSet,
+  readProbeDuration,
+  initCloudJob,
+  transcribeArtifactSet,
+  transcribeCloud,
+  CAPTION_STYLE_DEFAULTS,
+  timelineV2Schema,
+  emptyDiagnostics,
+  parseTimeline,
+  validateTimeline,
+  CAPABILITIES,
+  usesFromDoc,
+  checkCapabilities,
+  timelineJsonPath2,
+  planPath2,
+  diagnosticsPath2,
+  loadTimeline2,
+  validateLocal,
+  statAssetsForDoc,
+  compileRemote,
+  verifyCloud,
+  qaDir,
+  framesPngPath,
+  waveformPngPath,
+  inspectPngPath,
+  waveformWordsPath,
+  readPlanSegments,
+  joinSourceWindows,
+  joinSpanWindow,
+  outWindowToSourceWindows,
+  reviewDir2,
+  roundJsonPath2,
+  instructionPath2,
+  pullReview2,
+  resolveRunId2,
+  REVIEW_STAGES2,
+  pushStage2,
+  assetContentType2,
+  collectPlanAssetRefs2,
+  syncAssets2,
+  pushTimeline2,
+  readOutcomesFile2,
+  pushComplete2,
+  publicConfigDir,
+  publicConfigEnvPath,
+  loadPublicConfigEnv,
+  removePublicConfigKey,
+  savePublicConfigKey
+};