@osmo.inc/cli 0.1.24 → 0.1.25

package/dist/osmo.js

@@ -1,10 +1,3 @@
-// src/commands.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { createRequire } from "node:module";
-import path8 from "node:path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
-import { parseArgs } from "node:util";
-
 // src/auth.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import {
@@ -3052,8 +3045,8 @@ async function withCredentials(origin, action) {
   }
   try {
     try {
-      const stat5 = await lstat(file);
-      if (!stat5.isFile()) throw new Error("Not a regular file");
+      const stat9 = await lstat(file);
+      if (!stat9.isFile()) throw new Error("Not a regular file");
       await chmod(file, 384);
       state = JSON.parse(await readFile2(file, "utf8"));
       if (state.version !== 1 || state.origin !== origin || state.credentials && !validCredentials(state.credentials) || state.pending && (!validClient(state.pending.client) || typeof state.pending.sessionId !== "string" || typeof state.pending.deviceCode !== "string" || typeof state.pending.code !== "string" || !Number.isFinite(state.pending.expiresAt) || !Number.isFinite(state.pending.nextPollAt) || !Number.isFinite(state.pending.interval) || state.pending.interval < 5 || !validApprovalUrl(state.pending.url, origin)))
@@ -3493,6 +3486,71 @@ Next: ${result.next}`;
 Next: ${result.next}`;
 }
 
+// src/cloud-request.ts
+var PERMISSION_DOES = {
+  "projects:write": "change projects",
+  "energy:spend": "run models on your plan"
+};
+function scopeRequired(origin, scope) {
+  const login = origin === authOrigin() ? "osmo login" : `OSMO_BASE_URL=${origin} osmo login`;
+  return new OsmoError(
+    "scope_required",
+    `This login can't ${PERMISSION_DOES[scope ?? ""] ?? "do that"}. Sign in again to allow it: ${login}`,
+    login
+  );
+}
+async function call(origin, route, { method = "GET", body: body2, timeoutMs = 6e4, allow = [] } = {}) {
+  const response = await authenticatedFetch(
+    route,
+    { method, body: body2, timeoutMs },
+    origin
+  );
+  const data = await response.json().catch(() => ({}));
+  if (response.status === 403 && data.error === "scope_required" && !allow.includes(403))
+    throw scopeRequired(origin, data.scope);
+  if (!response.ok && !allow.includes(response.status))
+    throw new Error(
+      `Cloud ${response.status}: ${typeof data.error === "string" ? data.error : response.status === 400 ? "the request was invalid" : "request failed"}`
+    );
+  return { status: response.status, ...data };
+}
+
+// src/cloud-render.ts
+var isCloudRenderJob = (job) => /^render_[a-z0-9]{20,32}$/.test(job);
+async function cloudRenderJob(job, origin = authOrigin(), cancel = false) {
+  if (!isCloudRenderJob(job))
+    throw new OsmoError(
+      "invalid_job",
+      "Use the render job ID returned by cloud deploy."
+    );
+  return call(
+    origin,
+    `/api/cloud-renders/${job}${cancel ? "/cancel" : ""}`,
+    cancel ? { method: "POST" } : {}
+  );
+}
+function formatCloudRender(job) {
+  return `Cloud render ${job.job}: ${job.cancelRequested ? "cancellation requested" : job.status}${job.progress ? ` (${job.progress}%)` : ""}.
+Review: ${job.link}
+Payer: ${job.payer}${job.error ? `
+${job.error.message}` : ""}${job.next ? `
+Next: ${job.next}` : ""}`;
+}
+async function listCloudRenderJobs() {
+  const result = await call(
+    authOrigin(),
+    "/api/cloud-renders"
+  );
+  return { status: "ok", jobs: result.jobs };
+}
+
+// src/commands.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import path13 from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+
 // src/help.ts
 function cliHelp(version2, commands) {
   const groups = /* @__PURE__ */ new Map();
@@ -3546,140 +3604,2731 @@ Node 22 or later. Cloud commands need osmo login; OSMO_BASE_URL picks the cloud
 `;
 }
 
-// src/resources.ts
-import { createHash as createHash3 } from "node:crypto";
-import { constants } from "node:fs";
+// src/media-command.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createReadStream as createReadStream3, createWriteStream as createWriteStream2, existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir6, readFile as readFile5, rename as rename6, rm as rm6, stat as stat5, writeFile as writeFile5 } from "node:fs/promises";
+import path9 from "node:path";
+import { Readable as Readable2 } from "node:stream";
+import { pipeline as pipeline2 } from "node:stream/promises";
+
+// src/cloud-pointer.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+
+// src/git.ts
+import { execFileSync, spawnSync } from "node:child_process";
 import {
-  copyFile,
-  lstat as lstat2,
-  mkdir as mkdir3,
-  mkdtemp,
-  readdir,
-  readFile as readFile3,
-  realpath,
-  rename as rename3,
-  rm as rm3,
-  writeFile as writeFile3
-} from "node:fs/promises";
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
 import path4 from "node:path";
-import { unzipSync } from "fflate";
-var CATALOG_OWNER = "osmo";
-var COST = {
-  second: "grows with seconds of output",
-  image: "is the same for each image",
-  character: "grows with characters of text"
-};
-var packageFiles = (primitive) => primitive === "Model" ? ["model.glb", "resource.json"] : ["resource.json", "shader.d.ts", "shader.wgsl"];
-var LOCK = ".osmo-get.lock";
-var maxFile = 1024 * 1024;
-var maxResponse = 4 * maxFile;
-var maxModel = 64 * maxFile;
-var fileLimit = (name) => name.endsWith(".glb") ? maxModel : maxFile;
-var DOWNLOAD_MS = 30 * 6e4;
-var ownerPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var namePattern = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
-var versionPattern = /^\d+\.\d+\.\d+$/;
-var digest2 = (bytes2) => createHash3("sha256").update(bytes2).digest("hex");
-var fail = (code, message, next) => {
-  throw new AuthError(code, message, next);
+var git = (root, ...args) => execFileSync("git", ["-C", root, ...args], {
+  encoding: "utf8",
+  maxBuffer: 1 << 28
+}).replace(/\n$/, "");
+var hasRepo = (root) => existsSync(path4.join(root, ".git"));
+
+// src/cloud-pointer.ts
+var PROJECT_ID = /^[a-z0-9]{10,40}$/;
+function pointerFromGit(root) {
+  const read = (key) => {
+    const r = spawnSync2("git", ["-C", root, "config", "--get", key], {
+      encoding: "utf8"
+    });
+    return r.status === 0 ? r.stdout.trim() : "";
+  };
+  const origin = read("osmo.cloud.origin"), id = read("osmo.cloud.id");
+  return origin && id ? { origin, id } : null;
+}
+var cloudPointer = (root) => hasRepo(root) ? pointerFromGit(root) : null;
+
+// src/media-api.ts
+var MediaApiError = class extends OsmoError {
+  status;
+  body;
+  constructor(status, body2) {
+    super(
+      typeof body2.error === "string" ? body2.error : `http_${status}`,
+      describe(status, body2)
+    );
+    this.status = status;
+    this.body = body2;
+  }
 };
-var invalid = () => fail(
-  "invalid_resource",
-  "Osmo returned an invalid resource package or metadata."
-);
-var text = (value) => typeof value === "string" && value.length > 0;
-var strings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
-function catalogRef(input) {
-  let value = input.trim();
-  if (/^https?:\/\//i.test(value)) {
-    let page = null;
+function describe(status, body2) {
+  switch (body2.error) {
+    case "media_upload_not_enabled":
+      return "Footage uploads aren't enabled for this account.";
+    case "quota_exceeded":
+      return `This would go over the account's footage storage (${gb(body2.usedBytes)} of ${gb(body2.capBytes)} used).`;
+    case "not_found":
+      return "Not found among your footage.";
+    case "unsupported_file_type":
+      return "That file type isn't footage this accepts.";
+    default:
+      return `The footage service answered ${status}${typeof body2.error === "string" ? ` (${body2.error})` : ""}.`;
+  }
+}
+var gb = (n) => typeof n === "number" ? `${(n / 1e9).toFixed(1)} GB` : "?";
+var RETRY_DELAYS = [1, 2, 4, 8, 15, 30, 30, 30].map((s) => s * 1e3);
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var COMPLETING_WAIT_MS = 15e3;
+async function media(route, {
+  method = "GET",
+  body: body2,
+  timeoutMs = 6e4,
+  retry = true
+} = {}, origin = authOrigin()) {
+  for (let attempt = 0; ; attempt++) {
+    let response;
     try {
-      page = /^\/resources\/([^/]+)\/?$/.exec(new URL(value).pathname);
-    } catch {
+      response = await authenticatedFetch(
+        `/api/media${route}`,
+        { method, body: body2, timeoutMs },
+        origin
+      );
+    } catch (error) {
+      if (retry && error.code === "network_error" && attempt < RETRY_DELAYS.length) {
+        await sleep2(RETRY_DELAYS[attempt]);
+        continue;
+      }
+      throw error;
     }
-    value = page ? decodeURIComponent(page[1]) : "";
+    if (response.status === 204) return void 0;
+    const data = await response.json().catch(() => ({}));
+    if (retry && (response.status >= 500 || response.status === 429 && data.error !== "too_many_open_uploads") && attempt < RETRY_DELAYS.length) {
+      await sleep2(RETRY_DELAYS[attempt]);
+      continue;
+    }
+    if (!response.ok) throw new MediaApiError(response.status, data);
+    return data;
   }
-  const at = value.indexOf("@");
-  const version2 = at === -1 ? void 0 : value.slice(at + 1);
-  const parts = (at === -1 ? value : value.slice(0, at)).split("/");
-  const [owner, name] = parts.length === 1 ? [CATALOG_OWNER, ...parts] : parts;
-  if (parts.length > 2 || !ownerPattern.test(owner) || !namePattern.test(name))
-    fail(
-      "invalid_resource_id",
-      "Use an ID from osmo resources list, such as osmo/silk or silk.",
-      "osmo resources list"
+}
+var mediaApi = {
+  /** Which account this login is: the scope its uploads are recorded in. */
+  account: async (origin = authOrigin()) => {
+    const account2 = await currentAccount(origin);
+    if (!account2.user?.id)
+      throw new OsmoError("no_account", "Couldn't tell which account this is.");
+    return { origin, userId: account2.user.id };
+  },
+  createUpload: (input) => media("/uploads", {
+    method: "POST",
+    body: input,
+    retry: false
+  }),
+  session: (id) => media(`/uploads/${encodeURIComponent(id)}`),
+  signParts: (id, parts) => media(`/uploads/${encodeURIComponent(id)}/parts`, {
+    method: "POST",
+    body: { parts }
+  }),
+  /** Complete a session. While an earlier complete of it is still at work
+   * (a retry after a timeout), the server says `completing`: wait for it. */
+  complete: async (id, crc64nvme) => {
+    for (let waited = 0; ; waited += COMPLETING_WAIT_MS) {
+      try {
+        return await media(
+          `/uploads/${encodeURIComponent(id)}/complete`,
+          { method: "POST", body: { crc64nvme }, timeoutMs: 5 * 6e4 }
+        );
+      } catch (error) {
+        if (!(error instanceof MediaApiError && error.code === "completing") || waited >= 12 * 6e4)
+          throw error;
+        await sleep2(COMPLETING_WAIT_MS);
+      }
+    }
+  },
+  abort: (id) => media(`/uploads/${encodeURIComponent(id)}`, { method: "DELETE" }),
+  file: (id) => media(`/${encodeURIComponent(id)}`),
+  /** What pointer ids play: each followed through its clip to its proxy. */
+  resolve: async (ids, origin) => (await media(
+    "/resolve",
+    { method: "POST", body: { ids } },
+    origin
+  )).files,
+  list: (opts = {}) => {
+    const q = new URLSearchParams();
+    if (opts.role) q.set("role", opts.role);
+    if (opts.cursor) q.set("cursor", opts.cursor);
+    const qs = q.toString();
+    return media(
+      qs ? `?${qs}` : ""
     );
-  if (version2 !== void 0 && !versionPattern.test(version2))
-    fail("invalid_version", "Use a version such as osmo/silk@1.0.0.");
-  return { id: `${owner}/${name}`, owner, name, version: version2 };
+  }
+};
+
+// src/media-crc.ts
+var POLY = 0x9a6c9329ac4bc9b5n;
+var MASK = 0xffffffffffffffffn;
+var TLO = new Uint32Array(8 * 256);
+var THI = new Uint32Array(8 * 256);
+{
+  const t0 = [];
+  for (let b = 0; b < 256; b++) {
+    let c = BigInt(b);
+    for (let k = 0; k < 8; k++) c = c & 1n ? c >> 1n ^ POLY : c >> 1n;
+    t0[b] = c;
+  }
+  let prev = t0;
+  for (let k = 0; k < 8; k++) {
+    const cur = k === 0 ? t0 : prev.map((v) => v >> 8n ^ t0[Number(v & 0xffn)]);
+    for (let b = 0; b < 256; b++) {
+      TLO[k * 256 + b] = Number(cur[b] & 0xffffffffn);
+      THI[k * 256 + b] = Number(cur[b] >> 32n);
+    }
+    prev = cur;
+  }
 }
-async function bytes(response, limit = maxResponse) {
-  if (Number(response.headers.get("content-length")) > limit) {
-    await response.body?.cancel();
-    invalid();
+var Crc64Nvme = class {
+  lo = 4294967295;
+  hi = 4294967295;
+  update(u8) {
+    let lo = this.lo;
+    let hi = this.hi;
+    let i = 0;
+    const n = u8.length;
+    while (i < n && (u8.byteOffset + i) % 4 !== 0) {
+      const idx = (lo ^ u8[i++]) & 255;
+      const nlo = TLO[idx] ^ (lo >>> 8 | hi << 24);
+      hi = THI[idx] ^ hi >>> 8;
+      lo = nlo;
+    }
+    const words2 = n - i >>> 3;
+    if (words2 > 0) {
+      const w = new Uint32Array(u8.buffer, u8.byteOffset + i, words2 * 2);
+      for (let j = 0; j < w.length; j += 2) {
+        const a = lo ^ w[j];
+        const b = hi ^ w[j + 1];
+        lo = TLO[1792 + (a & 255)] ^ TLO[1536 + (a >>> 8 & 255)] ^ TLO[1280 + (a >>> 16 & 255)] ^ TLO[1024 + (a >>> 24)] ^ TLO[768 + (b & 255)] ^ TLO[512 + (b >>> 8 & 255)] ^ TLO[256 + (b >>> 16 & 255)] ^ TLO[b >>> 24];
+        hi = THI[1792 + (a & 255)] ^ THI[1536 + (a >>> 8 & 255)] ^ THI[1280 + (a >>> 16 & 255)] ^ THI[1024 + (a >>> 24)] ^ THI[768 + (b & 255)] ^ THI[512 + (b >>> 8 & 255)] ^ THI[256 + (b >>> 16 & 255)] ^ THI[b >>> 24];
+      }
+      i += words2 * 8;
+    }
+    while (i < n) {
+      const idx = (lo ^ u8[i++]) & 255;
+      const nlo = TLO[idx] ^ (lo >>> 8 | hi << 24);
+      hi = THI[idx] ^ hi >>> 8;
+      lo = nlo;
+    }
+    this.lo = lo >>> 0;
+    this.hi = hi >>> 0;
+    return this;
   }
-  const chunks = [];
-  let size = 0;
-  try {
-    for await (const chunk of response.body ?? []) {
-      size += chunk.length;
-      if (size > limit) invalid();
-      chunks.push(chunk);
+  digest() {
+    return (BigInt(this.hi ^ 4294967295) << 32n | BigInt((this.lo ^ 4294967295) >>> 0)) & MASK;
+  }
+};
+var crc64 = (u8) => new Crc64Nvme().update(u8).digest();
+function multmodp(a, b) {
+  let m = 1n << 63n;
+  let p = 0n;
+  for (; ; ) {
+    if (a & m) {
+      p ^= b;
+      if ((a & m - 1n) === 0n) break;
     }
-  } catch (error) {
-    if (error instanceof OsmoError) throw error;
-    fail(
-      "network_error",
-      "Lost the connection to Osmo partway through. Check your connection and retry."
-    );
+    m >>= 1n;
+    b = b & 1n ? b >> 1n ^ POLY : b >> 1n;
   }
-  return Buffer.concat(chunks);
+  return p;
 }
-async function responseBody(response, json = true, limit) {
-  if (!response.ok) {
-    const body3 = await response.json().catch(() => ({}));
-    if (response.status === 401) throw loginRequired(authOrigin());
-    if (response.status === 404)
-      fail(
-        "resource_not_found",
-        "No such resource or version. Run osmo resources list.",
-        "osmo resources list"
-      );
-    if (body3.error === "unknown_type" && strings(body3.types))
-      throw new UsageError(
-        `Unknown --type. Types: ${body3.types.join(", ")}.`,
-        "osmo resources list",
-        "unknown_type",
-        { types: body3.types }
-      );
-    fail(
-      "resource_request_failed",
-      `Osmo resource request failed (${response.status}). Retry later.`
-    );
+var X2N = [1n << 62n];
+for (let k = 1; k < 64; k++) X2N[k] = multmodp(X2N[k - 1], X2N[k - 1]);
+function x2nmodp(n, k) {
+  let p = 1n << 63n;
+  let nn = BigInt(n);
+  while (nn) {
+    if (nn & 1n) p = multmodp(X2N[k & 63], p);
+    nn >>= 1n;
+    k++;
   }
-  const body2 = await bytes(response, limit);
-  if (!json) return body2;
+  return p;
+}
+var opCache = /* @__PURE__ */ new Map();
+function crc64Combine(crcA, crcB, lenB) {
+  let op = opCache.get(lenB);
+  if (op === void 0) {
+    op = x2nmodp(lenB, 3);
+    if (opCache.size < 16) opCache.set(lenB, op);
+  }
+  return multmodp(op, crcA) ^ crcB;
+}
+function crcToB64(crc) {
+  const bytes2 = Buffer.alloc(8);
+  bytes2.writeBigUInt64BE(crc & MASK);
+  return bytes2.toString("base64");
+}
+function crcFromB64(b64) {
+  return Buffer.from(b64, "base64").readBigUInt64BE();
+}
+function combineParts(parts) {
+  let full = null;
+  for (const p of parts) {
+    const crc = crcFromB64(p.crc);
+    full = full === null ? crc : crc64Combine(full, crc, p.size);
+  }
+  return crcToB64(full ?? crc64(new Uint8Array()));
+}
+
+// src/media-ledger.ts
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
+import {
+  link,
+  mkdir as mkdir3,
+  open,
+  readdir,
+  readFile as readFile3,
+  rename as rename3,
+  rm as rm3,
+  writeFile as writeFile3
+} from "node:fs/promises";
+import os3 from "node:os";
+import path5 from "node:path";
+function mediaHome() {
+  return path5.join(
+    process.env.OSMO_CONFIG_DIR || path5.join(os3.homedir(), ".osmo"),
+    "media"
+  );
+}
+var filesDir = () => path5.join(mediaHome(), "files");
+function ledgerKey(file, scope) {
+  return hashKey(
+    `${scope}\0${file.name}\0${file.size}\0${Math.floor(file.mtimeMs)}`
+  );
+}
+function contentKey(file, crc, scope) {
+  return hashKey(
+    `${scope}\0${file.name}\0${file.size}\0${Math.floor(file.mtimeMs)}\0${crc}`
+  );
+}
+async function fingerprintOf(file) {
+  const span = 64 * 1024;
+  const handle = await open(file.path, "r");
   try {
-    return JSON.parse(String(body2));
-  } catch {
-    invalid();
+    const hash = new Crc64Nvme();
+    for (const at of /* @__PURE__ */ new Set([0, Math.max(0, file.size - span)])) {
+      const buffer = Buffer.alloc(Math.min(span, file.size - at));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, at);
+      hash.update(buffer.subarray(0, bytesRead));
+    }
+    return crcToB64(hash.digest());
+  } finally {
+    await handle.close();
   }
 }
-async function publicGet(route) {
-  let response;
+var hashKey = (text2) => createHash3("sha256").update(text2).digest("hex").slice(0, 32);
+async function readEntry(key) {
+  let text2;
   try {
-    response = await osmoFetch(authOrigin() + route, {
-      redirect: "error",
-      signal: AbortSignal.timeout(2e4)
-    });
+    text2 = await readFile3(path5.join(filesDir(), `${key}.json`), "utf8");
   } catch (error) {
-    if (error instanceof OsmoError) throw error;
-    fail(
-      "network_error",
-      "Cannot reach the Osmo resource catalog. Retry or continue using local capabilities."
-    );
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    const entry = JSON.parse(text2);
+    return entry.version === 1 && entry.key === key && entry.scope ? entry : null;
+  } catch {
+    return null;
   }
-  return responseBody(response);
+}
+async function writeEntry(entry) {
+  await mkdir3(filesDir(), { recursive: true, mode: 448 });
+  entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const file = path5.join(filesDir(), `${entry.key}.json`);
+  const temporary = `${file}.${randomUUID3()}.tmp`;
+  await writeFile3(temporary, `${JSON.stringify(entry, null, "	")}
+`, {
+    mode: 384,
+    flag: "wx"
+  });
+  await rename3(temporary, file);
+}
+async function allEntries() {
+  let names;
+  try {
+    names = await readdir(filesDir());
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const out2 = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const entry = await readEntry(name.slice(0, -5)).catch(() => null);
+    if (entry) out2.push(entry);
+  }
+  return out2;
+}
+function bootedAt() {
+  return Math.round((Date.now() / 1e3 - os3.uptime()) / 30);
+}
+var alive2 = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+var LedgerLockedError = class extends Error {
+  file;
+  pid;
+  constructor(file, pid) {
+    super(`Another osmo process (pid ${pid}) is uploading ${file}.`);
+    this.file = file;
+    this.pid = pid;
+  }
+};
+async function withEntryLock(key, file, action) {
+  await mkdir3(filesDir(), { recursive: true, mode: 448 });
+  const lock = path5.join(filesDir(), `${key}.lock`);
+  const nonce = randomUUID3();
+  const mine = `${lock}.${process.pid}.${nonce}`;
+  const content = JSON.stringify({ pid: process.pid, boot: bootedAt(), nonce });
+  await writeFile3(mine, content, { mode: 384 });
+  const read = (file2) => readFile3(file2, "utf8").catch(() => null);
+  try {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await link(mine, lock);
+        break;
+      } catch (error) {
+        if (error.code !== "EEXIST" || attempt > 2)
+          throw error;
+        const text2 = await read(lock);
+        const holder = (() => {
+          try {
+            return JSON.parse(text2 ?? "");
+          } catch {
+            return null;
+          }
+        })();
+        if (holder?.pid && Math.abs((holder.boot ?? 0) - bootedAt()) <= 1 && alive2(holder.pid))
+          throw new LedgerLockedError(file, holder.pid);
+        const aside = `${lock}.${nonce}.stale`;
+        try {
+          await rename3(lock, aside);
+        } catch (e) {
+          if (e.code === "ENOENT") continue;
+          throw e;
+        }
+        const moved = await read(aside);
+        if (moved !== text2) {
+          await link(aside, lock).catch(() => {
+          });
+          await rm3(aside, { force: true });
+          const taker = JSON.parse(moved ?? "{}");
+          throw new LedgerLockedError(file, taker.pid ?? 0);
+        }
+        await rm3(aside, { force: true });
+      }
+    }
+  } finally {
+    await rm3(mine, { force: true });
+  }
+  try {
+    return await action();
+  } finally {
+    if (await read(lock) === content) await rm3(lock, { force: true });
+  }
+}
+
+// src/media-project.ts
+import { createReadStream, createWriteStream, existsSync as existsSync2 } from "node:fs";
+import {
+  copyFile,
+  lstat as lstat2,
+  mkdir as mkdir4,
+  readdir as readdir2,
+  readFile as readFile4,
+  realpath,
+  rename as rename4,
+  rm as rm4,
+  stat as stat2,
+  writeFile as writeFile4
+} from "node:fs/promises";
+import path6 from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var MEDIA_DIR = "osmo-media";
+var MEDIA_ID = /^[a-z0-9]{20,40}$/;
+var POINTER_SUFFIX = ".osmo-media";
+var BLOCK_HEADER = "# Footage (osmo media): proxies stay out of git";
+var BLOCK = [
+  BLOCK_HEADER,
+  `/${MEDIA_DIR}/**`,
+  `!/${MEDIA_DIR}/**/`,
+  `!/${MEDIA_DIR}/**/*${POINTER_SUFFIX}`
+];
+var excludeFile = (root) => path6.resolve(root, git(root, "rev-parse", "--git-path", "info/exclude"));
+async function managed(root) {
+  const text2 = await readFile4(excludeFile(root), "utf8").catch(() => "");
+  return text2.split("\n").includes(BLOCK_HEADER);
+}
+async function adopt(root) {
+  if (await managed(root)) return;
+  const tracked = git(root, "ls-files", "-z", "--", MEDIA_DIR).split("\0").filter((f) => f && !f.endsWith(POINTER_SUFFIX));
+  if (tracked.length)
+    throw new Error(
+      `${MEDIA_DIR}/ already holds files in this project's history (${tracked[0]}). Move them elsewhere first; ${MEDIA_DIR}/ is where osmo media keeps footage out of git.`
+    );
+  const file = excludeFile(root);
+  const previous = await readFile4(file, "utf8").catch(() => "");
+  await mkdir4(path6.dirname(file), { recursive: true });
+  await writeFile4(
+    file,
+    `${previous}${previous && !previous.endsWith("\n") ? "\n" : ""}${BLOCK.join("\n")}
+`
+  );
+}
+async function realFolder(dir) {
+  return realpath(dir).catch(async () => {
+    const parent = path6.dirname(dir);
+    return parent === dir ? dir : path6.join(await realFolder(parent), path6.basename(dir));
+  });
+}
+async function excludeSources(root, sources) {
+  const top = await realFolder(path6.resolve(root));
+  const folders = /* @__PURE__ */ new Map();
+  const inside = [];
+  for (const source of sources) {
+    const absolute = path6.resolve(source);
+    const dir = path6.dirname(absolute);
+    let folder = folders.get(dir);
+    if (!folder) {
+      folder = realFolder(dir);
+      folders.set(dir, folder);
+    }
+    const rel = path6.relative(top, path6.join(await folder, path6.basename(absolute))).split(path6.sep).join("/");
+    if (rel && !rel.startsWith("../") && !path6.isAbsolute(rel))
+      inside.push(rel);
+  }
+  if (!inside.length) return [];
+  const file = excludeFile(root);
+  const previous = await readFile4(file, "utf8").catch(() => "");
+  const lines = previous.split("\n");
+  const escape = (s) => s.replace(/[\\!*?[\]# ]/g, "\\$&");
+  const additions = inside.map((rel) => `/${escape(rel)}`).filter((p) => !lines.includes(p));
+  if (additions.length)
+    await writeFile4(
+      file,
+      `${previous}${previous && !previous.endsWith("\n") ? "\n" : ""}# Footage sources (osmo media)
+${additions.join("\n")}
+`
+    );
+  return inside;
+}
+function placeFor(root, sourcePath) {
+  const safe = sourcePath.split(/[\\/]+/).filter((part) => part && part !== "." && part !== "..").join("/");
+  const parsed = path6.posix.parse(safe || "clip");
+  const dir = path6.posix.join(MEDIA_DIR, parsed.dir);
+  for (let n = 1; ; n++) {
+    const name = n === 1 ? `${parsed.name}.mp4` : `${parsed.name} (${n}).mp4`;
+    const rel = path6.posix.join(dir, name);
+    if (!existsSync2(path6.join(root, rel)) && !existsSync2(path6.join(root, `${rel}${POINTER_SUFFIX}`)))
+      return rel;
+  }
+}
+async function placeClip(root, rel, fileId, proxyFile) {
+  const target = path6.join(root, rel);
+  await mkdir4(path6.dirname(target), { recursive: true });
+  await writeFile4(
+    `${target}${POINTER_SUFFIX}`,
+    `${JSON.stringify({ media: fileId })}
+`
+  );
+  if (proxyFile && existsSync2(proxyFile) && !existsSync2(target))
+    await copyFile(proxyFile, target);
+  return rel;
+}
+async function pointersIn(root) {
+  const out2 = [];
+  const visit = async (dir) => {
+    let names;
+    try {
+      names = await readdir2(path6.join(root, dir));
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const rel = path6.posix.join(dir, name);
+      const info = await lstat2(path6.join(root, rel)).catch(() => null);
+      if (info?.isDirectory()) await visit(rel);
+      else if (info?.isFile() && info.size <= 1024 && name.endsWith(POINTER_SUFFIX) && !name.slice(0, -POINTER_SUFFIX.length).endsWith(POINTER_SUFFIX)) {
+        try {
+          const { media: media2 } = JSON.parse(
+            await readFile4(path6.join(root, rel), "utf8")
+          );
+          if (typeof media2 === "string" && MEDIA_ID.test(media2))
+            out2.push({ path: rel.slice(0, -POINTER_SUFFIX.length), id: media2 });
+        } catch {
+        }
+      }
+    }
+  };
+  await visit(MEDIA_DIR);
+  return out2.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function crcOfFile(file) {
+  const crc = new Crc64Nvme();
+  for await (const chunk of createReadStream(file, { highWaterMark: 8 << 20 }))
+    crc.update(chunk);
+  return crcToB64(crc.digest());
+}
+var pulledFile = () => path6.join(mediaHome(), "pulled.json");
+async function readPulled() {
+  try {
+    return JSON.parse(await readFile4(pulledFile(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function recordPulled(entries) {
+  if (!entries.length) return;
+  const all = await readPulled();
+  for (const e of entries) all[`${e.size}:${e.crc64nvme}`] = e;
+  await mkdir4(mediaHome(), { recursive: true, mode: 448 });
+  const temporary = `${pulledFile()}.${process.pid}.tmp`;
+  await writeFile4(temporary, JSON.stringify(all), { mode: 384 });
+  await rename4(temporary, pulledFile());
+}
+function pullLines(r) {
+  return [
+    `Footage: ${r.pulled.length} fetched, ${r.current.length} already here.`,
+    ...r.pending.map((p) => `  ${printable(p)}: its clip has no proxy`),
+    ...r.unavailable.map(
+      (p) => `  ${printable(p)}: its clip is missing or was deleted`
+    ),
+    ...r.failed.map(
+      (f) => `  ${printable(f.path)}: ${f.message}; run osmo media pull to retry`
+    )
+  ];
+}
+async function pull(root, project, log = () => {
+}) {
+  const pointers = await pointersIn(root);
+  const result = {
+    pulled: [],
+    current: [],
+    pending: [],
+    unavailable: [],
+    failed: []
+  };
+  if (!pointers.length) return result;
+  await adopt(root);
+  const ids = [...new Set(pointers.map((p) => p.id))];
+  const resolved = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ids.length; i += 100)
+    for (const r of await mediaApi.resolve(
+      ids.slice(i, i + 100),
+      project.origin
+    ))
+      resolved.set(r.id, r);
+  const recorded = [];
+  for (const p of pointers) {
+    const served = resolved.get(p.id);
+    if (served?.status !== "ready") {
+      (served?.status === "pending" ? result.pending : result.unavailable).push(
+        p.path
+      );
+      continue;
+    }
+    const target = path6.join(root, p.path);
+    const here2 = await stat2(target).catch(() => null);
+    if (here2 && Number(here2.size) === served.size && await knownCrc(target, here2) === served.crc64nvme) {
+      result.current.push(p.path);
+      recorded.push({
+        fileId: served.servedId,
+        size: served.size,
+        crc64nvme: served.crc64nvme,
+        path: p.path
+      });
+      continue;
+    }
+    log(`Fetching ${p.path}`);
+    await mkdir4(path6.dirname(target), { recursive: true });
+    const partial = `${target}.${process.pid}.partial`;
+    try {
+      const res = await fetch(served.url);
+      if (!res.ok || !res.body)
+        throw new Error(`download failed (${res.status})`);
+      const crc = new Crc64Nvme();
+      const body2 = Readable.fromWeb(
+        res.body
+      );
+      body2.on("data", (chunk) => crc.update(chunk));
+      await pipeline(body2, createWriteStream(partial));
+      const got = crcToB64(crc.digest());
+      if (got !== served.crc64nvme)
+        throw new Error("the download didn't match its checksum");
+      await rename4(partial, target);
+      const after = await stat2(target);
+      rememberCrc(target, after, got);
+      result.pulled.push(p.path);
+      recorded.push({
+        fileId: served.servedId,
+        size: Number(after.size),
+        crc64nvme: got,
+        path: p.path
+      });
+    } catch (error) {
+      result.failed.push({ path: p.path, message: error.message });
+    } finally {
+      await rm4(partial, { force: true });
+    }
+  }
+  await recordPulled(recorded);
+  await saveCrcCache();
+  return result;
+}
+var crcCache = null;
+var crcCacheFile = () => path6.join(mediaHome(), "local-crcs.json");
+async function knownCrc(file, info) {
+  crcCache ??= await readFile4(crcCacheFile(), "utf8").then((t) => JSON.parse(t)).catch(() => ({}));
+  const hit = crcCache[file];
+  if (hit && hit.size === Number(info.size) && hit.mtimeMs === Number(info.mtimeMs) && hit.ino === Number(info.ino))
+    return hit.crc;
+  const crc = await crcOfFile(file);
+  rememberCrc(file, info, crc);
+  return crc;
+}
+function rememberCrc(file, info, crc) {
+  crcCache ??= {};
+  crcCache[file] = {
+    size: Number(info.size),
+    mtimeMs: Number(info.mtimeMs),
+    ino: Number(info.ino),
+    crc
+  };
+}
+async function saveCrcCache() {
+  if (!crcCache) return;
+  await mkdir4(mediaHome(), { recursive: true, mode: 448 });
+  const temporary = `${crcCacheFile()}.${process.pid}.tmp`;
+  await writeFile4(temporary, JSON.stringify(crcCache), { mode: 384 });
+  await rename4(temporary, crcCacheFile());
+}
+
+// src/media-proxy.ts
+import { spawn, spawnSync as spawnSync3 } from "node:child_process";
+import { mkdir as mkdir5, rename as rename5, rm as rm5, stat as stat4, statfs } from "node:fs/promises";
+import os4 from "node:os";
+import path8 from "node:path";
+
+// src/media-walk.ts
+import { lstat as lstat3, readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import path7 from "node:path";
+var CLIP_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".mov",
+  ".mp4",
+  ".m4v",
+  ".mxf",
+  ".mkv",
+  // RAW containers: uploaded as originals, with no proxy (nothing here decodes them).
+  ".braw",
+  ".r3d",
+  ".crm"
+]);
+var RAW_EXTENSIONS = /* @__PURE__ */ new Set([".braw", ".r3d", ".crm"]);
+var hidden = (name) => name.startsWith(".");
+async function walk(paths) {
+  const result = { clips: [], skipped: [], unreadable: [] };
+  const seen = /* @__PURE__ */ new Set();
+  const folders = /* @__PURE__ */ new Set();
+  const visit = async (file, base) => {
+    let info;
+    try {
+      info = await lstat3(file);
+      if (info.isSymbolicLink()) info = await stat3(file);
+    } catch (error) {
+      result.unreadable.push({
+        path: file,
+        code: error.code ?? "unknown"
+      });
+      return;
+    }
+    if (info.isDirectory()) {
+      const folder = `${info.dev}:${info.ino}`;
+      if (folders.has(folder)) return;
+      folders.add(folder);
+      let names;
+      try {
+        names = await readdir3(file);
+      } catch (error) {
+        result.unreadable.push({
+          path: file,
+          code: error.code ?? "unknown"
+        });
+        return;
+      }
+      for (const name2 of names.sort()) {
+        if (hidden(name2)) continue;
+        await visit(path7.join(file, name2), base);
+      }
+      return;
+    }
+    if (!info.isFile()) return;
+    const id = `${info.dev}:${info.ino}`;
+    if (seen.has(id)) return;
+    seen.add(id);
+    const name = path7.basename(file);
+    if (hidden(name)) return;
+    const ext = path7.extname(name).toLowerCase();
+    if (!CLIP_EXTENSIONS.has(ext)) {
+      result.skipped.push({ path: file, reason: skipReason(ext) });
+      return;
+    }
+    result.clips.push({
+      path: file,
+      sourcePath: path7.relative(base, file) || name,
+      name,
+      size: Number(info.size),
+      mtimeMs: Number(info.mtimeMs),
+      ino: Number(info.ino),
+      dev: Number(info.dev)
+    });
+  };
+  for (const p of paths) {
+    const absolute = path7.resolve(p);
+    let base = path7.dirname(absolute);
+    try {
+      if ((await stat3(absolute)).isDirectory()) base = path7.dirname(absolute);
+    } catch {
+    }
+    await visit(absolute, base);
+  }
+  return result;
+}
+function skipReason(ext) {
+  if ([".wav", ".aif", ".aiff", ".mp3", ".m4a", ".bwf"].includes(ext))
+    return "audio";
+  if ([".xml", ".mhl", ".bim", ".ale", ".edl", ".txt", ".csv"].includes(ext))
+    return "sidecar";
+  if ([".jpg", ".jpeg", ".png", ".tif", ".tiff", ".heic"].includes(ext))
+    return "still";
+  if ([".ari", ".dng", ".exr", ".dpx"].includes(ext)) return "frame sequence";
+  return "not a clip";
+}
+
+// src/media-proxy.ts
+var RECIPE_VERSION = 1;
+var ffmpegBin = () => process.env.OSMO_FFMPEG ?? "ffmpeg";
+var ffprobeBin = () => process.env.OSMO_FFPROBE ?? "ffprobe";
+function preflight() {
+  const run = (bin, args) => spawnSync3(bin, args, { encoding: "utf8", maxBuffer: 8 << 20 });
+  const version2 = run(ffmpegBin(), ["-hide_banner", "-version"]);
+  const probe = run(ffprobeBin(), ["-hide_banner", "-version"]);
+  const ffmpeg = version2.status === 0;
+  const ffprobe = probe.status === 0;
+  const encoders = ffmpeg ? run(ffmpegBin(), ["-hide_banner", "-encoders"]).stdout ?? "" : "";
+  const filters = ffmpeg ? run(ffmpegBin(), ["-hide_banner", "-filters"]).stdout ?? "" : "";
+  let macOk = false;
+  if (process.platform === "darwin") {
+    const sw = run("sw_vers", ["-productVersion"]).stdout?.trim() ?? "";
+    macOk = Number(sw.split(".")[0]) >= 13;
+  }
+  const result = {
+    ffmpeg,
+    ffprobe,
+    ffmpegVersion: /ffmpeg version (\S+)/.exec(version2.stdout ?? "")?.[1],
+    libx264: /\blibx264\b/.test(encoders),
+    videotoolbox: macOk && /\bh264_videotoolbox\b/.test(encoders),
+    scaleVt: macOk && /\bscale_vt\b/.test(filters)
+  };
+  const [major, minor] = (result.ffmpegVersion ?? "").replace(/^n/, "").split(".").map(Number);
+  if (!ffmpeg || !ffprobe)
+    result.problem = "ffmpeg and ffprobe are needed to make proxies here. Install FFmpeg; until then originals upload alone, without proxies.";
+  else if (major < 5 || major === 5 && minor < 1)
+    result.problem = `FFmpeg ${result.ffmpegVersion} is too old to make proxies; install 5.1 or newer.`;
+  else if (!result.libx264 && !result.videotoolbox)
+    result.problem = "This FFmpeg has neither libx264 nor VideoToolbox. Install an FFmpeg build with libx264.";
+  return result;
+}
+function ratio(value) {
+  if (!value) return 0;
+  const [n, d] = value.split(/[/:]/).map(Number);
+  return d ? n / d : n;
+}
+var tag = (value) => value && value !== "unknown" && value !== "reserved" ? String(value) : void 0;
+async function probeClip(file) {
+  const out2 = await capture(ffprobeBin(), [
+    "-v",
+    "error",
+    "-show_streams",
+    "-show_format",
+    "-of",
+    "json",
+    file
+  ]);
+  if (out2.code !== 0) return null;
+  let data;
+  try {
+    data = JSON.parse(out2.stdout);
+  } catch {
+    return null;
+  }
+  const streams = data.streams ?? [];
+  const v = streams.find(
+    (s) => s.codec_type === "video" && !s.disposition?.attached_pic
+  );
+  const audioTracks = streams.filter((s) => s.codec_type === "audio").length;
+  const durationS = Number(data.format?.duration ?? 0) || 0;
+  if (!v) return { durationS, audioTracks };
+  const sideRotation = (v.side_data_list ?? []).find((d) => typeof d.rotation === "number")?.rotation;
+  const tagRotation = Number(
+    v.tags?.rotate ?? 0
+  );
+  const frames = Number(v.nb_frames);
+  return {
+    durationS,
+    audioTracks,
+    video: {
+      codec: String(v.codec_name ?? ""),
+      profile: v.profile ? String(v.profile) : void 0,
+      pixFmt: String(v.pix_fmt ?? ""),
+      width: Number(v.width ?? 0),
+      height: Number(v.height ?? 0),
+      sar: ratio(v.sample_aspect_ratio) || 1,
+      frameRate: String(v.r_frame_rate ?? ""),
+      avgFrameRate: String(v.avg_frame_rate ?? ""),
+      frames: Number.isFinite(frames) && frames > 0 ? frames : void 0,
+      timescale: Number(String(v.time_base ?? "").split("/")[1]) || 0,
+      transfer: tag(v.color_transfer),
+      colorSpace: tag(v.color_space),
+      colorPrimaries: tag(v.color_primaries),
+      colorRange: tag(v.color_range),
+      rotation: Math.round(Number(sideRotation ?? tagRotation) || 0) % 360
+    }
+  };
+}
+function proxySize(probe) {
+  const displayWidth = probe.width * (probe.sar || 1);
+  const long = Math.max(displayWidth, probe.height);
+  const f = long > 1920 ? 1920 / long : 1;
+  const even = (n) => Math.max(2, Math.round(n / 2) * 2);
+  return { width: even(displayWidth * f), height: even(probe.height * f) };
+}
+function planProxy(file, probe, tools) {
+  const none = (reason) => ({
+    path: "none",
+    noProxyReason: reason,
+    declared: {}
+  });
+  if (RAW_EXTENSIONS.has(path8.extname(file).toLowerCase())) return none("raw");
+  if (tools.problem) return none("no-ffmpeg");
+  if (!probe?.video || !probe.video.width || !probe.video.height)
+    return none("unreadable");
+  const v = probe.video;
+  if (v.transfer === "smpte2084" || v.transfer === "arib-std-b67")
+    return none("hdr");
+  if (v.rotation !== 0) return none("rotated");
+  const { width, height } = proxySize(v);
+  const vfr = !!v.avgFrameRate && Math.abs(ratio(v.frameRate) - ratio(v.avgFrameRate)) > 0.01;
+  const alpha = /^(yuva|rgba|bgra|argb|abgr|gbrap|ya)/.test(v.pixFmt);
+  const tenBit422 = /422/.test(v.pixFmt);
+  let chosen = "libx264";
+  const rec709 = (!v.colorSpace || v.colorSpace === "bt709") && (!v.colorPrimaries || v.colorPrimaries === "bt709") && (!v.transfer || v.transfer === "bt709") && (!v.colorRange || v.colorRange === "tv");
+  if (!vfr && tools.videotoolbox) {
+    if (v.codec === "prores" && tools.scaleVt)
+      chosen = rec709 ? "videotoolbox-hw" : "videotoolbox-sw";
+    else if ((v.codec === "h264" || v.codec === "hevc") && tenBit422)
+      chosen = "videotoolbox-sw";
+  }
+  if (chosen === "libx264" && !tools.libx264) {
+    if (tools.videotoolbox) chosen = "videotoolbox-sw";
+    else return none("no-encoder");
+  }
+  return {
+    path: chosen,
+    width,
+    height,
+    declared: {
+      recipe: RECIPE_VERSION,
+      encoder: chosen,
+      ffmpeg: tools.ffmpegVersion,
+      source: {
+        codec: v.codec,
+        pixFmt: v.pixFmt,
+        width: v.width,
+        height: v.height
+      },
+      ...alpha ? { alphaFlattened: true } : {},
+      ...vfr ? { variableFrameRate: true } : {}
+    }
+  };
+}
+function encodeArgs(source, out2, plan, probe) {
+  const v = probe.video;
+  if (!v || plan.path === "none" || !plan.width || !plan.height)
+    throw new Error("no proxy to make");
+  const pins = [
+    v.colorSpace ? "" : "colorspace=bt709",
+    v.colorPrimaries ? "" : "color_primaries=bt709",
+    v.transfer ? "" : "color_trc=bt709",
+    v.colorRange ? "" : "range=tv"
+  ].filter(Boolean);
+  const pin = pins.length ? `setparams=${pins.join(":")},` : "";
+  const scale = plan.path === "videotoolbox-hw" ? `scale_vt=w=${plan.width}:h=${plan.height}` : `scale=w=${plan.width}:h=${plan.height}:out_color_matrix=bt709:out_range=tv:flags=bicubic,setsar=1,format=yuv420p`;
+  const label = "setparams=colorspace=bt709:color_primaries=bt709:color_trc=bt709:range=tv";
+  const video = plan.path === "libx264" ? [
+    "-c:v",
+    "libx264",
+    "-preset",
+    "veryfast",
+    "-profile:v",
+    "high",
+    "-b:v",
+    "10M",
+    "-maxrate",
+    "12M",
+    "-bufsize",
+    "20M",
+    "-sc_threshold",
+    "0"
+  ] : [
+    "-c:v",
+    "h264_videotoolbox",
+    "-profile:v",
+    "high",
+    "-b:v",
+    "10M",
+    "-constant_bit_rate",
+    "1",
+    "-g",
+    "9999"
+  ];
+  return [
+    "-hide_banner",
+    "-nostdin",
+    "-y",
+    "-v",
+    "error",
+    "-progress",
+    "pipe:1",
+    ...plan.path === "videotoolbox-hw" ? [
+      "-hwaccel",
+      "videotoolbox",
+      "-hwaccel_output_format",
+      "videotoolbox_vld"
+    ] : [],
+    "-i",
+    source,
+    "-map",
+    "0:v:0",
+    "-map",
+    "0:a?",
+    "-fps_mode",
+    "passthrough",
+    // Preserve source timestamps. FFmpeg 9 removed the legacy -1 alias;
+    // older releases (including supported 5.1) still need that spelling.
+    "-enc_time_base:v",
+    Number(String(plan.declared.ffmpeg ?? "").replace(/^n/, "").split(".")[0]) < 7 ? "-1" : "demux",
+    "-vf",
+    `${pin}${scale},${label}`,
+    ...video,
+    "-bf",
+    "0",
+    "-force_key_frames",
+    "expr:gte(t,n_forced*1)",
+    "-colorspace",
+    "bt709",
+    "-color_primaries",
+    "bt709",
+    "-color_trc",
+    "bt709",
+    "-color_range",
+    "tv",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "192k",
+    "-ar",
+    "48000",
+    ...v.timescale > 0 ? ["-video_track_timescale", String(v.timescale)] : [],
+    // Nothing of the source's metadata (locations, serials, names,
+    // timecode): proxies are served to everyone the clip reaches.
+    "-map_metadata",
+    "-1",
+    "-map_metadata:s:v",
+    "-1",
+    "-map_metadata:s:a",
+    "-1",
+    "-map_chapters",
+    "-1",
+    "-movflags",
+    "+faststart",
+    out2
+  ];
+}
+function workDir() {
+  return path8.join(
+    process.env.OSMO_CONFIG_DIR || path8.join(os4.homedir(), ".osmo"),
+    "media",
+    "work"
+  );
+}
+async function encodeProxy(source, out2, plan, probe, onProgress) {
+  await mkdir5(path8.dirname(out2), { recursive: true });
+  const partial = `${out2}.partial.mp4`;
+  await rm5(partial, { force: true });
+  const args = encodeArgs(source, partial, plan, probe);
+  await new Promise((resolve, reject) => {
+    const child = spawn(ffmpegBin(), args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let err = "";
+    let buffered = "";
+    child.stdout.on("data", (d) => {
+      buffered += d.toString();
+      for (let nl = buffered.indexOf("\n"); nl >= 0; nl = buffered.indexOf("\n")) {
+        const line2 = buffered.slice(0, nl);
+        buffered = buffered.slice(nl + 1);
+        const m = /^out_time_us=(\d+)/.exec(line2);
+        if (m) onProgress?.(Number(m[1]) / 1e6);
+      }
+    });
+    child.stderr.on("data", (d) => {
+      err = (err + d.toString()).slice(-4e3);
+    });
+    child.on("error", reject);
+    child.on(
+      "close",
+      (code) => code === 0 ? resolve() : reject(
+        new Error(
+          err.trim().split("\n").slice(-3).join(" ") || `ffmpeg exited ${code}`
+        )
+      )
+    );
+  });
+  await rename5(partial, out2);
+  return out2;
+}
+async function checkProxy(proxy, source, plan) {
+  const failures = [];
+  const streams = await capture(ffprobeBin(), [
+    "-v",
+    "error",
+    "-count_packets",
+    "-show_entries",
+    "stream=codec_type,codec_name,profile,width,height,pix_fmt,color_space,color_primaries,color_transfer,color_range,has_b_frames,nb_read_packets:stream_tags:format_tags",
+    "-of",
+    "json",
+    proxy
+  ]);
+  if (streams.code !== 0) return { ok: false, failures: ["unreadable"] };
+  const parsed = JSON.parse(streams.stdout);
+  const video = parsed.streams.find((s) => s.codec_type === "video");
+  const audio = parsed.streams.filter((s) => s.codec_type === "audio");
+  if (!video) return { ok: false, failures: ["no video"] };
+  if (parsed.streams.length !== 1 + audio.length)
+    failures.push("streams other than picture and sound");
+  const kept = [
+    ...Object.keys(parsed.format?.tags ?? {}).filter(
+      (k) => ![
+        "major_brand",
+        "minor_version",
+        "compatible_brands",
+        "encoder"
+      ].includes(k)
+    ),
+    ...parsed.streams.flatMap(
+      (st) => Object.entries(st.tags ?? {}).filter(
+        ([k, v]) => !(["language", "encoder", "vendor_id"].includes(k) || k === "handler_name" && ["VideoHandler", "SoundHandler"].includes(v))
+      ).map(([k]) => k)
+    )
+  ];
+  if (kept.length) failures.push(`source metadata kept: ${kept.join(", ")}`);
+  const frames = Number(video.nb_read_packets);
+  const expected = source.video?.frames;
+  if (expected !== void 0 && frames !== expected)
+    failures.push(`frames ${frames} of ${expected}`);
+  else if (expected === void 0 && source.video) {
+    const estimate = source.durationS * ratio(source.video.avgFrameRate);
+    if (estimate > 0 && Math.abs(frames - estimate) > 2)
+      failures.push(`frames ${frames}, expected about ${Math.round(estimate)}`);
+  }
+  if (audio.length !== source.audioTracks)
+    failures.push(`audio tracks ${audio.length} of ${source.audioTracks}`);
+  if (video.codec_name !== "h264") failures.push(`codec ${video.codec_name}`);
+  if (String(video.profile) !== "High")
+    failures.push(`profile ${video.profile}`);
+  if (video.pix_fmt !== "yuv420p")
+    failures.push(`pixel format ${video.pix_fmt}`);
+  if (Number(video.has_b_frames) !== 0) failures.push("B-frames");
+  if (Number(video.width) !== plan.width || Number(video.height) !== plan.height)
+    failures.push(`size ${video.width}x${video.height}`);
+  for (const [key, want] of [
+    ["color_space", "bt709"],
+    ["color_primaries", "bt709"],
+    ["color_transfer", "bt709"],
+    ["color_range", "tv"]
+  ])
+    if (video[key] !== want) failures.push(`${key} ${video[key]}`);
+  const packets = await capture(ffprobeBin(), [
+    "-v",
+    "error",
+    "-select_streams",
+    "v:0",
+    "-show_entries",
+    "packet=pts_time,flags",
+    "-of",
+    "csv=p=0",
+    proxy
+  ]);
+  const rows = [];
+  for (const line2 of packets.stdout.split("\n")) {
+    const [time = "", flags = ""] = line2.split(",");
+    const t = Number.parseFloat(time);
+    if (Number.isFinite(t)) rows.push({ time: t, key: flags.includes("K") });
+  }
+  rows.sort((a, b) => a.time - b.time);
+  let lastKey = Number.NEGATIVE_INFINITY;
+  for (const { time, key } of rows) {
+    if (key) lastKey = time;
+    else if (time - lastKey > 1.1) {
+      failures.push(`keyframe gap ${(time - lastKey).toFixed(2)} s`);
+      break;
+    }
+  }
+  return { ok: failures.length === 0, failures, frames };
+}
+async function capture(bin, args) {
+  return new Promise((resolve) => {
+    const child = spawn(bin, args, { stdio: ["ignore", "pipe", "ignore"] });
+    const chunks = [];
+    child.stdout.on("data", (d) => chunks.push(d));
+    child.on("error", () => resolve({ code: -1, stdout: "" }));
+    child.on(
+      "close",
+      (code) => resolve({ code: code ?? -1, stdout: Buffer.concat(chunks).toString() })
+    );
+  });
+}
+async function freeBytes(dir = workDir()) {
+  try {
+    await mkdir5(dir, { recursive: true });
+    const s = await statfs(dir);
+    return Number(s.bavail) * Number(s.bsize);
+  } catch {
+    return null;
+  }
+}
+async function fileSize(file) {
+  return Number((await stat4(file)).size);
+}
+
+// src/media-transfer.ts
+import { createReadStream as createReadStream2 } from "node:fs";
+import { open as open2 } from "node:fs/promises";
+var STALL_BODY_MS = 6e4;
+var STALL_RESPONSE_MS = 12e4;
+async function putWatched(put, url, headers, body2) {
+  const controller = new AbortController();
+  let last = Date.now();
+  let sent = false;
+  const watchdog = setInterval(() => {
+    const idle = Date.now() - last;
+    if (idle > (sent ? STALL_RESPONSE_MS : STALL_BODY_MS))
+      controller.abort(new Error("the connection stalled"));
+  }, 5e3);
+  let at = 0;
+  const stream = new ReadableStream({
+    pull(c) {
+      last = Date.now();
+      if (at >= body2.length) {
+        sent = true;
+        c.close();
+        return;
+      }
+      const end = Math.min(body2.length, at + CHUNK);
+      c.enqueue(body2.subarray(at, end));
+      at = end;
+    }
+  });
+  try {
+    return await put(url, {
+      method: "PUT",
+      headers,
+      body: stream,
+      signal: controller.signal,
+      // Node's fetch needs this for a streamed body.
+      duplex: "half"
+    });
+  } finally {
+    clearInterval(watchdog);
+  }
+}
+var Semaphore = class {
+  queue = [];
+  available;
+  constructor(units) {
+    this.available = units;
+  }
+  async acquire(weight = 1) {
+    if (this.queue.length === 0 && this.available >= weight) {
+      this.available -= weight;
+    } else {
+      await new Promise(
+        (resolve) => this.queue.push({ weight, resolve })
+      );
+    }
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.available += weight;
+      this.drain();
+    };
+  }
+  drain() {
+    while (this.queue.length > 0 && this.available >= this.queue[0].weight) {
+      const next = this.queue.shift();
+      if (!next) break;
+      this.available -= next.weight;
+      next.resolve();
+    }
+  }
+};
+var SourceChangedError = class extends Error {
+};
+var UploadGoneError = class extends Error {
+};
+var HaltedError = class extends Error {
+};
+var MiB = 1024 * 1024;
+var CHUNK = 64 * 1024;
+var RAM_BUDGET = 1024 * MiB;
+var READS_PER_DRIVE = 3;
+var STALL_MS = 30 * 60 * 1e3;
+var Transfer = class {
+  slots;
+  ram = new Semaphore(RAM_BUDGET);
+  readers = /* @__PURE__ */ new Map();
+  opts;
+  api;
+  constructor(opts) {
+    this.opts = opts;
+    this.api = opts.api ?? mediaApi;
+    this.slots = new Semaphore(opts.jobs);
+  }
+  reader(dev) {
+    let s = this.readers.get(dev);
+    if (!s) {
+      s = new Semaphore(READS_PER_DRIVE);
+      this.readers.set(dev, s);
+    }
+    return s;
+  }
+  /** Read `length` bytes at `offset`, holding a read slot for the drive. */
+  async read(file, offset, length) {
+    const release = await this.reader(file.dev).acquire();
+    try {
+      const handle = await open2(file.path, "r");
+      try {
+        const buffer = Buffer.allocUnsafe(length);
+        let at = 0;
+        while (at < length) {
+          const { bytesRead } = await handle.read(
+            buffer,
+            at,
+            length - at,
+            offset + at
+          );
+          if (bytesRead === 0)
+            throw new SourceChangedError(`${file.path} is shorter than it was`);
+          at += bytesRead;
+        }
+        return buffer;
+      } finally {
+        await handle.close();
+      }
+    } finally {
+      release();
+    }
+  }
+  /** Each part's CRC, reading the whole file once (the duplicate check). */
+  async hashParts(file, partSize, partCount) {
+    const parts = {};
+    for (let n = 1; n <= partCount; n++) {
+      const offset = (n - 1) * partSize;
+      const length = Math.min(partSize, file.size - offset);
+      const release = await this.ram.acquire(Math.min(length, RAM_BUDGET));
+      try {
+        parts[n] = crcToB64(crc64(await this.read(file, offset, length)));
+      } finally {
+        release();
+      }
+    }
+    return parts;
+  }
+  /**
+   * Upload a file into a session, resuming the one `state` names when it can.
+   * `save` persists `state` (it is called often; it should be cheap).
+   */
+  async send(file, state, save3) {
+    for (let restarts = 0; ; restarts++) {
+      if (state.fileId)
+        return { fileId: state.fileId, duplicate: !!state.duplicateOf };
+      try {
+        return await this.attempt(file, state, save3);
+      } catch (error) {
+        const reason = error instanceof SourceChangedError || error instanceof UploadGoneError ? error.message : error instanceof MediaApiError && ["upload_lost", "checksum_mismatch"].includes(error.code) ? error.code : error instanceof MediaApiError && error.code === "complete_refused" ? error.code : null;
+        if (!reason || restarts >= 1) throw error;
+        if (state.sessionId)
+          await this.api.abort(state.sessionId).catch(() => {
+          });
+        for (const key of Object.keys(state))
+          delete state[key];
+        await save3();
+        this.opts.onEvent?.({ event: "restart", file: file.path, reason });
+      }
+    }
+  }
+  async attempt(file, state, save3) {
+    let session = state.sessionId ? await this.api.session(state.sessionId).catch((e) => {
+      if (e instanceof MediaApiError && e.status === 404) return null;
+      throw e;
+    }) : null;
+    if (session?.state === "completed") {
+      state.fileId = session.id;
+      await save3();
+      return { fileId: session.id, duplicate: false };
+    }
+    if (!session || session.state === "aborted" || session.state === "expired") {
+      const created = await this.api.createUpload({
+        role: file.role,
+        size: file.size,
+        name: file.name,
+        sourcePath: file.sourcePath,
+        proxyId: file.proxyId,
+        noProxyReason: file.noProxyReason,
+        declared: file.declared
+      });
+      state.sessionId = created.id;
+      state.partSize = created.partSize;
+      state.partCount = created.partCount;
+      state.parts = {};
+      await save3();
+      if (created.existing.length > 0) {
+        state.parts = await this.hashParts(
+          file,
+          created.partSize,
+          created.partCount
+        );
+        await save3();
+        const full = combineParts(this.partList(file, state));
+        const match = created.existing.find((e) => e.crc64nvme === full);
+        if (match) {
+          await this.api.abort(created.id).catch(() => {
+          });
+          state.fileId = match.id;
+          state.duplicateOf = match.id;
+          await save3();
+          this.opts.onEvent?.({
+            event: "duplicate",
+            file: file.path,
+            id: match.id
+          });
+          return { fileId: match.id, duplicate: true };
+        }
+      }
+      session = { ...created, state: "open", size: file.size, parts: [] };
+    }
+    const sessionId = state.sessionId;
+    state.partSize ??= session.partSize;
+    state.partCount ??= session.partCount;
+    const partSize = state.partSize;
+    const partCount = state.partCount;
+    state.parts ??= {};
+    for (let round = 0; ; round++) {
+      if (session.state === "open") {
+        const committed = new Map(
+          (session.parts ?? []).map((p) => [p.partNumber, p])
+        );
+        for (const [n, p] of committed) {
+          const recorded = state.parts[n];
+          if (recorded && p.crc64nvme && recorded !== p.crc64nvme)
+            throw new SourceChangedError(
+              `${file.path} changed since part ${n} was uploaded`
+            );
+          if (!recorded && p.crc64nvme) {
+            const offset = (n - 1) * partSize;
+            const length = Math.min(partSize, file.size - offset);
+            const crc = crcToB64(crc64(await this.read(file, offset, length)));
+            if (crc !== p.crc64nvme)
+              throw new SourceChangedError(
+                `${file.path} differs from the part ${n} already uploaded`
+              );
+            state.parts[n] = crc;
+          }
+        }
+        const missing = [];
+        for (let n = 1; n <= partCount; n++) {
+          const p = committed.get(n);
+          if (!p || p.size !== this.partLength(file, partSize, n))
+            missing.push(n);
+        }
+        const halt = { failed: false };
+        const results = await Promise.allSettled(
+          missing.map(async (n) => {
+            try {
+              await this.sendPart(
+                file,
+                sessionId,
+                n,
+                partSize,
+                state,
+                save3,
+                halt
+              );
+            } catch (error) {
+              halt.failed = true;
+              throw error;
+            }
+          })
+        );
+        await save3();
+        const failed = results.find(
+          (r) => r.status === "rejected" && !(r.reason instanceof HaltedError)
+        );
+        if (failed) throw failed.reason;
+      }
+      if (file.unchanged && !await file.unchanged())
+        throw new SourceChangedError(
+          `${file.path} changed while uploading; make sure nothing is writing to it`
+        );
+      try {
+        const done = await this.api.complete(
+          sessionId,
+          combineParts(this.partList(file, state))
+        );
+        state.fileId = done.id;
+        await save3();
+        return { fileId: done.id, duplicate: false };
+      } catch (error) {
+        if (error instanceof MediaApiError && (error.code === "parts_missing" || error.code === "parts_changed") && round < 2) {
+          session = await this.api.session(sessionId);
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  partLength(file, partSize, n) {
+    return Math.min(partSize, file.size - (n - 1) * partSize);
+  }
+  partList(file, state) {
+    const partSize = state.partSize;
+    const out2 = [];
+    for (let n = 1; n <= state.partCount; n++) {
+      const crc = state.parts?.[n];
+      if (!crc) throw new Error(`part ${n} of ${file.path} was never hashed`);
+      out2.push({ crc, size: this.partLength(file, partSize, n) });
+    }
+    return out2;
+  }
+  signer = /* @__PURE__ */ new Map();
+  /** Sign a part, batched with whatever else is waiting for this session. */
+  sign(sessionId, part) {
+    let batch = this.signer.get(sessionId);
+    if (!batch) {
+      batch = { pending: [], timer: null };
+      this.signer.set(sessionId, batch);
+    }
+    const b = batch;
+    return new Promise((resolve, reject) => {
+      b.pending.push({ part, resolve, reject });
+      const flush = async () => {
+        b.timer = null;
+        const taken = b.pending.splice(0, 32);
+        if (b.pending.length > 0) b.timer = setTimeout(flush, 0);
+        try {
+          const { urls } = await this.api.signParts(
+            sessionId,
+            taken.map((t) => t.part)
+          );
+          const byNumber = new Map(urls.map((u) => [u.partNumber, u]));
+          for (const t of taken) {
+            const u = byNumber.get(t.part.partNumber);
+            if (u) t.resolve(u);
+            else t.reject(new Error(`part ${t.part.partNumber} wasn't signed`));
+          }
+        } catch (error) {
+          for (const t of taken) t.reject(error);
+        }
+      };
+      if (b.pending.length >= 32) {
+        if (b.timer) clearTimeout(b.timer);
+        void flush();
+      } else b.timer ??= setTimeout(flush, 25);
+    });
+  }
+  async sendPart(file, sessionId, n, partSize, state, save3, halt) {
+    const length = this.partLength(file, partSize, n);
+    const releaseSlot = await this.slots.acquire();
+    const releaseRam = await this.ram.acquire(Math.min(length, RAM_BUDGET));
+    try {
+      if (halt.failed) throw new HaltedError();
+      let body2 = await this.read(file, (n - 1) * partSize, length);
+      let crc = crcToB64(crc64(body2));
+      const recorded = state.parts?.[n];
+      if (recorded && recorded !== crc)
+        throw new SourceChangedError(`${file.path} changed while uploading`);
+      state.parts ??= {};
+      state.parts[n] = crc;
+      save3().catch(() => {
+      });
+      let signed2 = await this.sign(sessionId, {
+        partNumber: n,
+        size: length,
+        crc64nvme: crc
+      });
+      let resigned = false;
+      let reread = false;
+      let delay2 = 1e3;
+      const started = Date.now();
+      for (; ; ) {
+        let status = 0;
+        let detail = "";
+        try {
+          const res = await putWatched(
+            this.opts.put ?? fetch,
+            signed2.url,
+            signed2.headers,
+            body2
+          );
+          status = res.status;
+          detail = status >= 400 ? await res.text().catch(() => "") : "";
+          if (res.ok) {
+            await res.arrayBuffer().catch(() => {
+            });
+            this.opts.onBytes?.(length, file.role);
+            return;
+          }
+        } catch (error) {
+          detail = error instanceof Error ? error.message : String(error);
+        }
+        if (status === 400 && /BadDigest/.test(detail)) {
+          if (reread)
+            throw new Error(
+              `Unstable reads from the drive holding ${file.path}: part ${n} read differently twice.`
+            );
+          reread = true;
+          body2 = await this.read(file, (n - 1) * partSize, length);
+          const again = crcToB64(crc64(body2));
+          if (again !== crc)
+            throw new SourceChangedError(
+              `${file.path} changed while uploading`
+            );
+          crc = again;
+          continue;
+        }
+        if (status === 404 && /NoSuchUpload/.test(detail))
+          throw new UploadGoneError(`${file.path}: the upload expired`);
+        if (status === 403) {
+          if (resigned)
+            throw new Error(`S3 refused part ${n} of ${file.path} (403).`);
+          resigned = true;
+          signed2 = await this.sign(sessionId, {
+            partNumber: n,
+            size: length,
+            crc64nvme: crc
+          });
+          continue;
+        }
+        const transient = status === 408 || status === 429 || status === 400 && /RequestTimeout/.test(detail);
+        if (status >= 400 && status < 500 && !transient)
+          throw new Error(`S3 refused part ${n} of ${file.path} (${status}).`);
+        if (Date.now() - started > STALL_MS)
+          throw new Error(
+            `No progress on ${file.path} for 30 minutes. Re-run the same command to resume.`
+          );
+        this.opts.onEvent?.({
+          event: "retry",
+          file: file.path,
+          part: n,
+          reason: status ? `HTTP ${status}` : detail
+        });
+        await new Promise((r) => setTimeout(r, delay2));
+        delay2 = Math.min(delay2 * 2, 6e4);
+      }
+    } finally {
+      releaseRam();
+      releaseSlot();
+    }
+  }
+};
+async function heldPartsMatch(file, sessionId, api2 = mediaApi) {
+  const session = await api2.session(sessionId).catch((e) => {
+    if (e instanceof MediaApiError && e.status === 404) return null;
+    throw e;
+  });
+  if (session?.state === "completed") return "completed";
+  const held = (session?.parts ?? []).filter((p) => p.crc64nvme);
+  if (!session || held.length === 0) return null;
+  for (const p of held) {
+    const start = (p.partNumber - 1) * session.partSize;
+    if (p.size !== Math.min(session.partSize, file.size - start)) return false;
+    const crc = new Crc64Nvme();
+    for await (const chunk of createReadStream2(file.path, {
+      start,
+      end: start + p.size - 1,
+      highWaterMark: 8 << 20
+    }))
+      crc.update(chunk);
+    if (crcToB64(crc.digest()) !== p.crc64nvme) return false;
+  }
+  return true;
+}
+
+// src/media-command.ts
+var Reporter = class {
+  io;
+  tty;
+  lines = [];
+  drawn = 0;
+  last = 0;
+  constructor(io) {
+    this.io = io;
+    this.tty = !io.json && !!process.stderr.isTTY;
+  }
+  event(event, fields) {
+    if (this.io.json)
+      process.stderr.write(`${JSON.stringify({ event, ...fields })}
+`);
+  }
+  /** A line that stays. Paths and names in it are printed safely. */
+  note(message) {
+    if (this.io.json) return;
+    this.clear();
+    this.io.log(printable(message));
+    this.redraw(true);
+  }
+  /** The progress block, replaced in place on a terminal. */
+  progress(lines) {
+    this.lines = lines.map((line2) => printable(line2));
+    this.redraw(false);
+  }
+  clear() {
+    if (!this.tty || this.drawn === 0) return;
+    process.stderr.write(`\x1B[${this.drawn}A\x1B[0J`);
+    this.drawn = 0;
+  }
+  redraw(force) {
+    if (!this.tty) return;
+    const now = Date.now();
+    if (!force && now - this.last < 250) return;
+    this.last = now;
+    this.clear();
+    if (this.lines.length === 0) return;
+    process.stderr.write(`${this.lines.join("\n")}
+`);
+    this.drawn = this.lines.length;
+  }
+  done() {
+    this.clear();
+    this.lines = [];
+  }
+};
+var clips = (n) => `${n} ${n === 1 ? "clip" : "clips"}`;
+var gb2 = (n) => n >= 1e9 ? `${(n / 1e9).toFixed(1)} GB` : `${Math.max(0, Math.round(n / 1e6))} MB`;
+function saver(entry) {
+  let chain = Promise.resolve();
+  return () => {
+    chain = chain.then(
+      () => writeEntry(entry),
+      () => writeEntry(entry)
+    );
+    return chain;
+  };
+}
+function holdLock(key, file) {
+  return new Promise((resolve, reject) => {
+    let release;
+    const held = new Promise((r) => {
+      release = r;
+    });
+    withEntryLock(key, file, async () => {
+      resolve(release);
+      await held;
+    }).catch(reject);
+  });
+}
+async function inPool(items, limit, work) {
+  const queue = [...items];
+  await Promise.all(
+    Array.from({ length: Math.min(limit, queue.length) }, async () => {
+      for (let item = queue.shift(); item !== void 0; item = queue.shift())
+        await work(item);
+    })
+  );
+}
+function acrossDrives(work) {
+  const byDrive = /* @__PURE__ */ new Map();
+  for (const w of [...work].sort((a, b) => a.clip.size - b.clip.size)) {
+    const list2 = byDrive.get(w.clip.dev) ?? [];
+    list2.push(w);
+    byDrive.set(w.clip.dev, list2);
+  }
+  const out2 = [];
+  const lists = [...byDrive.values()];
+  for (let i = 0; out2.length < work.length; i++)
+    for (const list2 of lists) if (list2[i]) out2.push(list2[i]);
+  return out2;
+}
+function keepAwake() {
+  if (process.platform !== "darwin") return;
+  try {
+    const child = spawn2("caffeinate", ["-i", "-w", String(process.pid)], {
+      stdio: "ignore",
+      detached: true
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function ownOriginals() {
+  let bySize = null;
+  return () => {
+    bySize ??= (async () => {
+      const map = /* @__PURE__ */ new Map();
+      let cursor;
+      do {
+        const page = await mediaApi.list({ role: "original", cursor });
+        for (const f of page.files) {
+          const list2 = map.get(f.size) ?? [];
+          list2.push(f);
+          map.set(f.size, list2);
+        }
+        cursor = page.cursor ?? void 0;
+      } while (cursor);
+      return map;
+    })();
+    return bySize;
+  };
+}
+function wholeCrcs() {
+  const crcs = /* @__PURE__ */ new Map();
+  return (clip) => {
+    let crc = crcs.get(clip.path);
+    if (!crc) {
+      crc = (async () => {
+        const hash = new Crc64Nvme();
+        const stream = createReadStream3(clip.path, {
+          highWaterMark: 8 << 20
+        });
+        for await (const chunk of stream) hash.update(chunk);
+        return crcToB64(hash.digest());
+      })();
+      crcs.set(clip.path, crc);
+    }
+    return crc;
+  };
+}
+async function accountScope() {
+  const { origin, userId } = await mediaApi.account();
+  const scope = `${origin} ${userId}`;
+  const known = await readFile5(scopesFile(), "utf8").then((t) => JSON.parse(t)).catch(() => ({}));
+  if (known[origin] !== scope) {
+    known[origin] = scope;
+    await mkdir6(mediaHome(), { recursive: true, mode: 448 });
+    await writeFile5(scopesFile(), JSON.stringify(known), { mode: 384 });
+  }
+  return scope;
+}
+var scopesFile = () => path9.join(mediaHome(), "accounts.json");
+async function knownScope() {
+  const known = await readFile5(scopesFile(), "utf8").then((t) => JSON.parse(t)).catch(() => ({}));
+  return known[authOrigin()] ?? null;
+}
+async function recognize(clip, entry, uploaded, crcOf) {
+  const candidates = (await uploaded()).get(clip.size);
+  if (!candidates?.length) return;
+  const full = await crcOf(clip);
+  const match = candidates.find((f) => f.crc64nvme === full);
+  if (!match) return;
+  if (entry.original?.sessionId)
+    await mediaApi.abort(entry.original.sessionId).catch(() => {
+    });
+  entry.original = {
+    state: "done",
+    fileId: match.id,
+    duplicateOf: match.id,
+    crc64nvme: full
+  };
+  if (match.proxyId) entry.proxy = { state: "done", fileId: match.proxyId };
+}
+async function isThisFile(entry, clip, fingerprint, uploaded, crcOf) {
+  if (entry.source.fingerprint !== fingerprint) return false;
+  if (entry.source.path === clip.path && entry.source.ino === clip.ino)
+    return true;
+  let fileId = entry.original?.fileId;
+  const sessionId = entry.original?.sessionId;
+  if (!fileId && sessionId) {
+    const held = await heldPartsMatch(clip, sessionId);
+    if (held !== "completed") return held !== false;
+    fileId = sessionId;
+  }
+  if (!fileId) return true;
+  const recorded = (await uploaded()).get(clip.size)?.find((f) => f.id === fileId);
+  return !!recorded && recorded.crc64nvme === await crcOf(clip);
+}
+function projectFolder(value, command) {
+  const root = path9.resolve(value);
+  const pointer = cloudPointer(root);
+  if (!pointer)
+    throw new UsageError(
+      `${value} isn't a synced Studio project's folder.`,
+      `osmo media ${command} --help`
+    );
+  if (pointer.origin !== authOrigin())
+    throw new UsageError(
+      `That project is on ${pointer.origin}. Run the command with OSMO_BASE_URL=${pointer.origin}.`,
+      `osmo media ${command} --help`
+    );
+  return root;
+}
+async function mediaUpload(paths, flags, io) {
+  const out2 = new Reporter(io);
+  const scope = await accountScope();
+  const projectRoot = typeof flags.project === "string" ? projectFolder(flags.project, "upload") : null;
+  if (!projectRoot && cloudPointer(process.cwd()))
+    out2.note(
+      "This folder is a Studio project; add --project . to place these clips in it."
+    );
+  const proxiesOnly = !!flags["proxies-only"];
+  const noProxy = !!flags["no-proxy"];
+  const rerun = [
+    "osmo media upload",
+    ...paths.map(quote),
+    ...proxiesOnly ? ["--proxies-only"] : [],
+    ...noProxy ? ["--no-proxy"] : [],
+    ...projectRoot ? ["--project", quote(projectRoot)] : []
+  ].join(" ");
+  const jobs = Number(flags.jobs ?? 12);
+  const found = await walk(paths);
+  for (const u of found.unreadable) {
+    const hint = u.code === "EPERM" && process.platform === "darwin" ? " macOS refused to read it: allow your terminal in System Settings > Privacy & Security > Files and Folders (or Full Disk Access)." : "";
+    out2.note(`Can't read ${u.path} (${u.code}).${hint}`);
+  }
+  for (const s of found.skipped)
+    out2.event("skip", { file: s.path, reason: s.reason });
+  if (found.skipped.length)
+    out2.note(
+      `Skipping ${found.skipped.length} ${found.skipped.length === 1 ? "file that isn't a clip" : "files that aren't clips"} (audio, sidecars, stills, frame sequences).`
+    );
+  if (found.clips.length === 0)
+    return {
+      status: found.unreadable.length ? "incomplete" : "nothing_to_upload",
+      ...found.unreadable.length ? { unreadable: found.unreadable } : {},
+      next: "osmo media upload --help"
+    };
+  const tools = noProxy ? {
+    ffmpeg: false,
+    ffprobe: false,
+    libx264: false,
+    videotoolbox: false,
+    scaleVt: false
+  } : preflight();
+  if (!noProxy && tools.problem) out2.note(tools.problem);
+  const work = [];
+  const locked = [];
+  const uploaded = ownOriginals();
+  const crcOf = wholeCrcs();
+  const claimed = /* @__PURE__ */ new Map();
+  for (const clip of found.clips) {
+    const lock = (key2) => holdLock(key2, clip.path).catch((error) => {
+      if (!(error instanceof LedgerLockedError)) throw error;
+      locked.push(error.message);
+      out2.note(error.message);
+      return null;
+    });
+    let key = ledgerKey(clip, scope);
+    let twin = claimed.get(key);
+    if (twin && await crcOf(twin) !== await crcOf(clip)) {
+      key = contentKey(clip, await crcOf(clip), scope);
+      twin = claimed.get(key);
+    }
+    if (twin) {
+      out2.note(
+        `${clip.path} is the same file as ${twin.path}; uploading it once.`
+      );
+      continue;
+    }
+    claimed.set(key, clip);
+    let unlock = await lock(key);
+    if (!unlock) continue;
+    let fingerprint;
+    try {
+      fingerprint = await fingerprintOf(clip);
+    } catch (error) {
+      unlock();
+      found.unreadable.push({
+        path: clip.path,
+        code: error.code ?? "unknown"
+      });
+      out2.note(`Can't read ${clip.path}.`);
+      continue;
+    }
+    let recorded = await readEntry(key);
+    if (recorded && !await isThisFile(recorded, clip, fingerprint, uploaded, crcOf)) {
+      unlock();
+      key = contentKey(clip, await crcOf(clip), scope);
+      claimed.set(key, clip);
+      unlock = await lock(key);
+      if (!unlock) continue;
+      recorded = await readEntry(key);
+    }
+    const entry = recorded ?? {
+      version: 1,
+      key,
+      scope,
+      source: {
+        path: clip.path,
+        sourcePath: clip.sourcePath,
+        name: clip.name,
+        size: clip.size,
+        mtimeMs: clip.mtimeMs,
+        ino: clip.ino,
+        fingerprint
+      },
+      updatedAt: ""
+    };
+    entry.source.path = clip.path;
+    entry.source.ino = clip.ino;
+    if (!entry.original?.fileId) await recognize(clip, entry, uploaded, crcOf);
+    const needsProbe = !noProxy && !entry.original?.fileId;
+    const probe = needsProbe && tools.ffprobe ? await probeClip(clip.path) : null;
+    const plan = noProxy ? { path: "none", noProxyReason: "skipped", declared: {} } : entry.plan && (entry.proxy?.fileId || entry.original?.fileId) ? {
+      path: entry.plan.proxy,
+      noProxyReason: entry.plan.noProxyReason,
+      declared: entry.plan.declared ?? {}
+    } : planProxy(clip.path, probe, tools);
+    entry.plan = {
+      proxy: plan.path,
+      ...plan.noProxyReason ? { noProxyReason: plan.noProxyReason } : {},
+      ...probe ? { durationS: probe.durationS } : {},
+      declared: plan.declared
+    };
+    await writeEntry(entry);
+    work.push({ clip, entry, probe, plan, unlock });
+    out2.event("plan", {
+      file: clip.path,
+      bytes: clip.size,
+      proxy: plan.path,
+      ...plan.noProxyReason ? { noProxyReason: plan.noProxyReason } : {}
+    });
+  }
+  const release = () => {
+    for (const w of work) w.unlock();
+  };
+  try {
+    const encodeList = work.filter(
+      (w) => w.plan.path !== "none" && !w.entry.proxy?.fileId && !w.entry.original?.fileId && w.probe
+    );
+    const totalBytes = work.reduce((n, w) => n + w.clip.size, 0);
+    const proxyHours = encodeList.reduce(
+      (h, w) => h + (w.probe?.durationS ?? 0) / 3600,
+      0
+    );
+    if (flags["dry-run"]) {
+      return {
+        status: "planned",
+        clips: work.map((w) => ({
+          file: w.clip.path,
+          bytes: w.clip.size,
+          proxy: w.plan.path,
+          noProxyReason: w.plan.noProxyReason,
+          done: !!(w.entry.original?.fileId || proxiesOnly && w.entry.proxy?.fileId)
+        })),
+        skipped: found.skipped.length,
+        totalBytes,
+        proxyHours: Math.round(proxyHours * 100) / 100,
+        next: rerun
+      };
+    }
+    const need = proxyHours * 46e8 * 1.2;
+    const free = await freeBytes();
+    if (free !== null && need > free)
+      throw new UsageError(
+        `Making these proxies needs about ${gb2(need)} free in ${workDir()}; there is ${gb2(free)}. Free some space and re-run.`,
+        "osmo media upload --help",
+        "disk_full"
+      );
+    keepAwake();
+    if (projectRoot) {
+      await adopt(projectRoot);
+      const inside = await excludeSources(
+        projectRoot,
+        work.map((w) => w.clip.path)
+      );
+      if (inside.length)
+        out2.note(
+          `${inside.length === 1 ? "A source file is" : `${inside.length} source files are`} inside the project; they are kept out of its history.`
+        );
+    }
+    const progress = {
+      encoded: 0,
+      encodeTotal: encodeList.length,
+      encodeNote: "",
+      proxyBytes: 0,
+      proxyTotal: 0,
+      proxiesDone: 0,
+      originalBytes: 0,
+      originalTotal: 0,
+      originalsDone: 0,
+      originalsStarted: false,
+      started: Date.now()
+    };
+    const draw = () => {
+      const secs = (Date.now() - progress.started) / 1e3 || 1;
+      out2.progress([
+        `Encoding proxies    ${progress.encoded}/${progress.encodeTotal}   ${progress.encodeNote}`,
+        `Uploading proxies   ${progress.proxiesDone}/${progress.encodeTotal}   ${gb2(progress.proxyBytes)} of ${gb2(progress.proxyTotal)}`,
+        `Originals           ${progress.originalsDone}/${proxiesOnly ? 0 : work.length}   ${gb2(progress.originalBytes)} of ${gb2(progress.originalTotal)}${progress.originalsStarted ? `, ${gb2((progress.originalBytes + progress.proxyBytes) / secs)}/s` : ", starts after the proxies"}`
+      ]);
+    };
+    const transfer = new Transfer({
+      jobs,
+      onBytes: (bytes2, role) => {
+        if (role === "proxy") progress.proxyBytes += bytes2;
+        else progress.originalBytes += bytes2;
+        draw();
+      },
+      onEvent: (e) => {
+        out2.event(e.event, e);
+        if (e.event === "restart")
+          out2.note(`Restarting ${e.file}: ${e.reason}`);
+      }
+    });
+    const encodeJobs = Number(
+      flags["encode-jobs"] ?? (tools.videotoolbox ? 2 : 1)
+    );
+    await inPool(encodeList, encodeJobs, async (w) => {
+      const save3 = saver(w.entry);
+      const target = path9.join(workDir(), w.entry.key, "proxy.mp4");
+      const existing = w.entry.proxy?.workPath ? await stat5(w.entry.proxy.workPath).catch(() => null) : null;
+      if (!(w.entry.proxy?.state === "encoded" && existing)) {
+        try {
+          const t0 = Date.now();
+          await encodeProxy(
+            w.clip.path,
+            target,
+            w.plan,
+            w.probe,
+            (s) => {
+              const x = s / ((Date.now() - t0) / 1e3 || 1);
+              progress.encodeNote = `${w.clip.name}, ${w.plan.path}, ${x.toFixed(1)}x realtime`;
+              draw();
+            }
+          );
+        } catch (error) {
+          w.plan = {
+            path: "none",
+            noProxyReason: "encode-failed",
+            declared: {}
+          };
+          w.entry.plan = { proxy: "none", noProxyReason: "encode-failed" };
+          w.entry.proxy = { state: "failed", error: error.message };
+          await save3();
+          out2.event("error", {
+            file: w.clip.path,
+            stage: "encode",
+            message: error.message
+          });
+          out2.note(
+            `Couldn't make a proxy of ${w.clip.name}; its original uploads alone (${error.message}).`
+          );
+          return;
+        }
+        const check = await checkProxy(target, w.probe, w.plan);
+        out2.event("check", {
+          file: w.clip.path,
+          ok: check.ok,
+          failures: check.failures
+        });
+        if (!check.ok) {
+          await rm6(target, { force: true });
+          w.plan = {
+            path: "none",
+            noProxyReason: "local-check-failed",
+            declared: {}
+          };
+          w.entry.plan = { proxy: "none", noProxyReason: "local-check-failed" };
+          w.entry.proxy = { state: "failed", error: check.failures.join("; ") };
+          await save3();
+          out2.note(
+            `The proxy of ${w.clip.name} failed its check (${check.failures.join("; ")}); its original uploads alone.`
+          );
+          return;
+        }
+        w.entry.proxy = {
+          state: "encoded",
+          workPath: target,
+          size: await fileSize(target),
+          crc64nvme: await crcOfFile(target)
+        };
+        await save3();
+      }
+      progress.encoded++;
+      out2.event("encode", { file: w.clip.path, bytes: w.entry.proxy?.size });
+      draw();
+    });
+    const proxies = work.filter(
+      (w) => w.entry.proxy?.workPath && w.entry.proxy.state !== "failed"
+    ).sort((a, b) => (a.entry.proxy?.size ?? 0) - (b.entry.proxy?.size ?? 0));
+    progress.proxyTotal = proxies.reduce(
+      (n, w) => n + (w.entry.proxy?.fileId ? 0 : w.entry.proxy?.size ?? 0),
+      0
+    );
+    const failures = [];
+    const stopOriginals = { quota: false };
+    await inPool(proxies, 4, async (w) => {
+      const proxy = w.entry.proxy;
+      if (!proxy?.workPath) return;
+      const save3 = saver(w.entry);
+      try {
+        const state = {
+          sessionId: proxy.sessionId,
+          partSize: proxy.partSize,
+          partCount: proxy.partCount,
+          parts: proxy.parts,
+          fileId: proxy.fileId
+        };
+        const file = {
+          path: proxy.workPath,
+          dev: -1,
+          size: proxy.size ?? await fileSize(proxy.workPath),
+          role: "proxy",
+          name: `${path9.parse(w.clip.name).name}.mp4`,
+          sourcePath: w.clip.sourcePath,
+          declared: w.plan.declared
+        };
+        const sent = await transfer.send(file, state, async () => {
+          Object.assign(proxy, state);
+          await save3();
+        });
+        proxy.fileId = sent.fileId;
+        proxy.state = "done";
+        await save3();
+        progress.proxiesDone++;
+        out2.event("complete", {
+          file: w.clip.path,
+          role: "proxy",
+          id: sent.fileId,
+          duplicate: sent.duplicate
+        });
+        draw();
+      } catch (error) {
+        failures.push({ file: w.clip.path, message: error.message });
+        out2.event("error", {
+          file: w.clip.path,
+          stage: "proxy",
+          message: error.message
+        });
+        if (error instanceof MediaApiError && error.code === "media_upload_not_enabled")
+          throw error;
+      }
+    });
+    const existingPointers = projectRoot ? new Map((await pointersIn(projectRoot)).map((p) => [p.id, p.path])) : /* @__PURE__ */ new Map();
+    const placed = [];
+    let needsPull = false;
+    const place = async (w, fileId, proxyFile) => {
+      if (!projectRoot || w.entry.placed?.[projectRoot]) return;
+      const already = [w.entry.proxy?.fileId, w.entry.original?.fileId].map((id) => id ? existingPointers.get(id) : void 0).find(Boolean);
+      const rel = already ?? placeFor(projectRoot, w.clip.sourcePath);
+      if (!already) {
+        await placeClip(projectRoot, rel, fileId, proxyFile);
+        placed.push(rel);
+      }
+      w.entry.placed = { ...w.entry.placed, [projectRoot]: rel };
+      await writeEntry(w.entry);
+      if (w.entry.proxy?.fileId && !existsSync3(path9.join(projectRoot, rel)))
+        needsPull = true;
+      out2.event("place", { file: w.clip.path, path: rel });
+    };
+    const unplaced = [];
+    for (const w of work) {
+      if (w.entry.proxy?.fileId)
+        await place(w, w.entry.proxy.fileId, w.entry.proxy.workPath ?? null);
+      else if (projectRoot) unplaced.push(w.clip.path);
+    }
+    const pointer = projectRoot ? cloudPointer(projectRoot) : null;
+    if (needsPull && projectRoot && pointer)
+      await pull(projectRoot, pointer).catch(
+        (error) => out2.note(`Couldn't fetch some proxies: ${error.message}`)
+      );
+    const originals = proxiesOnly ? [] : acrossDrives(
+      work.filter(
+        (w) => !w.entry.original?.fileId && (w.plan.path === "none" || !!w.entry.proxy?.fileId)
+      )
+    );
+    progress.originalTotal = originals.reduce((n, w) => n + w.clip.size, 0);
+    progress.originalsStarted = true;
+    await inPool(originals, 4, async (w) => {
+      if (stopOriginals.quota) return;
+      const save3 = saver(w.entry);
+      w.entry.original ??= { state: "uploading" };
+      const original = w.entry.original;
+      const unchanged = async () => {
+        const now = await stat5(w.clip.path).catch(() => null);
+        return !!now && Number(now.size) === w.entry.source.size && Math.floor(Number(now.mtimeMs)) === Math.floor(w.entry.source.mtimeMs);
+      };
+      if (!await unchanged())
+        return void failures.push({
+          file: w.clip.path,
+          message: "the file changed or went away; re-run to upload it"
+        });
+      const state = {
+        sessionId: original.sessionId,
+        partSize: original.partSize,
+        partCount: original.partCount,
+        parts: original.parts,
+        fileId: original.fileId,
+        duplicateOf: original.duplicateOf
+      };
+      try {
+        const proxyId = w.entry.proxy?.fileId;
+        const sent = await transfer.send(
+          {
+            path: w.clip.path,
+            dev: w.clip.dev,
+            size: w.clip.size,
+            role: "original",
+            name: w.clip.name,
+            sourcePath: w.clip.sourcePath,
+            ...proxyId ? { proxyId } : { noProxyReason: w.plan.noProxyReason ?? "none" },
+            ...w.probe ? {
+              declared: {
+                durationS: w.probe.durationS,
+                video: w.probe.video,
+                audioTracks: w.probe.audioTracks
+              }
+            } : {},
+            // Checked again before complete: written to while it was
+            // read, what S3 holds would be a mix.
+            unchanged
+          },
+          state,
+          async () => {
+            Object.assign(original, state);
+            await save3();
+          }
+        );
+        original.fileId = sent.fileId;
+        original.state = "done";
+        if (state.parts && Object.keys(state.parts).length === state.partCount)
+          original.crc64nvme = combineParts(
+            Array.from({ length: state.partCount }, (_, i) => ({
+              crc: state.parts[i + 1],
+              size: Math.min(
+                state.partSize,
+                w.clip.size - i * state.partSize
+              )
+            }))
+          );
+        if (sent.duplicate) {
+          const known = await mediaApi.file(sent.fileId).catch(() => null);
+          w.entry.proxy = known?.proxyId ? { state: "done", fileId: known.proxyId } : void 0;
+        }
+        await save3();
+        progress.originalsDone++;
+        out2.event(sent.duplicate ? "duplicate" : "complete", {
+          file: w.clip.path,
+          role: "original",
+          id: sent.fileId
+        });
+        draw();
+      } catch (error) {
+        if (error instanceof MediaApiError && error.code === "quota_exceeded")
+          stopOriginals.quota = true;
+        if (error instanceof MediaApiError && error.code === "proxy_not_found") {
+          w.entry.proxy = void 0;
+          delete w.entry.plan;
+        }
+        original.state = "failed";
+        original.error = error.message;
+        await save3();
+        failures.push({ file: w.clip.path, message: error.message });
+        out2.event("error", {
+          file: w.clip.path,
+          stage: "original",
+          message: error.message
+        });
+      }
+    });
+    out2.done();
+    const clips2 = work.map((w) => ({
+      file: w.clip.path,
+      proxyId: w.entry.proxy?.fileId,
+      originalId: w.entry.original?.fileId,
+      ...w.plan.noProxyReason ? { noProxyReason: w.plan.noProxyReason } : {},
+      ...w.entry.original?.duplicateOf ? { duplicate: true } : {}
+    }));
+    const unfinished = work.filter(
+      (w) => !(proxiesOnly ? w.entry.proxy?.fileId || w.plan.path === "none" : w.entry.original?.fileId)
+    );
+    for (const w of work)
+      if (w.entry.proxy?.state === "done" && w.entry.proxy.workPath) {
+        if (w.entry.original?.fileId)
+          await rm6(path9.dirname(w.entry.proxy.workPath), {
+            recursive: true,
+            force: true
+          });
+      }
+    const result = {
+      status: unfinished.length || locked.length || failures.length || found.unreadable.length ? "incomplete" : "done",
+      clips: clips2,
+      skipped: found.skipped.length,
+      ...found.unreadable.length ? { unreadable: found.unreadable } : {},
+      ...projectRoot ? { project: projectRoot, placed, unplaced } : {},
+      ...failures.length ? { failures } : {},
+      ...locked.length ? { locked } : {},
+      ...stopOriginals.quota ? { quota: "exceeded" } : {},
+      next: unfinished.length ? rerun : "osmo media ls"
+    };
+    out2.event("done", { status: result.status });
+    return result;
+  } finally {
+    out2.done();
+    release();
+  }
+}
+function formatUpload(result) {
+  const r = result;
+  if (r.status === "nothing_to_upload") return "No clips found.";
+  if (r.status === "planned")
+    return [
+      `${clips(r.clips?.length ?? 0)}, ${gb2(r.totalBytes ?? 0)}; ${Math.round((r.proxyHours ?? 0) * 60)} min of footage to proxy here.`,
+      ...(r.clips ?? []).map(
+        (c) => `  ${c.file}  ${c.proxy}${c.noProxyReason ? ` (${c.noProxyReason})` : ""}${c.done ? "  done" : ""}`
+      )
+    ].join("\n");
+  const done = r.clips?.filter((c) => c.originalId).length ?? 0;
+  const duplicates = r.clips?.filter((c) => c.duplicate).length ?? 0;
+  const lines = [
+    `${done} of ${clips(r.clips?.length ?? 0)} uploaded${duplicates ? ` (${duplicates} ${duplicates === 1 ? "was" : "were"} already there)` : ""}.`,
+    ...(r.clips ?? []).map(
+      (c) => `  ${path9.basename(c.file)}  ${c.originalId ?? "-"}${c.proxyId ? `  proxy ${c.proxyId}` : c.noProxyReason ? `  no proxy here (${c.noProxyReason})` : ""}`
+    )
+  ];
+  if (r.project && r.placed?.length)
+    lines.push(
+      `Placed ${clips(r.placed.length)} in ${MEDIA_DIR}/; scenes use their paths (sync sends the pointers, never the proxies).`
+    );
+  if (r.unplaced?.length)
+    lines.push(
+      `Not placed: ${clips(r.unplaced.length)} with no proxy up (HDR, rotated or RAW, or a proxy that failed or didn't finish uploading: re-run to retry it).`
+    );
+  if (r.quota)
+    lines.push(
+      "The account's footage storage is full; the remaining originals were skipped."
+    );
+  for (const f of r.failures ?? [])
+    lines.push(`Failed: ${f.file}: ${f.message}`);
+  for (const u of r.unreadable ?? [])
+    lines.push(`Couldn't read: ${u.path} (${u.code})`);
+  if (r.status !== "done") lines.push(`Re-run to resume: ${r.next}`);
+  return lines.join("\n");
+}
+async function mediaStatus(paths) {
+  const scope = await knownScope() ?? await accountScope();
+  let entries = (await allEntries()).filter((e) => e.scope === scope);
+  if (paths.length) {
+    const found = await walk(paths);
+    const keys = new Set(found.clips.map((c) => ledgerKey(c, scope)));
+    const seen = new Set(found.clips.map((c) => c.path));
+    entries = entries.filter((e) => keys.has(e.key) || seen.has(e.source.path));
+  }
+  const files = entries.sort((a, b) => a.source.path.localeCompare(b.source.path)).map((e) => ({
+    file: e.source.path,
+    proxy: e.proxy?.fileId ? "uploaded" : e.proxy?.state ?? e.plan?.noProxyReason ?? "none",
+    original: e.original?.fileId ? e.original.duplicateOf ? "already uploaded" : "uploaded" : e.original?.state ?? "waiting",
+    proxyId: e.proxy?.fileId,
+    originalId: e.original?.fileId,
+    partsSent: e.original?.parts ? Object.keys(e.original.parts).length : 0,
+    partCount: e.original?.partCount
+  }));
+  return { status: "ok", files, next: "osmo media upload PATH" };
+}
+function formatStatus(result) {
+  const r = result;
+  if (!r.files.length) return "No footage uploads recorded on this machine.";
+  return r.files.map(
+    (f) => `${f.file}
+  proxy: ${f.proxy}; original: ${f.original}${f.original === "uploading" && f.partCount ? ` (${f.partsSent}/${f.partCount} parts read)` : ""}`
+  ).join("\n");
+}
+async function mediaList() {
+  const files = [];
+  let cursor;
+  do {
+    const page = await mediaApi.list({ cursor });
+    files.push(...page.files);
+    cursor = page.cursor ?? void 0;
+  } while (cursor && files.length < 5e3);
+  return { status: "ok", files, next: "osmo media get ID" };
+}
+function formatList(result) {
+  const r = result;
+  if (!r.files.length) return "No footage yet.";
+  return r.files.map(
+    (f) => `${f.id}  ${f.role.padEnd(8)}  ${gb2(f.size).padStart(8)}  ${f.displayName ?? ""}${f.status ? `  [${f.status}]` : ""}`
+  ).join("\n");
+}
+async function mediaAdd(ids, flags) {
+  if (typeof flags.project !== "string")
+    throw new UsageError("--project is required.", "osmo media add --help");
+  const root = projectFolder(flags.project, "add");
+  const files = await Promise.all(ids.map((id) => mediaApi.file(id)));
+  await adopt(root);
+  const existing = new Set((await pointersIn(root)).map((p) => p.id));
+  const placed = [];
+  const unplaced = [];
+  for (const f of files) {
+    if ([f.id, f.proxyId, f.originalId].some((id) => id && existing.has(id)))
+      continue;
+    if (f.role === "original" && !f.proxyId) {
+      unplaced.push(f.displayName ?? f.id);
+      continue;
+    }
+    const rel = placeFor(root, f.sourcePath ?? f.displayName ?? `${f.id}.mp4`);
+    await placeClip(root, rel, f.id, null);
+    existing.add(f.id);
+    placed.push(rel);
+  }
+  const pointer = cloudPointer(root);
+  const pulled = pointer ? await pull(root, pointer) : null;
+  return {
+    status: "added",
+    placed,
+    ...unplaced.length ? { unplaced } : {},
+    ...pulled ? { pull: pulled } : {},
+    next: "osmo studio sync"
+  };
+}
+function formatAdd(result) {
+  const r = result;
+  return [
+    r.placed.length ? `Placed ${clips(r.placed.length)}:` : r.unplaced?.length ? "Nothing placed." : "Those clips are already in the project.",
+    ...r.placed.map((p) => `  ${printable(p)}`),
+    ...r.unplaced?.length ? [
+      `Not placed, having no proxy: ${r.unplaced.map((n) => printable(n)).join(", ")}`
+    ] : [],
+    ...r.pull ? pullLines(r.pull) : []
+  ].join("\n");
+}
+async function mediaPull(flags) {
+  const root = path9.resolve(
+    typeof flags.project === "string" ? flags.project : "."
+  );
+  const pointer = cloudPointer(root);
+  if (!pointer)
+    throw new UsageError(
+      `${root} isn't a synced Studio project's folder.`,
+      "osmo media pull --help"
+    );
+  const result = await pull(root, pointer, (m) => console.error(m));
+  return {
+    status: result.unavailable.length || result.pending.length || result.failed.length ? "incomplete" : "pulled",
+    ...result,
+    next: "osmo studio open"
+  };
+}
+function formatPull(result) {
+  return pullLines(result).join("\n");
+}
+async function mediaGet(id, flags) {
+  let file = await mediaApi.file(id);
+  if (file.role === "original" && !flags.original && file.proxyId)
+    file = await mediaApi.file(file.proxyId);
+  const fallback = `${file.id}.${file.role === "proxy" ? "mp4" : "bin"}`;
+  const name = path9.basename(file.displayName ?? "") || fallback;
+  const target = typeof flags.out === "string" ? path9.resolve(flags.out) : path9.resolve([".", ".."].includes(name) ? fallback : name);
+  if (existsSync3(target) && !flags.force)
+    throw new UsageError(
+      `${target} already exists. Give another path with -o, or add --force to replace it.`,
+      "osmo media get --help"
+    );
+  const partial = `${target}.${process.pid}.partial`;
+  const res = await fetch(file.url);
+  if (!res.ok || !res.body) throw new Error(`Download failed (${res.status}).`);
+  const crc = new Crc64Nvme();
+  const body2 = Readable2.fromWeb(
+    res.body
+  );
+  body2.on("data", (chunk) => crc.update(chunk));
+  await pipeline2(body2, createWriteStream2(partial, { flags: "wx" }));
+  if (crcToB64(crc.digest()) !== file.crc64nvme) {
+    await rm6(partial, { force: true });
+    throw new Error(
+      "The download didn't match the file's checksum. Try again."
+    );
+  }
+  await rename6(partial, target);
+  await recordPulled([
+    {
+      fileId: file.id,
+      size: file.size,
+      crc64nvme: file.crc64nvme,
+      path: target
+    }
+  ]);
+  return {
+    status: "downloaded",
+    id: file.id,
+    role: file.role,
+    path: target,
+    bytes: file.size,
+    next: "osmo media ls"
+  };
+}
+function formatGet(result) {
+  const r = result;
+  return `Saved the ${r.role} to ${r.path} (${gb2(r.bytes)}), checksum verified.`;
+}
+
+// src/resources.ts
+import { createHash as createHash4 } from "node:crypto";
+import { constants } from "node:fs";
+import {
+  copyFile as copyFile2,
+  lstat as lstat4,
+  mkdir as mkdir7,
+  mkdtemp,
+  readdir as readdir4,
+  readFile as readFile6,
+  realpath as realpath2,
+  rename as rename7,
+  rm as rm7,
+  writeFile as writeFile6
+} from "node:fs/promises";
+import path10 from "node:path";
+import { unzipSync } from "fflate";
+var CATALOG_OWNER = "osmo";
+var COST = {
+  second: "grows with seconds of output",
+  image: "is the same for each image",
+  character: "grows with characters of text"
+};
+var packageFiles = (primitive) => primitive === "Model" ? ["model.glb", "resource.json"] : ["resource.json", "shader.d.ts", "shader.wgsl"];
+var LOCK = ".osmo-get.lock";
+var maxFile = 1024 * 1024;
+var maxResponse = 4 * maxFile;
+var maxModel = 64 * maxFile;
+var fileLimit = (name) => name.endsWith(".glb") ? maxModel : maxFile;
+var DOWNLOAD_MS = 30 * 6e4;
+var ownerPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var namePattern = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+var versionPattern = /^\d+\.\d+\.\d+$/;
+var digest2 = (bytes2) => createHash4("sha256").update(bytes2).digest("hex");
+var fail = (code, message, next) => {
+  throw new AuthError(code, message, next);
+};
+var invalid = () => fail(
+  "invalid_resource",
+  "Osmo returned an invalid resource package or metadata."
+);
+var text = (value) => typeof value === "string" && value.length > 0;
+var strings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function catalogRef(input) {
+  let value = input.trim();
+  if (/^https?:\/\//i.test(value)) {
+    let page = null;
+    try {
+      page = /^\/resources\/([^/]+)\/?$/.exec(new URL(value).pathname);
+    } catch {
+    }
+    value = page ? decodeURIComponent(page[1]) : "";
+  }
+  const at = value.indexOf("@");
+  const version2 = at === -1 ? void 0 : value.slice(at + 1);
+  const parts = (at === -1 ? value : value.slice(0, at)).split("/");
+  const [owner, name] = parts.length === 1 ? [CATALOG_OWNER, ...parts] : parts;
+  if (parts.length > 2 || !ownerPattern.test(owner) || !namePattern.test(name))
+    fail(
+      "invalid_resource_id",
+      "Use an ID from osmo resources list, such as osmo/silk or silk.",
+      "osmo resources list"
+    );
+  if (version2 !== void 0 && !versionPattern.test(version2))
+    fail("invalid_version", "Use a version such as osmo/silk@1.0.0.");
+  return { id: `${owner}/${name}`, owner, name, version: version2 };
+}
+async function bytes(response, limit = maxResponse) {
+  if (Number(response.headers.get("content-length")) > limit) {
+    await response.body?.cancel();
+    invalid();
+  }
+  const chunks = [];
+  let size = 0;
+  try {
+    for await (const chunk of response.body ?? []) {
+      size += chunk.length;
+      if (size > limit) invalid();
+      chunks.push(chunk);
+    }
+  } catch (error) {
+    if (error instanceof OsmoError) throw error;
+    fail(
+      "network_error",
+      "Lost the connection to Osmo partway through. Check your connection and retry."
+    );
+  }
+  return Buffer.concat(chunks);
+}
+async function responseBody(response, json = true, limit) {
+  if (!response.ok) {
+    const body3 = await response.json().catch(() => ({}));
+    if (response.status === 401) throw loginRequired(authOrigin());
+    if (response.status === 404)
+      fail(
+        "resource_not_found",
+        "No such resource or version. Run osmo resources list.",
+        "osmo resources list"
+      );
+    if (body3.error === "unknown_type" && strings(body3.types))
+      throw new UsageError(
+        `Unknown --type. Types: ${body3.types.join(", ")}.`,
+        "osmo resources list",
+        "unknown_type",
+        { types: body3.types }
+      );
+    fail(
+      "resource_request_failed",
+      `Osmo resource request failed (${response.status}). Retry later.`
+    );
+  }
+  const body2 = await bytes(response, limit);
+  if (!json) return body2;
+  try {
+    return JSON.parse(String(body2));
+  } catch {
+    invalid();
+  }
+}
+async function publicGet(route) {
+  let response;
+  try {
+    response = await osmoFetch(authOrigin() + route, {
+      redirect: "error",
+      signal: AbortSignal.timeout(2e4)
+    });
+  } catch (error) {
+    if (error instanceof OsmoError) throw error;
+    fail(
+      "network_error",
+      "Cannot reach the Osmo resource catalog. Retry or continue using local capabilities."
+    );
+  }
+  return responseBody(response);
 }
 function validItem(item) {
   return !!item && text(item.id) && text(item.title) && typeof item.summary === "string" && (item.use === "run" || item.use === "get") && text(item.kind) && strings(item.tags) && (item.tasks === void 0 || strings(item.tasks));
@@ -3833,21 +6482,21 @@ function unpack(zip, pkg) {
     invalid();
   return { files, manifest: manifest2, names };
 }
-async function stat2(file) {
+async function stat6(file) {
   try {
-    return await lstat2(file);
+    return await lstat4(file);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
   }
 }
 async function save(destination, shown, files, names) {
-  const parent = path4.dirname(destination), base = path4.basename(destination);
-  const inside = (await stat2(destination))?.isDirectory() ?? false;
-  if (!inside) await mkdir3(parent, { recursive: true });
-  const lock = inside ? path4.join(destination, LOCK) : path4.join(parent, `.${base}.osmo-get.lock`);
+  const parent = path10.dirname(destination), base = path10.basename(destination);
+  const inside = (await stat6(destination))?.isDirectory() ?? false;
+  if (!inside) await mkdir7(parent, { recursive: true });
+  const lock = inside ? path10.join(destination, LOCK) : path10.join(parent, `.${base}.osmo-get.lock`);
   try {
-    await mkdir3(lock);
+    await mkdir7(lock);
   } catch (error) {
     if (error.code === "EEXIST")
       fail(
@@ -3858,16 +6507,16 @@ async function save(destination, shown, files, names) {
   }
   let stage;
   try {
-    const existing = await stat2(destination);
+    const existing = await stat6(destination);
     if (existing) {
       if (!existing.isDirectory())
         fail("resource_conflict", `${shown} must be a real folder.`);
-      const entries = (await readdir(destination)).filter((entry) => entry !== LOCK).sort();
+      const entries = (await readdir4(destination)).filter((entry) => entry !== LOCK).sort();
       if (entries.length) {
         const same = entries.join(",") === names.join(",") && (await Promise.all(
           names.map(async (name) => {
-            const file = path4.join(destination, name);
-            return (await stat2(file))?.isFile() && (await readFile3(file)).equals(Buffer.from(files[name]));
+            const file = path10.join(destination, name);
+            return (await stat6(file))?.isFile() && (await readFile6(file)).equals(Buffer.from(files[name]));
           })
         )).every(Boolean);
         if (same) return "already_downloaded";
@@ -3876,21 +6525,21 @@ async function save(destination, shown, files, names) {
           `${shown} already holds other files, which were left alone. Download somewhere else with --out DIR.`
         );
       }
-      stage = await mkdtemp(path4.join(destination, ".osmo-get-"));
+      stage = await mkdtemp(path10.join(destination, ".osmo-get-"));
       for (const name of names)
-        await writeFile3(path4.join(stage, name), files[name], { flag: "wx" });
+        await writeFile6(path10.join(stage, name), files[name], { flag: "wx" });
       const copied = [];
       try {
         for (const name of names) {
-          await copyFile(
-            path4.join(stage, name),
-            path4.join(destination, name),
+          await copyFile2(
+            path10.join(stage, name),
+            path10.join(destination, name),
             constants.COPYFILE_EXCL
           );
-          copied.push(path4.join(destination, name));
+          copied.push(path10.join(destination, name));
         }
       } catch (error) {
-        for (const file of copied) await rm3(file, { force: true });
+        for (const file of copied) await rm7(file, { force: true });
         if (error.code !== "EEXIST") throw error;
         fail(
           "resource_conflict",
@@ -3899,20 +6548,20 @@ async function save(destination, shown, files, names) {
       }
       return "downloaded";
     }
-    stage = await mkdtemp(path4.join(parent, `.${base}-`));
+    stage = await mkdtemp(path10.join(parent, `.${base}-`));
     for (const name of names)
-      await writeFile3(path4.join(stage, name), files[name], { flag: "wx" });
-    if (await stat2(destination))
+      await writeFile6(path10.join(stage, name), files[name], { flag: "wx" });
+    if (await stat6(destination))
       fail(
         "resource_conflict",
         `${shown} appeared during the download. Existing files were left alone.`
       );
-    await rename3(stage, destination);
+    await rename7(stage, destination);
     stage = void 0;
     return "downloaded";
   } finally {
-    if (stage) await rm3(stage, { recursive: true, force: true });
-    await rm3(lock, { recursive: true, force: true });
+    if (stage) await rm7(stage, { recursive: true, force: true });
+    await rm7(lock, { recursive: true, force: true });
   }
 }
 async function get(ref, flags, io) {
@@ -3948,7 +6597,7 @@ async function get(ref, flags, io) {
       version: pkg.version,
       scope: "global",
       folder: store.directory,
-      files: pkg.files.map((f) => path4.join(store.directory, f.path)),
+      files: pkg.files.map((f) => path10.join(store.directory, f.path)),
       presets: pkg.presets,
       defaultPreset: pkg.defaultPreset,
       usage: {},
@@ -3957,7 +6606,7 @@ async function get(ref, flags, io) {
       guide: "Ready for offline use in every local project. Apply a film effect in Studio or use film({stock: ...}) in a scene."
     };
   }
-  const destination = path4.resolve(flags.out ?? pkg.folder);
+  const destination = path10.resolve(flags.out ?? pkg.folder);
   checkFiles(pkg);
   const declared = pkg.files.reduce((sum, file) => sum + file.bytes, 0);
   const zip = await responseBody(
@@ -3970,9 +6619,9 @@ async function get(ref, flags, io) {
   );
   const { files, manifest: manifest2, names } = unpack(zip, pkg);
   const status = await save(destination, flags.out ?? pkg.folder, files, names);
-  const relative = path4.relative(await realpath(process.cwd()), await realpath(destination)).split(path4.sep).join("/");
+  const relative = path10.relative(await realpath2(process.cwd()), await realpath2(destination)).split(path10.sep).join("/");
   const folder = relative === "" ? "." : relative;
-  const src = path4.isAbsolute(folder) || folder.startsWith("../") || folder === "." ? folder : `./${folder}`;
+  const src = path10.isAbsolute(folder) || folder.startsWith("../") || folder === "." ? folder : `./${folder}`;
   return {
     status,
     id: detail.id,
@@ -4141,73 +6790,13 @@ ${r.guide}`;
 }
 
 // src/run.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { createWriteStream, existsSync as existsSync2, openAsBlob, rmSync as rmSync2 } from "node:fs";
-import { mkdir as mkdir4, readFile as readFile4, rename as rename4, rm as rm4, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
-import path6 from "node:path";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-
-// src/cloud-pointer.ts
-import { spawnSync } from "node:child_process";
-
-// src/git.ts
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeFileSync
-} from "node:fs";
-import path5 from "node:path";
-var hasRepo = (root) => existsSync(path5.join(root, ".git"));
-
-// src/cloud-pointer.ts
-var PROJECT_ID = /^[a-z0-9]{10,40}$/;
-function pointerFromGit(root) {
-  const read = (key) => {
-    const r = spawnSync("git", ["-C", root, "config", "--get", key], {
-      encoding: "utf8"
-    });
-    return r.status === 0 ? r.stdout.trim() : "";
-  };
-  const origin = read("osmo.cloud.origin"), id = read("osmo.cloud.id");
-  return origin && id ? { origin, id } : null;
-}
-var cloudPointer = (root) => hasRepo(root) ? pointerFromGit(root) : null;
-
-// src/cloud-request.ts
-var PERMISSION_DOES = {
-  "projects:write": "change projects",
-  "energy:spend": "run models on your plan"
-};
-function scopeRequired(origin, scope) {
-  const login = origin === authOrigin() ? "osmo login" : `OSMO_BASE_URL=${origin} osmo login`;
-  return new OsmoError(
-    "scope_required",
-    `This login can't ${PERMISSION_DOES[scope ?? ""] ?? "do that"}. Sign in again to allow it: ${login}`,
-    login
-  );
-}
-async function call(origin, route, { method = "GET", body: body2, timeoutMs = 6e4, allow = [] } = {}) {
-  const response = await authenticatedFetch(
-    route,
-    { method, body: body2, timeoutMs },
-    origin
-  );
-  const data = await response.json().catch(() => ({}));
-  if (response.status === 403 && data.error === "scope_required" && !allow.includes(403))
-    throw scopeRequired(origin, data.scope);
-  if (!response.ok && !allow.includes(response.status))
-    throw new Error(
-      `Cloud ${response.status}: ${typeof data.error === "string" ? data.error : response.status === 400 ? "the request was invalid" : "request failed"}`
-    );
-  return { status: response.status, ...data };
-}
-
-// src/run.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { createWriteStream as createWriteStream3, existsSync as existsSync4, openAsBlob, rmSync as rmSync2 } from "node:fs";
+import { mkdir as mkdir8, readFile as readFile7, rename as rename8, rm as rm8, stat as stat7, writeFile as writeFile7 } from "node:fs/promises";
+import path11 from "node:path";
+import { Readable as Readable3 } from "node:stream";
+import { pipeline as pipeline3 } from "node:stream/promises";
 var WAIT_SECONDS = 60;
 var REQUEST_MS = (WAIT_SECONDS + 30) * 1e3;
 var READ_RETRIES = 4;
@@ -4486,7 +7075,7 @@ function fileSource(value) {
   return { kind: "local", file: value };
 }
 function uploadType(name) {
-  return UPLOAD_TYPES[path6.extname(name).slice(1).toLowerCase()];
+  return UPLOAD_TYPES[path11.extname(name).slice(1).toLowerCase()];
 }
 var megabytes = (n) => n < 1048576 ? `${Math.max(1, Math.round(n / 1024))} KB` : `${(n / 1048576).toFixed(1)} MB`;
 async function resolveFiles(schema, input, issues, io) {
@@ -4516,18 +7105,18 @@ async function resolveFiles(schema, input, issues, io) {
   for (const job of jobs) {
     if (job.source.kind === "ours") job.set(job.source.url);
     if (job.source.kind !== "local") continue;
-    const info = await stat3(job.source.file).catch(() => null);
+    const info = await stat7(job.source.file).catch(() => null);
     if (!info?.isFile())
       issues.push({ path: job.path, message: `no file at ${job.source.file}` });
     else if (!uploadType(job.source.file))
       issues.push({
         path: job.path,
-        message: `${path6.basename(job.source.file)} isn't a type runs take (${Object.keys(UPLOAD_TYPES).join(", ")})`
+        message: `${path11.basename(job.source.file)} isn't a type runs take (${Object.keys(UPLOAD_TYPES).join(", ")})`
       });
     else if (info.size > UPLOAD_MAX_BYTES || info.size === 0)
       issues.push({
         path: job.path,
-        message: `${path6.basename(job.source.file)} must be 1 byte to ${megabytes(UPLOAD_MAX_BYTES)}`
+        message: `${path11.basename(job.source.file)} must be 1 byte to ${megabytes(UPLOAD_MAX_BYTES)}`
       });
   }
   return async () => {
@@ -4536,7 +7125,7 @@ async function resolveFiles(schema, input, issues, io) {
         const { file } = job.source;
         const type = uploadType(file);
         const blob = await openAsBlob(file, { type });
-        io.log(`uploading ${path6.basename(file)} (${megabytes(blob.size)})`);
+        io.log(`uploading ${path11.basename(file)} (${megabytes(blob.size)})`);
         job.set(await upload(blob, type));
       } else if (job.source.kind === "web") {
         io.log(`fetching ${job.source.url}`);
@@ -4618,8 +7207,8 @@ async function readInputsFile(file) {
   let text2;
   try {
     text2 = file === "-" ? await new Response(
-      Readable.toWeb(process.stdin)
-    ).text() : await readFile4(file, "utf8");
+      Readable3.toWeb(process.stdin)
+    ).text() : await readFile7(file, "utf8");
   } catch {
     throw new OsmoError("invalid_input", `Can't read ${file}.`);
   }
@@ -4724,14 +7313,14 @@ Next: ${next}`
     stop();
   }
 }
-function projectFolder(start = process.cwd()) {
-  for (let dir = path6.resolve(start); ; dir = path6.dirname(dir)) {
-    if (existsSync2(path6.join(dir, ".osmo/project.json"))) return dir;
-    if (path6.dirname(dir) === dir) return null;
+function projectFolder2(start = process.cwd()) {
+  for (let dir = path11.resolve(start); ; dir = path11.dirname(dir)) {
+    if (existsSync4(path11.join(dir, ".osmo/project.json"))) return dir;
+    if (path11.dirname(dir) === dir) return null;
   }
 }
 function here() {
-  const root = projectFolder();
+  const root = projectFolder2();
   if (!root) return null;
   const pointer = cloudPointer(root);
   let same = false;
@@ -4742,23 +7331,23 @@ function here() {
   return same && pointer ? { root, project: pointer.id } : { root };
 }
 async function generationsFolder(root) {
-  const ours = path6.join(root, "generations");
-  const listed = hasRepo(root) ? spawnSync2("git", ["-C", root, "ls-files", "--", "generations"], {
+  const ours = path11.join(root, "generations");
+  const listed = hasRepo(root) ? spawnSync4("git", ["-C", root, "ls-files", "--", "generations"], {
     encoding: "utf8"
   }) : null;
   const tracked = listed?.status === 0 && listed.stdout.trim() !== "";
-  const theirs = tracked || existsSync2(ours) && !existsSync2(path6.join(ours, ".gitignore"));
-  const folder = theirs ? path6.join(root, "osmo-generations") : ours;
-  await mkdir4(folder, { recursive: true });
-  const ignore = path6.join(folder, ".gitignore");
-  if (!existsSync2(ignore)) await writeFile4(ignore, "*\n");
+  const theirs = tracked || existsSync4(ours) && !existsSync4(path11.join(ours, ".gitignore"));
+  const folder = theirs ? path11.join(root, "osmo-generations") : ours;
+  await mkdir8(folder, { recursive: true });
+  const ignore = path11.join(folder, ".gitignore");
+  if (!existsSync4(ignore)) await writeFile7(ignore, "*\n");
   return folder;
 }
 async function targets(run, out2) {
   const model = (run.model.split("/").pop() ?? "").replace(/[^A-Za-z0-9.-]/g, "-").replace(/^[.-]+/, "") || "output";
   const name = `${model}-${run.job.slice(4, 12)}`;
   const extension = (o) => {
-    const fromUrl = path6.extname(new URL(o.url).pathname).slice(1);
+    const fromUrl = path11.extname(new URL(o.url).pathname).slice(1);
     return EXTENSIONS[o.mime] ?? (/^[A-Za-z0-9]{1,5}$/.test(fromUrl) ? fromUrl : "bin");
   };
   const several = run.outputs.length > 1;
@@ -4770,20 +7359,20 @@ async function targets(run, out2) {
     if (!project) return named;
     const folder2 = await generationsFolder(project.root);
     return named.map(
-      (n) => path6.relative(process.cwd(), path6.join(folder2, n)) || n
+      (n) => path11.relative(process.cwd(), path11.join(folder2, n)) || n
     );
   }
-  const folder = /[/\\]$/.test(out2) || (await stat3(out2).catch(() => null))?.isDirectory() || several && !path6.extname(out2);
+  const folder = /[/\\]$/.test(out2) || (await stat7(out2).catch(() => null))?.isDirectory() || several && !path11.extname(out2);
   if (!folder) {
     if (!several)
       return run.outputs.map(
-        (o) => path6.extname(out2) ? out2 : `${out2}.${extension(o)}`
+        (o) => path11.extname(out2) ? out2 : `${out2}.${extension(o)}`
       );
-    const stem = out2.slice(0, -path6.extname(out2).length);
+    const stem = out2.slice(0, -path11.extname(out2).length);
     return run.outputs.map((o, i) => `${stem}-${i + 1}.${extension(o)}`);
   }
-  await mkdir4(out2, { recursive: true });
-  return named.map((file) => path6.join(out2, file));
+  await mkdir8(out2, { recursive: true });
+  return named.map((file) => path11.join(out2, file));
 }
 async function save2(run, out2, io) {
   let partial;
@@ -4817,24 +7406,24 @@ Next: ${pickUp(run.job, out2)}`
           gone ? `${run.job}'s outputs are no longer kept. Outputs last 30 days.` : `Couldn't download ${run.job}'s output${response ? ` (${response.status})` : ""}.`,
           gone ? void 0 : pickUp(run.job, out2)
         );
-      await mkdir4(path6.dirname(path6.resolve(file)), { recursive: true });
+      await mkdir8(path11.dirname(path11.resolve(file)), { recursive: true });
       partial = `${file}.part-${process.pid}`;
       try {
-        await pipeline(
-          Readable.fromWeb(
+        await pipeline3(
+          Readable3.fromWeb(
             response.body
           ),
-          createWriteStream(partial)
+          createWriteStream3(partial)
         );
-        await rename4(partial, file);
+        await rename8(partial, file);
       } catch (error) {
-        await rm4(partial, { force: true });
+        await rm8(partial, { force: true });
         throw error;
       } finally {
         partial = void 0;
       }
-      const bytes2 = (await stat3(file)).size;
-      const said = path6.extname(file).slice(1).toLowerCase();
+      const bytes2 = (await stat7(file)).size;
+      const said = path11.extname(file).slice(1).toLowerCase();
       const made = EXTENSIONS[output.mime];
       if (out2 !== void 0 && said && made && (said === "jpeg" ? "jpg" : said) !== made)
         io.log(`${file} holds ${output.mime}, which its name doesn't say.`);
@@ -4923,7 +7512,7 @@ async function runCommand(id, flags, io) {
   const schema = detail.run.inputSchema;
   const base = flags.inputs ? await readInputsFile(flags.inputs) : {};
   const { input, issues } = buildInputs(schema, flags.input ?? [], base);
-  const wanted = path6.extname(flags.out ?? "").slice(1).toLowerCase();
+  const wanted = path11.extname(flags.out ?? "").slice(1).toLowerCase();
   const formats = schema.properties?.format?.enum;
   if (wanted && formats && input.format === void 0 && !issues.length) {
     const format = wanted === "jpeg" ? "jpg" : wanted;
@@ -4956,7 +7545,7 @@ Osmo: ${error.message}
 Next: ${error.next}`
     );
   });
-  const key = randomUUID3();
+  const key = randomUUID4();
   const linked = here()?.project;
   const refusedFirst = (code) => ["runs_disabled", "model_unavailable"].includes(code ?? "");
   let started;
@@ -5335,7 +7924,7 @@ async function unshareProject(projectId, origin) {
     );
 }
 async function shareComments(value, {
-  open = false,
+  open: open3 = false,
   origin = authOrigin()
 } = {}) {
   const share = await resolveShare(value, origin);
@@ -5347,7 +7936,7 @@ async function shareComments(value, {
       `/api/projects/${share.id}/review-comments${cursor ? `?before=${encodeURIComponent(cursor)}` : ""}`
     );
     for (const { render, ...comment } of page.comments)
-      if (!open || comment.status === "open")
+      if (!open3 || comment.status === "open")
         comments.push({
           ...comment,
           version: render,
@@ -5565,8 +8154,8 @@ function formatUsage(result, now = Date.now()) {
 
 // src/video-deploy.ts
 import { execFile } from "node:child_process";
-import { stat as stat4 } from "node:fs/promises";
-import path7 from "node:path";
+import { stat as stat8 } from "node:fs/promises";
+import path12 from "node:path";
 import { promisify } from "node:util";
 
 // src/upload-render.ts
@@ -5671,7 +8260,7 @@ async function uploadRender(origin, project, file, metadata, log = () => {
 // src/video-deploy.ts
 var exec = promisify(execFile);
 async function probeVideo(file) {
-  const info = await stat4(file).catch(() => null);
+  const info = await stat8(file).catch(() => null);
   if (!info?.isFile() || !info.size || info.size > 2 * 1024 ** 3)
     throw new Error(
       "Video must be an existing, non-empty file no larger than 2 GiB."
@@ -5735,9 +8324,9 @@ async function shareVideo(file, {
   if (to !== void 0) parseShare(to, origin);
   if (name !== void 0 && (!name.trim() || name.trim().length > 200))
     throw new Error("--name takes 1 to 200 characters.");
-  const source = path7.resolve(file), metadata = await probeVideo(source);
+  const source = path12.resolve(file), metadata = await probeVideo(source);
   await currentAccount(origin);
-  const title = name?.trim() ?? path7.basename(source).slice(0, 200);
+  const title = name?.trim() ?? path12.basename(source).slice(0, 200);
   const target = to === void 0 ? void 0 : await resolveShare(to);
   if (target?.kind === "repo")
     throw new OsmoError(
@@ -5780,14 +8369,14 @@ Retry with --to ${share} to add it to the same share.`,
 }
 
 // src/commands.ts
-var auth = (path9, usage, about, args, flags) => ({
-  path: path9,
+var auth = (path14, usage, about, args, flags) => ({
+  path: path14,
   group: "Account",
   usage,
   about,
   args,
   flags,
-  run: (rest, flags2) => authCommand([...path9, ...rest], flags2),
+  run: (rest, flags2) => authCommand([...path14, ...rest], flags2),
   text: (result) => formatAuth(result),
   failed: (result) => ["denied", "expired"].includes(result.status)
 });
@@ -6030,15 +8619,16 @@ var COMMANDS = [
     example: "osmo run osmo/seedance-2.5 --input prompt='slow push in' --input durationSeconds=5 --out shot.mp4",
     run: (args, flags, io) => runCommand(args[0], flags, io),
     text: formatRun,
-    failed: (result) => result.status === "failed"
+    failed: (result) => result.status === "failed" || "job" in result && result.status === "expired"
   },
   {
     path: ["jobs"],
     group: "Resources and models",
-    usage: "jobs [JOB] [--out PATH] [--limit N] [--all]",
-    about: "Lists your recent runs, newest first: in a project linked to the cloud, that project's. With a JOB, waits for it and saves its outputs, which are kept for 30 days.",
+    usage: "jobs [JOB] [--out PATH] [--limit N] [--all] [--cloud]",
+    about: "With a cloud render ID, shows its current status and review link. --cloud lists recent cloud renders. For model runs, lists your recent runs, newest first: in a project linked to the cloud, that project's. With a JOB, waits for it and saves its outputs, which are kept for 30 days.",
     args: [0, 1],
     flags: {
+      cloud: { type: "boolean", help: "List your 50 most recent cloud renders across projects." },
       out: out(
         "PATH",
         "A file for one output, replacing one of that name, or a folder. A file name with no extension gets the output's. Default: MODEL-JOB.EXT in the project's generations/ (kept out of its versions), or here outside a project."
@@ -6060,6 +8650,8 @@ var COMMANDS = [
     },
     example: "osmo jobs run_abc12345",
     check(args, flags) {
+      if (flags.cloud && (args[0] || flags.out || flags.limit || flags.cursor || flags.all)) throw new UsageError("Use osmo jobs --cloud on its own to list cloud renders.", "osmo jobs --help");
+      if (args[0] && isCloudRenderJob(args[0]) && flags.out) throw new UsageError("Cloud renders publish to the review link; --out applies to model runs.", "osmo jobs --help");
       if (args[0] === "list")
         throw new UsageError(
           "There is no osmo jobs list. osmo jobs lists your runs.",
@@ -6091,19 +8683,19 @@ var COMMANDS = [
           "osmo jobs --help"
         );
     },
-    run: (args, flags, io) => jobsCommand(args[0], flags, io),
-    text: (result) => "runs" in result ? formatJobs(result) : formatRun(result),
-    failed: (result) => result.status === "failed"
+    run: (args, flags, io) => flags.cloud ? listCloudRenderJobs() : args[0] && isCloudRenderJob(args[0]) ? cloudRenderJob(args[0]) : jobsCommand(args[0], flags, io),
+    text: (result) => "jobs" in result ? result.jobs.map(formatCloudRender).join("\n\n") || "No cloud renders yet." : "job" in result && isCloudRenderJob(String(result.job)) ? formatCloudRender(result) : "runs" in result ? formatJobs(result) : formatRun(result),
+    failed: (result) => result.status === "failed" || "job" in result && result.status === "expired"
   },
   {
     path: ["jobs", "cancel"],
     group: "Resources and models",
     usage: "jobs cancel JOB",
-    about: "Cancels a run that hasn't started yet, and nothing is charged. A run that has started can't be stopped; it finishes on its own.",
+    about: "Cancels a queued model run or a cloud render. Queued cancellation is free. A cloud render already processing is charged for elapsed processing. Running model generations cannot be stopped.",
     args: [1, 1],
     example: "osmo jobs cancel run_abc12345",
-    run: (args) => cancelCommand(args[0]),
-    text: formatCancel
+    run: (args) => isCloudRenderJob(args[0]) ? cloudRenderJob(args[0], void 0, true) : cancelCommand(args[0]),
+    text: (result) => "job" in result && isCloudRenderJob(String(result.job)) ? formatCloudRender(result) : formatCancel(result)
   },
   {
     path: ["share"],
@@ -6267,10 +8859,18 @@ Version: ${r.versionLink}`;
   ),
   studio(
     "clone",
-    "PROJECT [FOLDER]",
-    "Copies a cloud project and its history into a new folder. Legacy web-editor projects download as text exports with asset URLs and require conversion before local editing. PROJECT is an ID or project/review link. FOLDER defaults to the project name, or legacy-<id> for legacy exports. Needs osmo login and source access.",
+    "PROJECT [FOLDER] [--no-media]",
+    "Copies a cloud project and its history into a new folder. Legacy web-editor projects download as text exports with asset URLs and require conversion before local editing. PROJECT is an ID or project/review link. FOLDER defaults to the project name, or legacy-<id> for legacy exports. A project that points to footage also gets those clips' proxies (osmo media pull). Needs osmo login and source access.",
     [1, 2],
-    { example: "osmo studio clone https://studio.osmo.inc/app/projects/ID" }
+    {
+      example: "osmo studio clone https://studio.osmo.inc/app/projects/ID",
+      flags: {
+        "no-media": {
+          type: "boolean",
+          help: "Don't fetch the footage the project points to."
+        }
+      }
+    }
   ),
   studio(
     "sync",
@@ -6355,11 +8955,13 @@ Version: ${r.versionLink}`;
   ),
   studio(
     "deploy",
-    "[SCENE] [--overwrite]",
+    "[SCENE] [--overwrite] [--cloud] [--wait]",
     "Deploys the project for review: sends this folder's version, renders the scene, and adds the video as a new version on the project's review link, where people comment on moments, areas and layers. The first run makes the cloud project, named after the folder (osmo studio sync --name NAME first, to name it yourself) and private: sourceAccess in the result is who can open the source. The review link is separate, and opens for anyone who has it. A deploy posts only what this folder holds: when the cloud has edits the folder has not seen (someone else's, from the web or another folder), it stops before rendering, lists them under arrived, and leaves the folder as it was. Then run osmo studio sync to bring them in and look at them, and deploy again. Needs osmo login.",
     [0, 1],
     {
       flags: {
+        cloud: { type: "boolean", help: "Render on Osmo GPU workers using paid allowance or credits. Returns a job ID; no local GPU is needed." },
+        wait: { type: "boolean", help: "With --cloud, wait for completion. Disconnecting leaves the job running." },
         overwrite: {
           type: "boolean",
           help: "Put this folder's version over cloud edits it has not seen, as one new revision on top of them; theirs stay in history. Only when that is what the user wants. It refuses while someone is editing in the web."
@@ -6368,7 +8970,7 @@ Version: ${r.versionLink}`;
       removed: {
         "--access": "a project starts private, and osmo studio permissions set --access LEVEL changes it."
       },
-      failed: (result) => result.status !== "deployed"
+      failed: (result) => !["deployed", "queued", "starting", "running", "uploading", "succeeded"].includes(String(result.status))
     }
   ),
   studio(
@@ -6455,7 +9057,138 @@ Version: ${r.versionLink}`;
     "EMAIL",
     "Stops sharing the project with someone, whether it was shared here or on the web. Access they have through a workspace, or through the access level, stays.",
     [1, 1]
-  )
+  ),
+  {
+    path: ["media", "upload"],
+    group: "Media",
+    usage: "media upload PATH... [--project DIR] [--proxies-only] [--no-proxy] [--jobs N] [--encode-jobs N] [--dry-run]",
+    about: "Uploads camera footage: files or whole cards and folders. Each clip's proxy is made and checked on this machine and uploaded first, so cloud work can start, then the original, linked to it. Every part is checksummed end to end. Re-run the same command (or any command over the same files) to resume after a crash, a network drop or a remount. With --project, each clip is also placed in the project's osmo-media/ folder: a pointer, which sync sends, and the proxy beside it, which stays out of git. Like other uploaded media, anyone with a file's link can download it.",
+    args: [1, Number.POSITIVE_INFINITY],
+    flags: {
+      project: {
+        type: "string",
+        value: "DIR",
+        help: "Also place the clips in this synced Studio project's folder."
+      },
+      "proxies-only": {
+        type: "boolean",
+        help: "Upload the proxies only; the originals can follow later with the same command."
+      },
+      "no-proxy": {
+        type: "boolean",
+        help: "Upload originals only, with no proxies."
+      },
+      jobs: {
+        type: "string",
+        value: "N",
+        help: "Parts uploaded at once, 8 to 16 (default 12)."
+      },
+      "encode-jobs": {
+        type: "string",
+        value: "N",
+        help: "Proxies made at once (default 2 with VideoToolbox, else 1)."
+      },
+      "dry-run": {
+        type: "boolean",
+        help: "Plan only: what would be proxied and uploaded."
+      }
+    },
+    example: "osmo media upload /Volumes/CARD_A --project .",
+    check(_args, flags) {
+      if (flags["proxies-only"] && flags["no-proxy"])
+        throw new UsageError(
+          "--proxies-only and --no-proxy can't both be given.",
+          "osmo media upload --help"
+        );
+      const jobs = Number(flags.jobs ?? 12);
+      if (!Number.isInteger(jobs) || jobs < 8 || jobs > 16)
+        throw new UsageError(
+          "--jobs takes a whole number from 8 to 16.",
+          "osmo media upload --help"
+        );
+      const encode = Number(flags["encode-jobs"] ?? 1);
+      if (!Number.isInteger(encode) || encode < 1 || encode > 8)
+        throw new UsageError(
+          "--encode-jobs takes a whole number from 1 to 8.",
+          "osmo media upload --help"
+        );
+    },
+    run: (args, flags, io) => mediaUpload(args, flags, io),
+    text: formatUpload,
+    failed: (result) => result.status === "incomplete"
+  },
+  {
+    path: ["media", "status"],
+    group: "Media",
+    usage: "media status [PATH...]",
+    about: "Shows what this machine has uploaded, or is part way through uploading: every file, or those under the paths given.",
+    args: [0, Number.POSITIVE_INFINITY],
+    run: (args) => mediaStatus(args),
+    text: formatStatus
+  },
+  {
+    path: ["media", "ls"],
+    group: "Media",
+    usage: "media ls",
+    about: "Lists your uploaded footage.",
+    args: [0, 0],
+    run: () => mediaList(),
+    text: formatList
+  },
+  {
+    path: ["media", "add"],
+    group: "Media",
+    usage: "media add ID... --project DIR",
+    about: "Places your uploaded clips in a project folder's osmo-media/: a pointer each, which sync sends, and its proxy, fetched here. To stop using a clip, delete its pointer.",
+    args: [1, 100],
+    flags: {
+      project: {
+        type: "string",
+        value: "DIR",
+        help: "The synced Studio project's folder."
+      }
+    },
+    example: "osmo media add ID --project .",
+    run: (args, flags) => mediaAdd(args, flags),
+    text: formatAdd
+  },
+  {
+    path: ["media", "pull"],
+    group: "Media",
+    usage: "media pull [--project DIR]",
+    about: "Fetches the proxy of every clip the project points to (its osmo-media/*.osmo-media files) that is missing or differs here.",
+    args: [0, 0],
+    flags: {
+      project: {
+        type: "string",
+        value: "DIR",
+        help: "The project's folder (default: this one)."
+      }
+    },
+    run: (_args, flags) => mediaPull(flags),
+    text: formatPull,
+    failed: (result) => result.status === "incomplete"
+  },
+  {
+    path: ["media", "get"],
+    group: "Media",
+    usage: "media get ID [-o PATH] [--original] [--force]",
+    about: "Downloads one of your clips, checking it against its checksum. For an original, downloads its proxy unless --original is given. Never replaces a file already at the path unless --force is given.",
+    args: [1, 1],
+    flags: {
+      out: out("PATH", "Where to save it (default: its own name, here)."),
+      original: {
+        type: "boolean",
+        help: "The camera original, not its proxy."
+      },
+      force: {
+        type: "boolean",
+        help: "Replace a file already at the path."
+      }
+    },
+    run: ([id], flags) => mediaGet(id, flags),
+    text: formatGet
+  }
 ];
 var STUDIO_NOW = {
   "studio publish": "studio sync",
@@ -6473,9 +9206,9 @@ var GLOBAL_FLAGS = {
 function findCommand(words2) {
   let found;
   for (const command of COMMANDS)
-    for (const path9 of [command.path, ...command.aliases ?? []])
-      if (path9.length <= words2.length && path9.every((word, i) => words2[i] === word) && path9.length > (found?.length ?? 0))
-        found = { command, length: path9.length };
+    for (const path14 of [command.path, ...command.aliases ?? []])
+      if (path14.length <= words2.length && path14.every((word, i) => words2[i] === word) && path14.length > (found?.length ?? 0))
+        found = { command, length: path14.length };
   return found && { command: found.command, rest: words2.slice(found.length) };
 }
 function commandHelp(command) {
@@ -6487,7 +9220,7 @@ function commandHelp(command) {
   );
   const width = Math.max(...names.map((name) => name.length));
   const aliases = (command.aliases ?? []).map(
-    (path9) => `osmo ${path9.join(" ")}`
+    (path14) => `osmo ${path14.join(" ")}`
   );
   return [
     `osmo ${command.usage}`,
@@ -6667,10 +9400,10 @@ async function loadStudio() {
     manifest2 = createRequire(import.meta.url).resolve(
       `@osmo.inc/cli-${platform}/package.json`
     );
-    entry = path8.join(path8.dirname(manifest2), "dist/studio.js");
+    entry = path13.join(path13.dirname(manifest2), "dist/studio.js");
   } catch {
   }
-  if (!existsSync3(entry))
+  if (!existsSync5(entry))
     throw new OsmoError(
       "studio_unavailable",
       PLATFORMS.includes(platform) ? `Osmo Studio and its renderer aren't installed: @osmo.inc/cli-${platform} is missing. Reinstall @osmo.inc/cli with optional dependencies; if that doesn't add it, this release has no package for ${platform}.` : `Osmo Studio's renderer isn't available for ${platform} yet. It runs on ${PLATFORMS.join(", ")}.`,