fluncle 0.72.0 → 0.74.0

package/bin/fluncle.mjs

@@ -380,6 +380,107 @@ function formatError(error) {
   }
   return String(error);
 }
+function parseDuration(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (trimmed.includes(":")) {
+    const parts = trimmed.split(":");
+    if (parts.length !== 2 && parts.length !== 3) {
+      return null;
+    }
+    const nums = parts.map((part) => Number(part));
+    if (nums.some((n) => !Number.isFinite(n) || n < 0)) {
+      return null;
+    }
+    if (parts.length === 3) {
+      const [hours, minutes2, seconds2] = nums;
+      if (hours === undefined || minutes2 === undefined || seconds2 === undefined) {
+        return null;
+      }
+      if (minutes2 >= 60 || seconds2 >= 60) {
+        return null;
+      }
+      return Math.round((hours * 3600 + minutes2 * 60 + seconds2) * 1000);
+    }
+    const [minutes, seconds] = nums;
+    if (minutes === undefined || seconds === undefined) {
+      return null;
+    }
+    if (seconds >= 60) {
+      return null;
+    }
+    return Math.round((minutes * 60 + seconds) * 1000);
+  }
+  const value = Number(trimmed);
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function isRemix(title) {
+  return REMIX_MARKER.test(title);
+}
+function stripVersionSuffix(title) {
+  const parts = title.split(/\s+-\s+/);
+  if (parts.length > 1 && VERSION_MARKER.test(parts[parts.length - 1] ?? "")) {
+    return parts.slice(0, -1).join(" - ").trim();
+  }
+  return title.trim();
+}
+function tokenize(value) {
+  return value.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, " ").trim().split(" ").filter(Boolean);
+}
+function versionTokens(title) {
+  const parts = title.split(/\s+-\s+/);
+  const tail = parts.length > 1 ? parts[parts.length - 1] ?? "" : "";
+  if (parts.length > 1 && VERSION_MARKER.test(tail)) {
+    return new Set(tokenize(tail));
+  }
+  const bracketed = /[([]([^)\]]*?)[)\]]/.exec(title);
+  if (bracketed?.[1] && VERSION_MARKER.test(bracketed[1])) {
+    return new Set(tokenize(bracketed[1]));
+  }
+  return new Set;
+}
+function versionMatches(findingTitle, candidateTitle) {
+  const findingIsRemix = isRemix(findingTitle);
+  const candidateIsRemix = isRemix(candidateTitle);
+  if (findingIsRemix) {
+    if (!candidateIsRemix) {
+      return false;
+    }
+    const want = [...versionTokens(findingTitle)].filter((t) => !VERSION_STOPWORDS.has(t));
+    if (want.length === 0) {
+      return true;
+    }
+    const have = versionTokens(candidateTitle);
+    for (const token of want) {
+      if (!have.has(token)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return !candidateIsRemix;
+}
+function baseTitleMatches(findingTitle, candidateTitle) {
+  const want = new Set(tokenize(stripVersionSuffix(findingTitle)));
+  const have = new Set(tokenize(stripVersionSuffix(candidateTitle)));
+  if (want.size === 0) {
+    return false;
+  }
+  for (const token of want) {
+    if (!have.has(token)) {
+      return false;
+    }
+  }
+  return true;
+}
+var VERSION_MARKER, REMIX_MARKER, VERSION_STOPWORDS;
+var init_util = __esm(() => {
+  VERSION_MARKER = /\b(mix|edit|version|remix|dub|vip|bootleg|rework|re-?edit|flip|refix|remaster(?:ed)?|instrumental)\b/i;
+  REMIX_MARKER = /\b(remix|bootleg|vip|rework|re-?edit|flip|refix)\b/i;
+  VERSION_STOPWORDS = new Set(["mix", "the", "and", "feat", "ft", "edit", "version", "remix"]);
+});
 
 // src/output.ts
 function isJsonFailure(value) {
@@ -423,7 +524,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.72.0".trim() ? "0.72.0".trim() : "0.1.0";
+  currentVersion = "0.74.0".trim() ? "0.74.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -887,6 +988,24 @@ var init_recent = __esm(() => {
   init_api();
 });
 
+// src/commands/mixtape-api.ts
+async function mixtapeListCommand() {
+  const response = await adminApiGet("/api/admin/mixtapes");
+  return response.mixtapes;
+}
+async function mixtapeGetCommand(idOrLogId) {
+  const mixtapes = await mixtapeListCommand();
+  const match = mixtapes.find((mixtape) => mixtape.id === idOrLogId || mixtape.logId === idOrLogId);
+  if (!match) {
+    throw new CliError2("mixtape_not_found", `No mixtape with id or log id ${idOrLogId}`);
+  }
+  return match;
+}
+var init_mixtape_api = __esm(() => {
+  init_api();
+  init_output();
+});
+
 // src/commands/mixtape-youtube.ts
 var exports_mixtape_youtube = {};
 __export(exports_mixtape_youtube, {
@@ -1047,70 +1166,217 @@ var init_mixtape_youtube = __esm(() => {
   init_output();
 });
 
-// src/commands/mixtape-set-video.ts
-var exports_mixtape_set_video = {};
-__export(exports_mixtape_set_video, {
-  stageSetVideo: () => stageSetVideo,
-  renditionFfmpegArgs: () => renditionFfmpegArgs,
-  planMultipart: () => planMultipart,
-  buildCompleteXml: () => buildCompleteXml,
-  SET_VIDEO_RENDITION: () => SET_VIDEO_RENDITION,
-  MIN_PART_SIZE: () => MIN_PART_SIZE,
-  MAX_PARTS: () => MAX_PARTS,
-  DEFAULT_PART_SIZE: () => DEFAULT_PART_SIZE
+// src/commands/mixtape-mixcloud.ts
+var exports_mixtape_mixcloud = {};
+__export(exports_mixtape_mixcloud, {
+  mixtapeDescription: () => mixtapeDescription,
+  mixcloudSections: () => mixcloudSections,
+  distributeMixcloud: () => distributeMixcloud,
+  authMixcloudCommand: () => authMixcloudCommand
 });
-import { randomUUID } from "node:crypto";
-import { existsSync, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join4 } from "node:path";
-function planMultipart(contentLength, partSize = DEFAULT_PART_SIZE) {
-  if (!Number.isInteger(contentLength) || contentLength <= 0) {
-    throw new CliError2("invalid_size", `The rendition size must be a positive integer (got ${contentLength})`);
+async function distributeMixcloud(mixtapeId, audioPath, onProgress, unlisted = false) {
+  const token = await fetchMixcloudToken();
+  const mixtape = await mixtapeGetCommand(mixtapeId);
+  const logId = mixtape.logId;
+  if (!logId) {
+    throw new CliError2("mixtape_no_log_id", "The mixtape has no Log ID; mint it before distributing");
   }
-  let effective = Math.max(partSize, MIN_PART_SIZE);
-  if (Math.ceil(contentLength / effective) > MAX_PARTS) {
-    effective = Math.ceil(contentLength / MAX_PARTS);
+  const audio = Bun.file(audioPath);
+  if (!await audio.exists()) {
+    throw new CliError2("audio_not_found", `Audio master not found: ${audioPath}`);
   }
-  const parts = [];
-  let start = 0;
-  let partNumber = 1;
-  while (start < contentLength) {
-    const end = Math.min(start + effective, contentLength);
-    parts.push({ end, partNumber, size: end - start, start });
-    start = end;
-    partNumber += 1;
+  const form = new FormData;
+  form.append("mp3", audio);
+  form.append("name", mixtape.title);
+  form.append("description", mixtapeDescription(mixtape.note, logId));
+  onProgress?.("Mixcloud: fetching the cover…");
+  const picture = await fetchCover(logId);
+  if (picture) {
+    form.append("picture", picture, "cover.png");
   }
-  return { partCount: parts.length, partSize: effective, parts };
+  for (const [index, tag] of mixtapeTags(mixtape).entries()) {
+    form.append(`tags-${index}-tag`, tag);
+  }
+  const sections = mixcloudSections(mixtape.members);
+  for (const [index, section] of sections.entries()) {
+    form.append(`sections-${index}-artist`, section.artist);
+    form.append(`sections-${index}-song`, section.song);
+    form.append(`sections-${index}-start_time`, String(section.start_time));
+  }
+  if (unlisted) {
+    form.append("unlisted", "1");
+    onProgress?.("Mixcloud: uploading UNLISTED (private).");
+  }
+  const cuelessCount = mixtape.members.length - sections.length;
+  if (cuelessCount > 0) {
+    onProgress?.(`Mixcloud: ${cuelessCount} of ${mixtape.members.length} members have no cue (omitted from sections).`);
+  }
+  onProgress?.("Mixcloud: uploading the master…");
+  const uploadResponse = await fetch(`${MIXCLOUD_API}/upload/?access_token=${encodeURIComponent(token)}`, {
+    body: form,
+    method: "POST"
+  });
+  const uploadText = await uploadResponse.text();
+  if (!uploadResponse.ok) {
+    throwMixcloudError(uploadResponse.status, uploadText);
+  }
+  const result = parseUploadResult(uploadText);
+  if (!result.success || !result.key) {
+    throw new CliError2("mixcloud_upload_rejected", `Mixcloud rejected the upload: ${result.message ?? uploadText.slice(0, 300)}`);
+  }
+  const externalId = result.key;
+  const url = `https://www.mixcloud.com${result.key}`;
+  onProgress?.("Mixcloud: recording the link…");
+  await adminApiPost(`/api/admin/mixtapes/${encodeURIComponent(mixtapeId)}/mixcloud/finalize`, {
+    externalId,
+    url
+  });
+  return { url };
 }
-function escapeXml(value) {
-  return value.replace(/[<>&'"]/g, (char) => ({ '"': "&quot;", "&": "&amp;", "'": "&apos;", "<": "&lt;", ">": "&gt;" })[char] ?? char);
+async function authMixcloudCommand() {
+  const response = await adminApiGet("/api/admin/mixcloud/auth/start");
+  console.log(`Open this Mixcloud authorization URL:
+
+${response.authUrl}
+
+After approving access, Mixcloud returns to the Fluncle admin callback and stores the access token server-side.`);
 }
-function buildCompleteXml(parts) {
-  const ordered = [...parts].sort((a, b) => a.partNumber - b.partNumber);
-  const body = ordered.map((part) => `<Part><PartNumber>${part.partNumber}</PartNumber><ETag>${escapeXml(part.etag)}</ETag></Part>`).join("");
-  return `<CompleteMultipartUpload>${body}</CompleteMultipartUpload>`;
+function mixtapeDescription(note, logId) {
+  const breadcrumb = `fluncle://${logId}`;
+  const body = (note ?? "").trim();
+  const full = body ? `${body}
+
+${breadcrumb}` : breadcrumb;
+  if (full.length <= DESCRIPTION_MAX) {
+    return full;
+  }
+  const room = DESCRIPTION_MAX - (breadcrumb.length + 2);
+  const trimmedNote = body.slice(0, Math.max(room, 0)).trimEnd();
+  return trimmedNote ? `${trimmedNote}
+
+${breadcrumb}` : breadcrumb;
 }
-function renditionFfmpegArgs(inputPath, outputPath) {
-  return [
-    "-y",
-    "-i",
-    inputPath,
-    "-vf",
-    `scale=-2:${SET_VIDEO_RENDITION.height}`,
-    "-c:v",
-    "libx264",
-    "-preset",
-    "medium",
-    "-crf",
-    String(SET_VIDEO_RENDITION.crf),
-    "-force_key_frames",
-    `expr:gte(t,n_forced*${SET_VIDEO_RENDITION.gopSeconds})`,
-    "-pix_fmt",
-    "yuv420p",
-    "-c:a",
-    "aac",
-    "-b:a",
-    SET_VIDEO_RENDITION.audioBitrate,
+function mixcloudSections(members) {
+  return members.filter((member) => typeof member.startMs === "number").sort((a, b) => a.startMs - b.startMs).map((member) => ({
+    artist: member.artists.join(", "),
+    song: member.title,
+    start_time: Math.floor(member.startMs / 1000)
+  }));
+}
+function mixtapeTags(_mixtape) {
+  return ["Drum & Bass", "Fluncle"];
+}
+async function fetchMixcloudToken() {
+  try {
+    const response = await adminApiPost("/api/admin/mixcloud/token");
+    return response.accessToken;
+  } catch {
+    throw new CliError2("mixcloud_not_connected", "Mixcloud is not connected. Run `fluncle admin auth mixcloud` to authorize it.");
+  }
+}
+async function fetchCover(logId) {
+  for (const size of ["square", "og"]) {
+    const response = await fetch(`${COVER_BASE}/${encodeURIComponent(logId)}?size=${size}`);
+    if (!response.ok) {
+      continue;
+    }
+    const blob = await response.blob();
+    if (blob.size <= PICTURE_MAX_BYTES) {
+      return blob;
+    }
+  }
+  return;
+}
+function parseUploadResult(body) {
+  try {
+    const data = JSON.parse(body);
+    return {
+      key: data.result?.key,
+      message: data.result?.message,
+      success: data.result?.success === true
+    };
+  } catch {
+    return { message: body.slice(0, 300), success: false };
+  }
+}
+function throwMixcloudError(status, body) {
+  if (body.includes("An invalid access token was provided")) {
+    throw new CliError2("mixcloud_invalid_token", "Mixcloud rejected the access token. Re-auth with `fluncle admin auth mixcloud`.");
+  }
+  throw new CliError2("mixcloud_request_failed", `Mixcloud responded ${status}${body ? `: ${body.slice(0, 300)}` : ""}`);
+}
+var MIXCLOUD_API = "https://api.mixcloud.com", DESCRIPTION_MAX = 1000, PICTURE_MAX_BYTES, COVER_BASE = "https://www.fluncle.com/api/mixtape-cover";
+var init_mixtape_mixcloud = __esm(() => {
+  init_api();
+  init_output();
+  init_mixtape_api();
+  PICTURE_MAX_BYTES = 10 * 1024 * 1024;
+});
+
+// src/commands/mixtape-set-video.ts
+var exports_mixtape_set_video = {};
+__export(exports_mixtape_set_video, {
+  stageSetVideo: () => stageSetVideo,
+  renditionFfmpegArgs: () => renditionFfmpegArgs,
+  planMultipart: () => planMultipart,
+  buildCompleteXml: () => buildCompleteXml,
+  SET_VIDEO_RENDITION: () => SET_VIDEO_RENDITION,
+  MIN_PART_SIZE: () => MIN_PART_SIZE,
+  MAX_PARTS: () => MAX_PARTS,
+  DEFAULT_PART_SIZE: () => DEFAULT_PART_SIZE
+});
+import { randomUUID } from "node:crypto";
+import { existsSync, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join4 } from "node:path";
+function planMultipart(contentLength, partSize = DEFAULT_PART_SIZE) {
+  if (!Number.isInteger(contentLength) || contentLength <= 0) {
+    throw new CliError2("invalid_size", `The rendition size must be a positive integer (got ${contentLength})`);
+  }
+  let effective = Math.max(partSize, MIN_PART_SIZE);
+  if (Math.ceil(contentLength / effective) > MAX_PARTS) {
+    effective = Math.ceil(contentLength / MAX_PARTS);
+  }
+  const parts = [];
+  let start = 0;
+  let partNumber = 1;
+  while (start < contentLength) {
+    const end = Math.min(start + effective, contentLength);
+    parts.push({ end, partNumber, size: end - start, start });
+    start = end;
+    partNumber += 1;
+  }
+  return { partCount: parts.length, partSize: effective, parts };
+}
+function escapeXml(value) {
+  return value.replace(/[<>&'"]/g, (char) => ({ '"': "&quot;", "&": "&amp;", "'": "&apos;", "<": "&lt;", ">": "&gt;" })[char] ?? char);
+}
+function buildCompleteXml(parts) {
+  const ordered = [...parts].sort((a, b) => a.partNumber - b.partNumber);
+  const body = ordered.map((part) => `<Part><PartNumber>${part.partNumber}</PartNumber><ETag>${escapeXml(part.etag)}</ETag></Part>`).join("");
+  return `<CompleteMultipartUpload>${body}</CompleteMultipartUpload>`;
+}
+function renditionFfmpegArgs(inputPath, outputPath) {
+  return [
+    "-y",
+    "-i",
+    inputPath,
+    "-vf",
+    `scale=-2:${SET_VIDEO_RENDITION.height}`,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "medium",
+    "-crf",
+    String(SET_VIDEO_RENDITION.crf),
+    "-force_key_frames",
+    `expr:gte(t,n_forced*${SET_VIDEO_RENDITION.gopSeconds})`,
+    "-pix_fmt",
+    "yuv420p",
+    "-c:a",
+    "aac",
+    "-b:a",
+    SET_VIDEO_RENDITION.audioBitrate,
     "-movflags",
     "+faststart",
     outputPath
@@ -1159,517 +1425,104 @@ async function putPart(url, path2, part) {
     method: "PUT"
   });
   if (!response.ok) {
-    const detail = (await response.text().catch(() => "")).slice(0, 300);
-    throw new CliError2("r2_part_failed", `R2 rejected part ${part.partNumber} (${response.status} ${response.statusText})${detail ? `: ${detail}` : ""}`);
-  }
-  const etag = response.headers.get("etag");
-  if (!etag) {
-    throw new CliError2("r2_no_etag", `R2 returned no ETag for part ${part.partNumber}`);
-  }
-  return etag;
-}
-async function completeUpload(url, parts) {
-  const response = await fetch(url, {
-    body: buildCompleteXml(parts),
-    headers: { "content-type": "application/xml" },
-    method: "POST"
-  });
-  const text = await response.text().catch(() => "");
-  if (!response.ok || text.includes("<Error>")) {
-    throw new CliError2("r2_complete_failed", `R2 CompleteMultipartUpload failed (${response.status} ${response.statusText})${text ? `: ${text.slice(0, 300)}` : ""}`);
-  }
-}
-async function abortUpload(url) {
-  await fetch(url, { method: "DELETE" });
-}
-async function assertFfmpeg() {
-  try {
-    const proc = Bun.spawn(["ffmpeg", "-version"], { stderr: "ignore", stdout: "ignore" });
-    await proc.exited;
-    if (proc.exitCode !== 0) {
-      throw new Error("ffmpeg -version exited non-zero");
-    }
-  } catch {
-    throw new CliError2("ffmpeg_missing", "--set-video needs ffmpeg to derive the 1080p rendition. Install it (brew install ffmpeg).");
-  }
-}
-async function deriveRendition(inputPath, outputPath) {
-  const proc = Bun.spawn(["ffmpeg", ...renditionFfmpegArgs(inputPath, outputPath)], {
-    stderr: "pipe",
-    stdout: "ignore"
-  });
-  await proc.exited;
-  if (proc.exitCode !== 0) {
-    const detail = (await new Response(proc.stderr).text().catch(() => "")).slice(-400);
-    throw new CliError2("ffmpeg_failed", `ffmpeg failed to derive the set-video rendition${detail ? `: ${detail}` : ""}`);
-  }
-}
-var FOUND_BASE = "https://found.fluncle.com", SET_VIDEO_RENDITION, DEFAULT_PART_SIZE, MIN_PART_SIZE, MAX_PARTS = 1e4;
-var init_mixtape_set_video = __esm(() => {
-  init_api();
-  init_output();
-  SET_VIDEO_RENDITION = {
-    audioBitrate: "192k",
-    crf: 20,
-    gopSeconds: 2,
-    height: 1080
-  };
-  DEFAULT_PART_SIZE = 100 * 1024 * 1024;
-  MIN_PART_SIZE = 5 * 1024 * 1024;
-});
-
-// src/commands/mixtapes.ts
-var exports_mixtapes = {};
-__export(exports_mixtapes, {
-  mixtapesCommand: () => mixtapesCommand,
-  mixtapeUpdateCommand: () => mixtapeUpdateCommand,
-  mixtapePublishCommand: () => mixtapePublishCommand,
-  mixtapeMembersCommand: () => mixtapeMembersCommand,
-  mixtapeListCommand: () => mixtapeListCommand,
-  mixtapeGetCommand: () => mixtapeGetCommand,
-  mixtapeDistributeCommand: () => mixtapeDistributeCommand,
-  mixtapeDeleteCommand: () => mixtapeDeleteCommand,
-  mixtapeCreateCommand: () => mixtapeCreateCommand
-});
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-async function mixtapesCommand() {
-  const response = await publicApiGet("/api/mixtapes");
-  return response.mixtapes;
-}
-async function mixtapeCreateCommand(options) {
-  return adminApiPost("/api/admin/mixtapes", buildBody(options));
-}
-async function mixtapeUpdateCommand(id, options) {
-  return adminApiPatch(`/api/admin/mixtapes/${encodeURIComponent(id)}`, buildBody(options));
-}
-async function mixtapeMembersCommand(id, refs, options) {
-  const members = refs.map((ref) => ({ ref }));
-  if (options.from) {
-    members.push(...parseCueFile(options.from));
-  }
-  return adminApiPut(`/api/admin/mixtapes/${encodeURIComponent(id)}/members`, { members });
-}
-async function mixtapePublishCommand(id) {
-  return adminApiPost(`/api/admin/mixtapes/${encodeURIComponent(id)}/publish`);
-}
-async function mixtapeDeleteCommand(id) {
-  return adminApiDelete(`/api/admin/mixtapes/${encodeURIComponent(id)}`);
-}
-async function mixtapeListCommand() {
-  const response = await adminApiGet("/api/admin/mixtapes");
-  return response.mixtapes;
-}
-async function mixtapeGetCommand(idOrLogId) {
-  const mixtapes = await mixtapeListCommand();
-  const match = mixtapes.find((mixtape) => mixtape.id === idOrLogId || mixtape.logId === idOrLogId);
-  if (!match) {
-    throw new CliError2("mixtape_not_found", `No mixtape with id or log id ${idOrLogId}`);
-  }
-  return match;
-}
-async function mixtapeDistributeCommand(idOrLogId, options, onProgress = () => {}) {
-  const mixtape = await mixtapeGetCommand(idOrLogId);
-  if (!mixtape.id) {
-    throw new CliError2("mixtape_not_found", `No mixtape with id or log id ${idOrLogId}`);
-  }
-  const both = !options.youtube && !options.mixcloud && !options.setVideo;
-  const doYoutube = both || Boolean(options.youtube);
-  const doMixcloud = both || Boolean(options.mixcloud);
-  const doSetVideo = Boolean(options.setVideo);
-  if (doYoutube && !options.video) {
-    throw new CliError2("missing_video", "YouTube distribution needs --video <mp4>");
-  }
-  if (doMixcloud && !options.audio) {
-    throw new CliError2("missing_audio", "Mixcloud distribution needs --audio <file>");
-  }
-  if (doSetVideo && !options.video) {
-    throw new CliError2("missing_video", "--set-video needs --video <master.mp4>");
-  }
-  const mixtapeId = mixtape.id;
-  let logId = mixtape.logId;
-  if (!mixtape.durationMs) {
-    const source = options.audio ?? options.video;
-    const durationMs = source ? await probeDurationMs(source) : undefined;
-    if (durationMs) {
-      await mixtapeUpdateCommand(mixtapeId, { durationMs: String(durationMs), json: false });
-      onProgress(`Duration: ${Math.round(durationMs / 60000)} min (from the upload).`);
-    }
-  }
-  if (mixtape.status === "draft") {
-    onProgress("Minting the coordinate…");
-    const published = await mixtapePublishCommand(mixtapeId);
-    logId = published.mixtape.logId;
-    onProgress(`Minted ${logId}.`);
-  } else if (mixtape.status === "published") {
-    onProgress(`Already published (${logId}); re-distributing.`);
-  } else {
-    onProgress(`Resuming distribution for ${logId}.`);
-  }
-  if (!logId) {
-    throw new CliError2("mint_failed", "The mixtape has no Log ID after minting");
-  }
-  const results = [];
-  if (doYoutube) {
-    if (!options.video) {
-      throw new CliError2("missing_video", "YouTube distribution needs --video <mp4>");
-    }
-    onProgress("YouTube: uploading video…");
-    const { distributeYoutube: distributeYoutube2 } = await Promise.resolve().then(() => (init_mixtape_youtube(), exports_mixtape_youtube));
-    const result = await distributeYoutube2(mixtapeId, options.video, onProgress);
-    results.push({ platform: "youtube", url: result.url });
-    onProgress(`YouTube: ${result.url}`);
-  }
-  if (doMixcloud) {
-    if (!options.audio) {
-      throw new CliError2("missing_audio", "Mixcloud distribution needs --audio <file>");
-    }
-    onProgress("Mixcloud: uploading audio…");
-    const { distributeMixcloud } = await Promise.resolve().then(() => (init_mixtape_mixcloud(), exports_mixtape_mixcloud));
-    const result = await distributeMixcloud(mixtapeId, options.audio, onProgress, options.unlisted);
-    results.push({ platform: "mixcloud", url: result.url });
-    onProgress(`Mixcloud: ${result.url}`);
-  }
-  if (doSetVideo) {
-    if (!options.video) {
-      throw new CliError2("missing_video", "--set-video needs --video <master.mp4>");
-    }
-    onProgress("Set video: staging the 1080p rendition…");
-    const { stageSetVideo: stageSetVideo2 } = await Promise.resolve().then(() => (init_mixtape_set_video(), exports_mixtape_set_video));
-    const result = await stageSetVideo2(mixtapeId, options.video, onProgress);
-    results.push({ platform: "set-video", url: result.url });
-    onProgress(`Set video: ${result.url}`);
-  }
-  return { logId, mixtapeId, results };
-}
-async function probeDurationMs(filePath) {
-  try {
-    const proc = Bun.spawn(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", filePath], { stderr: "ignore", stdout: "pipe" });
-    const out = await new Response(proc.stdout).text();
-    await proc.exited;
-    const seconds = Number.parseFloat(out.trim());
-    return Number.isFinite(seconds) && seconds > 0 ? Math.round(seconds * 1000) : undefined;
-  } catch {
-    return;
-  }
-}
-function buildBody(options) {
-  const body = {};
-  if (options.note !== undefined) {
-    body.note = options.note;
-  }
-  if (options.recordedAt !== undefined) {
-    body.recordedAt = options.recordedAt;
-  }
-  if (options.soundcloudUrl !== undefined) {
-    body.soundcloudUrl = options.soundcloudUrl;
-  }
-  if (options.durationMs !== undefined) {
-    const parsed = parseDuration(options.durationMs);
-    if (parsed === null) {
-      throw new CliError2("invalid_duration", "Duration must be mm:ss or h:mm:ss, or a millisecond count");
-    }
-    body.durationMs = parsed;
-  }
-  return body;
-}
-function parseCueFile(filePath) {
-  if (!existsSync2(filePath)) {
-    throw new CliError2("file_not_found", `Cue file not found: ${filePath}`);
-  }
-  const text = readFileSync2(filePath, "utf-8");
-  const trimmed = text.trim();
-  if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (!Array.isArray(parsed)) {
-        throw new Error("not an array");
-      }
-      return parsed.map((entry, index) => {
-        if (typeof entry === "string") {
-          return { ref: entry.trim() };
-        }
-        const obj = entry;
-        if (typeof obj?.ref !== "string") {
-          throw new CliError2("invalid_cue_json", `Entry ${index + 1} missing "ref" string`);
-        }
-        const cue = { ref: obj.ref.trim() };
-        if (typeof obj.startMs === "number" && Number.isInteger(obj.startMs) && obj.startMs >= 0) {
-          cue.startMs = obj.startMs;
-        }
-        return cue;
-      });
-    } catch (error) {
-      if (error instanceof CliError2) {
-        throw error;
-      }
-      throw new CliError2("invalid_cue_json", `Cue JSON parse failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  return parseCueSheet(text);
-}
-function parseCueSheet(text) {
-  const entries = [];
-  for (const line of text.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      continue;
-    }
-    const match = trimmed.match(/^(\d{1,2}:\d{2}(?::\d{2})?)\s+(.+)$/);
-    if (match) {
-      const [, time, ref] = match;
-      if (time === undefined || ref === undefined) {
-        continue;
-      }
-      const startMs = parseDuration(time);
-      if (startMs === null) {
-        continue;
-      }
-      entries.push({ ref: ref.trim(), startMs });
-    } else {
-      entries.push({ ref: trimmed });
-    }
-  }
-  return entries;
-}
-function parseDuration(input) {
-  const trimmed = input.trim();
-  if (!trimmed) {
-    return null;
-  }
-  if (trimmed.includes(":")) {
-    const parts = trimmed.split(":");
-    if (parts.length !== 2 && parts.length !== 3) {
-      return null;
-    }
-    const nums = parts.map((part) => Number(part));
-    if (nums.some((n) => !Number.isFinite(n) || n < 0)) {
-      return null;
-    }
-    if (parts.length === 3) {
-      const [hours, minutes2, seconds2] = nums;
-      if (hours === undefined || minutes2 === undefined || seconds2 === undefined) {
-        return null;
-      }
-      if (minutes2 >= 60 || seconds2 >= 60) {
-        return null;
-      }
-      return Math.round((hours * 3600 + minutes2 * 60 + seconds2) * 1000);
-    }
-    const [minutes, seconds] = nums;
-    if (minutes === undefined || seconds === undefined) {
-      return null;
-    }
-    if (seconds >= 60) {
-      return null;
-    }
-    return Math.round((minutes * 60 + seconds) * 1000);
-  }
-  const value = Number(trimmed);
-  return Number.isFinite(value) && value >= 0 ? value : null;
-}
-var init_mixtapes = __esm(() => {
-  init_api();
-  init_output();
-});
-
-// src/commands/mixtape-mixcloud.ts
-var exports_mixtape_mixcloud = {};
-__export(exports_mixtape_mixcloud, {
-  mixtapeDescription: () => mixtapeDescription,
-  mixcloudSections: () => mixcloudSections,
-  distributeMixcloud: () => distributeMixcloud,
-  authMixcloudCommand: () => authMixcloudCommand
-});
-async function distributeMixcloud(mixtapeId, audioPath, onProgress, unlisted = false) {
-  const token = await fetchMixcloudToken();
-  const mixtape = await mixtapeGetCommand(mixtapeId);
-  const logId = mixtape.logId;
-  if (!logId) {
-    throw new CliError2("mixtape_no_log_id", "The mixtape has no Log ID; mint it before distributing");
-  }
-  const audio = Bun.file(audioPath);
-  if (!await audio.exists()) {
-    throw new CliError2("audio_not_found", `Audio master not found: ${audioPath}`);
-  }
-  const form = new FormData;
-  form.append("mp3", audio);
-  form.append("name", mixtape.title);
-  form.append("description", mixtapeDescription(mixtape.note, logId));
-  onProgress?.("Mixcloud: fetching the cover…");
-  const picture = await fetchCover(logId);
-  if (picture) {
-    form.append("picture", picture, "cover.png");
-  }
-  for (const [index, tag] of mixtapeTags(mixtape).entries()) {
-    form.append(`tags-${index}-tag`, tag);
-  }
-  const sections = mixcloudSections(mixtape.members);
-  for (const [index, section] of sections.entries()) {
-    form.append(`sections-${index}-artist`, section.artist);
-    form.append(`sections-${index}-song`, section.song);
-    form.append(`sections-${index}-start_time`, String(section.start_time));
-  }
-  if (unlisted) {
-    form.append("unlisted", "1");
-    onProgress?.("Mixcloud: uploading UNLISTED (private).");
-  }
-  const cuelessCount = mixtape.members.length - sections.length;
-  if (cuelessCount > 0) {
-    onProgress?.(`Mixcloud: ${cuelessCount} of ${mixtape.members.length} members have no cue (omitted from sections).`);
-  }
-  onProgress?.("Mixcloud: uploading the master…");
-  const uploadResponse = await fetch(`${MIXCLOUD_API}/upload/?access_token=${encodeURIComponent(token)}`, {
-    body: form,
-    method: "POST"
-  });
-  const uploadText = await uploadResponse.text();
-  if (!uploadResponse.ok) {
-    throwMixcloudError(uploadResponse.status, uploadText);
-  }
-  const result = parseUploadResult(uploadText);
-  if (!result.success || !result.key) {
-    throw new CliError2("mixcloud_upload_rejected", `Mixcloud rejected the upload: ${result.message ?? uploadText.slice(0, 300)}`);
-  }
-  const externalId = result.key;
-  const url = `https://www.mixcloud.com${result.key}`;
-  onProgress?.("Mixcloud: recording the link…");
-  await adminApiPost(`/api/admin/mixtapes/${encodeURIComponent(mixtapeId)}/mixcloud/finalize`, {
-    externalId,
-    url
-  });
-  return { url };
-}
-async function authMixcloudCommand() {
-  const response = await adminApiGet("/api/admin/mixcloud/auth/start");
-  console.log(`Open this Mixcloud authorization URL:
-
-${response.authUrl}
-
-After approving access, Mixcloud returns to the Fluncle admin callback and stores the access token server-side.`);
-}
-function mixtapeDescription(note, logId) {
-  const breadcrumb = `fluncle://${logId}`;
-  const body = (note ?? "").trim();
-  const full = body ? `${body}
-
-${breadcrumb}` : breadcrumb;
-  if (full.length <= DESCRIPTION_MAX) {
-    return full;
-  }
-  const room = DESCRIPTION_MAX - (breadcrumb.length + 2);
-  const trimmedNote = body.slice(0, Math.max(room, 0)).trimEnd();
-  return trimmedNote ? `${trimmedNote}
-
-${breadcrumb}` : breadcrumb;
-}
-function mixcloudSections(members) {
-  return members.filter((member) => typeof member.startMs === "number").sort((a, b) => a.startMs - b.startMs).map((member) => ({
-    artist: member.artists.join(", "),
-    song: member.title,
-    start_time: Math.floor(member.startMs / 1000)
-  }));
-}
-function mixtapeTags(_mixtape) {
-  return ["Drum & Bass", "Fluncle"];
-}
-async function fetchMixcloudToken() {
-  try {
-    const response = await adminApiPost("/api/admin/mixcloud/token");
-    return response.accessToken;
-  } catch {
-    throw new CliError2("mixcloud_not_connected", "Mixcloud is not connected. Run `fluncle admin auth mixcloud` to authorize it.");
+    const detail = (await response.text().catch(() => "")).slice(0, 300);
+    throw new CliError2("r2_part_failed", `R2 rejected part ${part.partNumber} (${response.status} ${response.statusText})${detail ? `: ${detail}` : ""}`);
+  }
+  const etag = response.headers.get("etag");
+  if (!etag) {
+    throw new CliError2("r2_no_etag", `R2 returned no ETag for part ${part.partNumber}`);
   }
+  return etag;
 }
-async function fetchCover(logId) {
-  for (const size of ["square", "og"]) {
-    const response = await fetch(`${COVER_BASE}/${encodeURIComponent(logId)}?size=${size}`);
-    if (!response.ok) {
-      continue;
-    }
-    const blob = await response.blob();
-    if (blob.size <= PICTURE_MAX_BYTES) {
-      return blob;
-    }
+async function completeUpload(url, parts) {
+  const response = await fetch(url, {
+    body: buildCompleteXml(parts),
+    headers: { "content-type": "application/xml" },
+    method: "POST"
+  });
+  const text = await response.text().catch(() => "");
+  if (!response.ok || text.includes("<Error>")) {
+    throw new CliError2("r2_complete_failed", `R2 CompleteMultipartUpload failed (${response.status} ${response.statusText})${text ? `: ${text.slice(0, 300)}` : ""}`);
   }
-  return;
 }
-function parseUploadResult(body) {
+async function abortUpload(url) {
+  await fetch(url, { method: "DELETE" });
+}
+async function assertFfmpeg() {
   try {
-    const data = JSON.parse(body);
-    return {
-      key: data.result?.key,
-      message: data.result?.message,
-      success: data.result?.success === true
-    };
+    const proc = Bun.spawn(["ffmpeg", "-version"], { stderr: "ignore", stdout: "ignore" });
+    await proc.exited;
+    if (proc.exitCode !== 0) {
+      throw new Error("ffmpeg -version exited non-zero");
+    }
   } catch {
-    return { message: body.slice(0, 300), success: false };
+    throw new CliError2("ffmpeg_missing", "--set-video needs ffmpeg to derive the 1080p rendition. Install it (brew install ffmpeg).");
   }
 }
-function throwMixcloudError(status, body) {
-  if (body.includes("An invalid access token was provided")) {
-    throw new CliError2("mixcloud_invalid_token", "Mixcloud rejected the access token. Re-auth with `fluncle admin auth mixcloud`.");
+async function deriveRendition(inputPath, outputPath) {
+  const proc = Bun.spawn(["ffmpeg", ...renditionFfmpegArgs(inputPath, outputPath)], {
+    stderr: "pipe",
+    stdout: "ignore"
+  });
+  await proc.exited;
+  if (proc.exitCode !== 0) {
+    const detail = (await new Response(proc.stderr).text().catch(() => "")).slice(-400);
+    throw new CliError2("ffmpeg_failed", `ffmpeg failed to derive the set-video rendition${detail ? `: ${detail}` : ""}`);
   }
-  throw new CliError2("mixcloud_request_failed", `Mixcloud responded ${status}${body ? `: ${body.slice(0, 300)}` : ""}`);
 }
-var MIXCLOUD_API = "https://api.mixcloud.com", DESCRIPTION_MAX = 1000, PICTURE_MAX_BYTES, COVER_BASE = "https://www.fluncle.com/api/mixtape-cover";
-var init_mixtape_mixcloud = __esm(() => {
+var FOUND_BASE = "https://found.fluncle.com", SET_VIDEO_RENDITION, DEFAULT_PART_SIZE, MIN_PART_SIZE, MAX_PARTS = 1e4;
+var init_mixtape_set_video = __esm(() => {
   init_api();
   init_output();
-  init_mixtapes();
-  PICTURE_MAX_BYTES = 10 * 1024 * 1024;
+  SET_VIDEO_RENDITION = {
+    audioBitrate: "192k",
+    crf: 20,
+    gopSeconds: 2,
+    height: 1080
+  };
+  DEFAULT_PART_SIZE = 100 * 1024 * 1024;
+  MIN_PART_SIZE = 5 * 1024 * 1024;
 });
 
 // src/commands/mixtapes.ts
-var exports_mixtapes2 = {};
-__export(exports_mixtapes2, {
-  mixtapesCommand: () => mixtapesCommand2,
-  mixtapeUpdateCommand: () => mixtapeUpdateCommand2,
-  mixtapePublishCommand: () => mixtapePublishCommand2,
-  mixtapeMembersCommand: () => mixtapeMembersCommand2,
-  mixtapeListCommand: () => mixtapeListCommand2,
-  mixtapeGetCommand: () => mixtapeGetCommand2,
-  mixtapeDistributeCommand: () => mixtapeDistributeCommand2,
-  mixtapeDeleteCommand: () => mixtapeDeleteCommand2,
-  mixtapeCreateCommand: () => mixtapeCreateCommand2
+var exports_mixtapes = {};
+__export(exports_mixtapes, {
+  mixtapesCommand: () => mixtapesCommand,
+  mixtapeUpdateCommand: () => mixtapeUpdateCommand,
+  mixtapePublishCommand: () => mixtapePublishCommand,
+  mixtapeMembersCommand: () => mixtapeMembersCommand,
+  mixtapeListCommand: () => mixtapeListCommand,
+  mixtapeGetCommand: () => mixtapeGetCommand,
+  mixtapeDistributeCommand: () => mixtapeDistributeCommand,
+  mixtapeDeleteCommand: () => mixtapeDeleteCommand,
+  mixtapeCreateCommand: () => mixtapeCreateCommand
 });
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-async function mixtapesCommand2() {
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+async function mixtapesCommand() {
   const response = await publicApiGet("/api/mixtapes");
   return response.mixtapes;
 }
-async function mixtapeCreateCommand2(options) {
-  return adminApiPost("/api/admin/mixtapes", buildBody2(options));
+async function mixtapeCreateCommand(options) {
+  return adminApiPost("/api/admin/mixtapes", buildBody(options));
 }
-async function mixtapeUpdateCommand2(id, options) {
-  return adminApiPatch(`/api/admin/mixtapes/${encodeURIComponent(id)}`, buildBody2(options));
+async function mixtapeUpdateCommand(id, options) {
+  return adminApiPatch(`/api/admin/mixtapes/${encodeURIComponent(id)}`, buildBody(options));
 }
-async function mixtapeMembersCommand2(id, refs, options) {
+async function mixtapeMembersCommand(id, refs, options) {
   const members = refs.map((ref) => ({ ref }));
   if (options.from) {
-    members.push(...parseCueFile2(options.from));
+    members.push(...parseCueFile(options.from));
   }
   return adminApiPut(`/api/admin/mixtapes/${encodeURIComponent(id)}/members`, { members });
 }
-async function mixtapePublishCommand2(id) {
+async function mixtapePublishCommand(id) {
   return adminApiPost(`/api/admin/mixtapes/${encodeURIComponent(id)}/publish`);
 }
-async function mixtapeDeleteCommand2(id) {
+async function mixtapeDeleteCommand(id) {
   return adminApiDelete(`/api/admin/mixtapes/${encodeURIComponent(id)}`);
 }
-async function mixtapeListCommand2() {
-  const response = await adminApiGet("/api/admin/mixtapes");
-  return response.mixtapes;
-}
-async function mixtapeGetCommand2(idOrLogId) {
-  const mixtapes = await mixtapeListCommand2();
-  const match = mixtapes.find((mixtape) => mixtape.id === idOrLogId || mixtape.logId === idOrLogId);
-  if (!match) {
-    throw new CliError2("mixtape_not_found", `No mixtape with id or log id ${idOrLogId}`);
-  }
-  return match;
-}
-async function mixtapeDistributeCommand2(idOrLogId, options, onProgress = () => {}) {
-  const mixtape = await mixtapeGetCommand2(idOrLogId);
+async function mixtapeDistributeCommand(idOrLogId, options, onProgress = () => {}) {
+  const mixtape = await mixtapeGetCommand(idOrLogId);
   if (!mixtape.id) {
     throw new CliError2("mixtape_not_found", `No mixtape with id or log id ${idOrLogId}`);
   }
@@ -1690,15 +1543,15 @@ async function mixtapeDistributeCommand2(idOrLogId, options, onProgress = () =>
   let logId = mixtape.logId;
   if (!mixtape.durationMs) {
     const source = options.audio ?? options.video;
-    const durationMs = source ? await probeDurationMs2(source) : undefined;
+    const durationMs = source ? await probeDurationMs(source) : undefined;
     if (durationMs) {
-      await mixtapeUpdateCommand2(mixtapeId, { durationMs: String(durationMs), json: false });
+      await mixtapeUpdateCommand(mixtapeId, { durationMs: String(durationMs), json: false });
       onProgress(`Duration: ${Math.round(durationMs / 60000)} min (from the upload).`);
     }
   }
   if (mixtape.status === "draft") {
     onProgress("Minting the coordinate…");
-    const published = await mixtapePublishCommand2(mixtapeId);
+    const published = await mixtapePublishCommand(mixtapeId);
     logId = published.mixtape.logId;
     onProgress(`Minted ${logId}.`);
   } else if (mixtape.status === "published") {
@@ -1742,7 +1595,7 @@ async function mixtapeDistributeCommand2(idOrLogId, options, onProgress = () =>
   }
   return { logId, mixtapeId, results };
 }
-async function probeDurationMs2(filePath) {
+async function probeDurationMs(filePath) {
   try {
     const proc = Bun.spawn(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", filePath], { stderr: "ignore", stdout: "pipe" });
     const out = await new Response(proc.stdout).text();
@@ -1753,7 +1606,7 @@ async function probeDurationMs2(filePath) {
     return;
   }
 }
-function buildBody2(options) {
+function buildBody(options) {
   const body = {};
   if (options.note !== undefined) {
     body.note = options.note;
@@ -1765,7 +1618,7 @@ function buildBody2(options) {
     body.soundcloudUrl = options.soundcloudUrl;
   }
   if (options.durationMs !== undefined) {
-    const parsed = parseDuration2(options.durationMs);
+    const parsed = parseDuration(options.durationMs);
     if (parsed === null) {
       throw new CliError2("invalid_duration", "Duration must be mm:ss or h:mm:ss, or a millisecond count");
     }
@@ -1773,11 +1626,11 @@ function buildBody2(options) {
   }
   return body;
 }
-function parseCueFile2(filePath) {
-  if (!existsSync3(filePath)) {
+function parseCueFile(filePath) {
+  if (!existsSync2(filePath)) {
     throw new CliError2("file_not_found", `Cue file not found: ${filePath}`);
   }
-  const text = readFileSync3(filePath, "utf-8");
+  const text = readFileSync2(filePath, "utf-8");
   const trimmed = text.trim();
   if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
     try {
@@ -1806,9 +1659,9 @@ function parseCueFile2(filePath) {
       throw new CliError2("invalid_cue_json", `Cue JSON parse failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  return parseCueSheet2(text);
+  return parseCueSheet(text);
 }
-function parseCueSheet2(text) {
+function parseCueSheet(text) {
   const entries = [];
   for (const line of text.split(/\r?\n/)) {
     const trimmed = line.trim();
@@ -1821,7 +1674,7 @@ function parseCueSheet2(text) {
       if (time === undefined || ref === undefined) {
         continue;
       }
-      const startMs = parseDuration2(time);
+      const startMs = parseDuration(time);
       if (startMs === null) {
         continue;
       }
@@ -1832,44 +1685,10 @@ function parseCueSheet2(text) {
   }
   return entries;
 }
-function parseDuration2(input) {
-  const trimmed = input.trim();
-  if (!trimmed) {
-    return null;
-  }
-  if (trimmed.includes(":")) {
-    const parts = trimmed.split(":");
-    if (parts.length !== 2 && parts.length !== 3) {
-      return null;
-    }
-    const nums = parts.map((part) => Number(part));
-    if (nums.some((n) => !Number.isFinite(n) || n < 0)) {
-      return null;
-    }
-    if (parts.length === 3) {
-      const [hours, minutes2, seconds2] = nums;
-      if (hours === undefined || minutes2 === undefined || seconds2 === undefined) {
-        return null;
-      }
-      if (minutes2 >= 60 || seconds2 >= 60) {
-        return null;
-      }
-      return Math.round((hours * 3600 + minutes2 * 60 + seconds2) * 1000);
-    }
-    const [minutes, seconds] = nums;
-    if (minutes === undefined || seconds === undefined) {
-      return null;
-    }
-    if (seconds >= 60) {
-      return null;
-    }
-    return Math.round((minutes * 60 + seconds) * 1000);
-  }
-  const value = Number(trimmed);
-  return Number.isFinite(value) && value >= 0 ? value : null;
-}
-var init_mixtapes2 = __esm(() => {
+var init_mixtapes = __esm(() => {
+  init_util();
   init_api();
+  init_mixtape_api();
   init_output();
 });
 
@@ -1881,7 +1700,9 @@ function artistTitle(track) {
   return `${track.artists.join(", ")} — ${track.title}`;
 }
 var COORD_FALLBACK = "—";
-var init_format = () => {};
+var init_format = __esm(() => {
+  init_util();
+});
 
 // src/interactive.ts
 import { createInterface } from "node:readline/promises";
@@ -2388,12 +2209,13 @@ async function meCommand() {
   if (!me.user) {
     throw new Error("Your sign-in expired. Run `fluncle login` to link this device again.");
   }
+  const user = me.user;
   return {
     collectedCount: progress.collectedLogIds.length,
     deaths: progress.deaths,
-    joinedAt: me.user.createdAt,
-    name: me.user.displayUsername ?? me.user.username ?? "cosmonaut",
-    userId: me.user.id,
+    joinedAt: user.createdAt,
+    name: user.displayUsername ?? user.username ?? "cosmonaut",
+    userId: user.id,
     wins: progress.wins
   };
 }
@@ -2559,7 +2381,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.72.0".trim() ? "0.72.0".trim() : "0.1.0";
+  currentVersion2 = "0.74.0".trim() ? "0.74.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -3553,99 +3375,32 @@ async function noteQueueCommand(limit) {
 async function backfillLastfmCommand(limit, dryRun, cursor) {
   const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
   if (cursor) {
-    params.set("cursor", cursor);
-  }
-  return adminApiPost(`/api/admin/backfill/lastfm?${params.toString()}`);
-}
-async function backfillDiscogsCommand(limit, dryRun, cursor) {
-  const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
-  if (cursor) {
-    params.set("cursor", cursor);
-  }
-  return adminApiPost(`/api/admin/backfill/discogs?${params.toString()}`);
-}
-async function vehiclesCommand(limit) {
-  const tracks = await fetchAdminTracks({ hasVideo: true, max: limit, order: "desc" });
-  return tracks.map((track) => ({
-    addedAt: track.addedAt,
-    artists: track.artists,
-    grain: track.videoGrain,
-    logId: track.logId,
-    title: track.title,
-    vehicle: track.videoVehicle
-  }));
-}
-var pageSize3 = 48;
-var init_admin_tracks = __esm(() => {
-  init_api();
-  init_recent2();
-});
-
-// src/version-match.ts
-function isRemix(title) {
-  return REMIX_MARKER.test(title);
-}
-function stripVersionSuffix(title) {
-  const parts = title.split(/\s+-\s+/);
-  if (parts.length > 1 && VERSION_MARKER.test(parts[parts.length - 1] ?? "")) {
-    return parts.slice(0, -1).join(" - ").trim();
-  }
-  return title.trim();
-}
-function tokenize(value) {
-  return value.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, " ").trim().split(" ").filter(Boolean);
-}
-function versionTokens(title) {
-  const parts = title.split(/\s+-\s+/);
-  const tail = parts.length > 1 ? parts[parts.length - 1] ?? "" : "";
-  if (parts.length > 1 && VERSION_MARKER.test(tail)) {
-    return new Set(tokenize(tail));
-  }
-  const bracketed = /[([]([^)\]]*?)[)\]]/.exec(title);
-  if (bracketed?.[1] && VERSION_MARKER.test(bracketed[1])) {
-    return new Set(tokenize(bracketed[1]));
-  }
-  return new Set;
-}
-function versionMatches(findingTitle, candidateTitle) {
-  const findingIsRemix = isRemix(findingTitle);
-  const candidateIsRemix = isRemix(candidateTitle);
-  if (findingIsRemix) {
-    if (!candidateIsRemix) {
-      return false;
-    }
-    const want = [...versionTokens(findingTitle)].filter((t) => !VERSION_STOPWORDS.has(t));
-    if (want.length === 0) {
-      return true;
-    }
-    const have = versionTokens(candidateTitle);
-    for (const token of want) {
-      if (!have.has(token)) {
-        return false;
-      }
-    }
-    return true;
+    params.set("cursor", cursor);
   }
-  return !candidateIsRemix;
+  return adminApiPost(`/api/admin/backfill/lastfm?${params.toString()}`);
 }
-function baseTitleMatches(findingTitle, candidateTitle) {
-  const want = new Set(tokenize(stripVersionSuffix(findingTitle)));
-  const have = new Set(tokenize(stripVersionSuffix(candidateTitle)));
-  if (want.size === 0) {
-    return false;
-  }
-  for (const token of want) {
-    if (!have.has(token)) {
-      return false;
-    }
+async function backfillDiscogsCommand(limit, dryRun, cursor) {
+  const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
+  if (cursor) {
+    params.set("cursor", cursor);
   }
-  return true;
+  return adminApiPost(`/api/admin/backfill/discogs?${params.toString()}`);
 }
-var VERSION_MARKER, REMIX_MARKER, VERSION_STOPWORDS;
-var init_version_match = __esm(() => {
-  VERSION_MARKER = /\b(mix|edit|version|remix|dub|vip|bootleg|rework|re-?edit|flip|refix|remaster(?:ed)?|instrumental)\b/i;
-  REMIX_MARKER = /\b(remix|bootleg|vip|rework|re-?edit|flip|refix)\b/i;
-  VERSION_STOPWORDS = new Set(["mix", "the", "and", "feat", "ft", "edit", "version", "remix"]);
+async function vehiclesCommand(limit) {
+  const tracks = await fetchAdminTracks({ hasVideo: true, max: limit, order: "desc" });
+  return tracks.map((track) => ({
+    addedAt: track.addedAt,
+    artists: track.artists,
+    grain: track.videoGrain,
+    logId: track.logId,
+    title: track.title,
+    vehicle: track.videoVehicle
+  }));
+}
+var pageSize3 = 48;
+var init_admin_tracks = __esm(() => {
+  init_api();
+  init_recent2();
 });
 
 // src/commands/preview-archive.ts
@@ -3844,8 +3599,8 @@ function normalize(value) {
 }
 var DURATION_TOLERANCE_S = 5;
 var init_preview_archive = __esm(() => {
+  init_util();
   init_api();
-  init_version_match();
 });
 
 // src/commands/mixtape-youtube.ts
@@ -4008,6 +3763,214 @@ var init_mixtape_youtube2 = __esm(() => {
   init_output();
 });
 
+// src/commands/mixtapes.ts
+var exports_mixtapes2 = {};
+__export(exports_mixtapes2, {
+  mixtapesCommand: () => mixtapesCommand2,
+  mixtapeUpdateCommand: () => mixtapeUpdateCommand2,
+  mixtapePublishCommand: () => mixtapePublishCommand2,
+  mixtapeMembersCommand: () => mixtapeMembersCommand2,
+  mixtapeListCommand: () => mixtapeListCommand,
+  mixtapeGetCommand: () => mixtapeGetCommand,
+  mixtapeDistributeCommand: () => mixtapeDistributeCommand2,
+  mixtapeDeleteCommand: () => mixtapeDeleteCommand2,
+  mixtapeCreateCommand: () => mixtapeCreateCommand2
+});
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+async function mixtapesCommand2() {
+  const response = await publicApiGet("/api/mixtapes");
+  return response.mixtapes;
+}
+async function mixtapeCreateCommand2(options) {
+  return adminApiPost("/api/admin/mixtapes", buildBody2(options));
+}
+async function mixtapeUpdateCommand2(id, options) {
+  return adminApiPatch(`/api/admin/mixtapes/${encodeURIComponent(id)}`, buildBody2(options));
+}
+async function mixtapeMembersCommand2(id, refs, options) {
+  const members = refs.map((ref) => ({ ref }));
+  if (options.from) {
+    members.push(...parseCueFile2(options.from));
+  }
+  return adminApiPut(`/api/admin/mixtapes/${encodeURIComponent(id)}/members`, { members });
+}
+async function mixtapePublishCommand2(id) {
+  return adminApiPost(`/api/admin/mixtapes/${encodeURIComponent(id)}/publish`);
+}
+async function mixtapeDeleteCommand2(id) {
+  return adminApiDelete(`/api/admin/mixtapes/${encodeURIComponent(id)}`);
+}
+async function mixtapeDistributeCommand2(idOrLogId, options, onProgress = () => {}) {
+  const mixtape = await mixtapeGetCommand(idOrLogId);
+  if (!mixtape.id) {
+    throw new CliError2("mixtape_not_found", `No mixtape with id or log id ${idOrLogId}`);
+  }
+  const both = !options.youtube && !options.mixcloud && !options.setVideo;
+  const doYoutube = both || Boolean(options.youtube);
+  const doMixcloud = both || Boolean(options.mixcloud);
+  const doSetVideo = Boolean(options.setVideo);
+  if (doYoutube && !options.video) {
+    throw new CliError2("missing_video", "YouTube distribution needs --video <mp4>");
+  }
+  if (doMixcloud && !options.audio) {
+    throw new CliError2("missing_audio", "Mixcloud distribution needs --audio <file>");
+  }
+  if (doSetVideo && !options.video) {
+    throw new CliError2("missing_video", "--set-video needs --video <master.mp4>");
+  }
+  const mixtapeId = mixtape.id;
+  let logId = mixtape.logId;
+  if (!mixtape.durationMs) {
+    const source = options.audio ?? options.video;
+    const durationMs = source ? await probeDurationMs2(source) : undefined;
+    if (durationMs) {
+      await mixtapeUpdateCommand2(mixtapeId, { durationMs: String(durationMs), json: false });
+      onProgress(`Duration: ${Math.round(durationMs / 60000)} min (from the upload).`);
+    }
+  }
+  if (mixtape.status === "draft") {
+    onProgress("Minting the coordinate…");
+    const published = await mixtapePublishCommand2(mixtapeId);
+    logId = published.mixtape.logId;
+    onProgress(`Minted ${logId}.`);
+  } else if (mixtape.status === "published") {
+    onProgress(`Already published (${logId}); re-distributing.`);
+  } else {
+    onProgress(`Resuming distribution for ${logId}.`);
+  }
+  if (!logId) {
+    throw new CliError2("mint_failed", "The mixtape has no Log ID after minting");
+  }
+  const results = [];
+  if (doYoutube) {
+    if (!options.video) {
+      throw new CliError2("missing_video", "YouTube distribution needs --video <mp4>");
+    }
+    onProgress("YouTube: uploading video…");
+    const { distributeYoutube: distributeYoutube3 } = await Promise.resolve().then(() => (init_mixtape_youtube(), exports_mixtape_youtube));
+    const result = await distributeYoutube3(mixtapeId, options.video, onProgress);
+    results.push({ platform: "youtube", url: result.url });
+    onProgress(`YouTube: ${result.url}`);
+  }
+  if (doMixcloud) {
+    if (!options.audio) {
+      throw new CliError2("missing_audio", "Mixcloud distribution needs --audio <file>");
+    }
+    onProgress("Mixcloud: uploading audio…");
+    const { distributeMixcloud: distributeMixcloud2 } = await Promise.resolve().then(() => (init_mixtape_mixcloud(), exports_mixtape_mixcloud));
+    const result = await distributeMixcloud2(mixtapeId, options.audio, onProgress, options.unlisted);
+    results.push({ platform: "mixcloud", url: result.url });
+    onProgress(`Mixcloud: ${result.url}`);
+  }
+  if (doSetVideo) {
+    if (!options.video) {
+      throw new CliError2("missing_video", "--set-video needs --video <master.mp4>");
+    }
+    onProgress("Set video: staging the 1080p rendition…");
+    const { stageSetVideo: stageSetVideo2 } = await Promise.resolve().then(() => (init_mixtape_set_video(), exports_mixtape_set_video));
+    const result = await stageSetVideo2(mixtapeId, options.video, onProgress);
+    results.push({ platform: "set-video", url: result.url });
+    onProgress(`Set video: ${result.url}`);
+  }
+  return { logId, mixtapeId, results };
+}
+async function probeDurationMs2(filePath) {
+  try {
+    const proc = Bun.spawn(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", filePath], { stderr: "ignore", stdout: "pipe" });
+    const out = await new Response(proc.stdout).text();
+    await proc.exited;
+    const seconds = Number.parseFloat(out.trim());
+    return Number.isFinite(seconds) && seconds > 0 ? Math.round(seconds * 1000) : undefined;
+  } catch {
+    return;
+  }
+}
+function buildBody2(options) {
+  const body = {};
+  if (options.note !== undefined) {
+    body.note = options.note;
+  }
+  if (options.recordedAt !== undefined) {
+    body.recordedAt = options.recordedAt;
+  }
+  if (options.soundcloudUrl !== undefined) {
+    body.soundcloudUrl = options.soundcloudUrl;
+  }
+  if (options.durationMs !== undefined) {
+    const parsed = parseDuration(options.durationMs);
+    if (parsed === null) {
+      throw new CliError2("invalid_duration", "Duration must be mm:ss or h:mm:ss, or a millisecond count");
+    }
+    body.durationMs = parsed;
+  }
+  return body;
+}
+function parseCueFile2(filePath) {
+  if (!existsSync3(filePath)) {
+    throw new CliError2("file_not_found", `Cue file not found: ${filePath}`);
+  }
+  const text = readFileSync3(filePath, "utf-8");
+  const trimmed = text.trim();
+  if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!Array.isArray(parsed)) {
+        throw new Error("not an array");
+      }
+      return parsed.map((entry, index) => {
+        if (typeof entry === "string") {
+          return { ref: entry.trim() };
+        }
+        const obj = entry;
+        if (typeof obj?.ref !== "string") {
+          throw new CliError2("invalid_cue_json", `Entry ${index + 1} missing "ref" string`);
+        }
+        const cue = { ref: obj.ref.trim() };
+        if (typeof obj.startMs === "number" && Number.isInteger(obj.startMs) && obj.startMs >= 0) {
+          cue.startMs = obj.startMs;
+        }
+        return cue;
+      });
+    } catch (error) {
+      if (error instanceof CliError2) {
+        throw error;
+      }
+      throw new CliError2("invalid_cue_json", `Cue JSON parse failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return parseCueSheet2(text);
+}
+function parseCueSheet2(text) {
+  const entries = [];
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const match = trimmed.match(/^(\d{1,2}:\d{2}(?::\d{2})?)\s+(.+)$/);
+    if (match) {
+      const [, time, ref] = match;
+      if (time === undefined || ref === undefined) {
+        continue;
+      }
+      const startMs = parseDuration(time);
+      if (startMs === null) {
+        continue;
+      }
+      entries.push({ ref: ref.trim(), startMs });
+    } else {
+      entries.push({ ref: trimmed });
+    }
+  }
+  return entries;
+}
+var init_mixtapes2 = __esm(() => {
+  init_util();
+  init_api();
+  init_mixtape_api();
+  init_output();
+});
+
 // src/commands/clips.ts
 var exports_clips = {};
 __export(exports_clips, {
@@ -4102,8 +4065,8 @@ async function clipCutCommand(clipId, onProgress = () => {}) {
   if (!clip) {
     throw new CliError2("clip_not_found", `No clip with id ${clipId}`);
   }
-  const { mixtapeGetCommand: mixtapeGetCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
-  const mixtape = await mixtapeGetCommand3(clip.mixtapeId);
+  const { mixtapeGetCommand: mixtapeGetCommand2 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+  const mixtape = await mixtapeGetCommand2(clip.mixtapeId);
   if (!mixtape.logId) {
     throw new CliError2("mixtape_no_log_id", `Mixtape ${clip.mixtapeId} has no committed Log ID`);
   }
@@ -4544,7 +4507,7 @@ var MIXCLOUD_API2 = "https://api.mixcloud.com", DESCRIPTION_MAX2 = 1000, PICTURE
 var init_mixtape_mixcloud2 = __esm(() => {
   init_api();
   init_output();
-  init_mixtapes();
+  init_mixtape_api();
   PICTURE_MAX_BYTES2 = 10 * 1024 * 1024;
 });
 
@@ -4854,7 +4817,9 @@ function trackDetailLines(track) {
   return lines;
 }
 var COORD_FALLBACK2 = "—";
-var init_format2 = () => {};
+var init_format2 = __esm(() => {
+  init_util();
+});
 
 // src/cli.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
@@ -6966,6 +6931,10 @@ function toJsonFailure(error) {
     ok: false
   };
 }
+
+// src/retry.ts
+init_util();
+
 // src/cli.ts
 function createProgram() {
   const program2 = configureCommand(new Command);
@@ -7019,7 +6988,7 @@ function addListenCommands(program2) {
     await runRecent(options, recentCommand3);
   });
   program2.command("mixtapes").description("Fluncle's checkpoint sets").option("--json", "Print JSON", false).action(async (options) => {
-    const { mixtapesCommand: mixtapesCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    const { mixtapesCommand: mixtapesCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
     await runMixtapes(options, mixtapesCommand3);
   });
   program2.command("open").description("Pick a track, open it in Spotify").argument("[target]").option("--app", "Open in the native app", false).option("--browser", "Open in the browser", false).option("--limit <limit>", "Number of recent tracks to choose from", "20").allowExcessArguments().action(async (target, options) => {
@@ -7073,7 +7042,7 @@ function addMetaCommands(program2) {
   });
 }
 function addTrackCommands(program2) {
-  const tracks = configureCommand(program2.command("tracks", { hidden: true }).alias("track").description("Public track lookups"));
+  const tracks = configureCommand(program2.command("tracks", { hidden: true }).description("Public track lookups"));
   tracks.command("get").description("Look up one finding by id or Log ID").argument("[idOrLogId]").option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
     const { trackGetCommand: trackGetCommand2 } = await Promise.resolve().then(() => (init_track(), exports_track));
     await runTrackGet(idOrLogId, options, trackGetCommand2);
@@ -7087,7 +7056,7 @@ function addAdminCommands(program2) {
   admin.command("help", { hidden: true }).description("display help for command").action(() => {
     admin.outputHelp();
   });
-  const adminTracks = configureCommand(admin.command("tracks").alias("track").description("Track admin commands"));
+  const adminTracks = configureCommand(admin.command("tracks").description("Track admin commands"));
   adminTracks.action(() => {
     adminTracks.outputHelp();
   });
@@ -7095,15 +7064,7 @@ function addAdminCommands(program2) {
     const { addCommand: addCommand3 } = await Promise.resolve().then(() => (init_add(), exports_add));
     await runAdd(spotifyUrl, options, addCommand3);
   });
-  admin.command("add", { hidden: true }).description("Publish a Spotify track (alias of `admin tracks publish`)").argument("[spotifyUrl]").option("--note <text>", "Operator note").option("--dry-run", "Preview without publishing", false).option("--json", "Print JSON", false).allowExcessArguments().action(async (spotifyUrl, options) => {
-    const { addCommand: addCommand3 } = await Promise.resolve().then(() => (init_add(), exports_add));
-    await runAdd(spotifyUrl, options, addCommand3);
-  });
-  adminTracks.command("queue").description("Findings awaiting a video, oldest first (the next to film is first)").option("--limit <limit>", "Number of findings to show", "10").option("--has-context", "No-op: the render queue is always context-gated").option("--has-observation", "Only findings that already have a spoken observation").option("--json", "Print JSON", false).action(async (options) => {
-    const { queueCommand: queueCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
-    await runAdminQueue(options, queueCommand2);
-  });
-  admin.command("queue", { hidden: true }).description("Render queue (alias of `admin tracks queue`)").option("--limit <limit>", "Number of findings to show", "10").option("--has-context", "No-op: the render queue is always context-gated").option("--has-observation", "Only findings that already have a spoken observation").option("--json", "Print JSON", false).action(async (options) => {
+  adminTracks.command("queue").description("Findings awaiting a video, oldest first (the next to film is first)").option("--limit <limit>", "Number of findings to show", "10").option("--has-observation", "Only findings that already have a spoken observation").option("--json", "Print JSON", false).action(async (options) => {
     const { queueCommand: queueCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runAdminQueue(options, queueCommand2);
   });
@@ -7120,10 +7081,6 @@ function addAdminCommands(program2) {
     const { vehiclesCommand: vehiclesCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runAdminVehicles(options, vehiclesCommand2);
   });
-  admin.command("vehicles", { hidden: true }).description("Video vehicles (alias of `admin tracks vehicles`)").option("--limit <limit>", "Number of vehicles to show", "10").option("--json", "Print JSON", false).action(async (options) => {
-    const { vehiclesCommand: vehiclesCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
-    await runAdminVehicles(options, vehiclesCommand2);
-  });
   const adminTrack = adminTracks;
   adminTrack.command("update").description("Certify a track into the archive").argument("[trackId]").option("--bpm <number>", "Track BPM").option("--features <json>", "Audio feature JSON").option("--json", "Print JSON", false).option("--key <key>", "Musical key").option("--note <text>", "Operator note").option("--status <status>", "Enrichment status").option("--video-url <url>", "Rendered video URL").allowExcessArguments().action(async (trackId, options) => {
     const { trackUpdateCommand: trackUpdateCommand2 } = await Promise.resolve().then(() => (init_track(), exports_track));
@@ -7190,35 +7147,35 @@ function addAdminCommands(program2) {
     adminMixtapes.outputHelp();
   });
   adminMixtapes.command("create").description("Log a new mixtape draft").option("--duration-ms <duration>", "Duration (mm:ss, h:mm:ss, or ms)").option("--json", "Print JSON", false).option("--note <text>", "Operator note").option("--recorded-at <date>", "Recorded date (ISO)").option("--soundcloud-url <url>", "SoundCloud URL (manual; YouTube + Mixcloud come from distribute)").allowExcessArguments().action(async (options) => {
-    const { mixtapeCreateCommand: mixtapeCreateCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    const { mixtapeCreateCommand: mixtapeCreateCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
     await runMixtapeCreate(options, mixtapeCreateCommand3);
   });
   adminMixtapes.command("update").description("Update a mixtape's fields").argument("[id]").option("--duration-ms <duration>", "Duration (mm:ss, h:mm:ss, or ms)").option("--json", "Print JSON", false).option("--note <text>", "Operator note").option("--recorded-at <date>", "Recorded date (ISO)").option("--soundcloud-url <url>", "SoundCloud URL (manual; YouTube + Mixcloud come from distribute)").allowExcessArguments().action(async (id, options) => {
-    const { mixtapeUpdateCommand: mixtapeUpdateCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    const { mixtapeUpdateCommand: mixtapeUpdateCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
     await runMixtapeUpdate(id, options, mixtapeUpdateCommand3);
   });
   adminMixtapes.command("members").description("Set a mixtape's tracklist (refs and/or a cue-sheet file)").argument("[id]").argument("[refs...]").option("--from <file>", "Cue-sheet or JSON file with members").option("--json", "Print JSON", false).allowExcessArguments().action(async (id, refs, options) => {
-    const { mixtapeMembersCommand: mixtapeMembersCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    const { mixtapeMembersCommand: mixtapeMembersCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
     await runMixtapeMembers(id, refs, options, mixtapeMembersCommand3);
   });
   adminMixtapes.command("publish").description("Publish a mixtape draft").argument("[id]").option("--json", "Print JSON", false).allowExcessArguments().action(async (id, options) => {
-    const { mixtapePublishCommand: mixtapePublishCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    const { mixtapePublishCommand: mixtapePublishCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
     await runMixtapePublish(id, options, mixtapePublishCommand3);
   });
   adminMixtapes.command("delete").description("Discard a mixtape draft (published mixtapes can't be deleted)").argument("[id]").option("--json", "Print JSON", false).option("--yes", "Skip confirmation", false).allowExcessArguments().action(async (id, options) => {
-    const { mixtapeDeleteCommand: mixtapeDeleteCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    const { mixtapeDeleteCommand: mixtapeDeleteCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
     await runMixtapeDelete(id, options, mixtapeDeleteCommand3);
   });
   adminMixtapes.command("list").description("List all mixtapes (including drafts)").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
-    const { mixtapeListCommand: mixtapeListCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
-    await runMixtapeList(options, mixtapeListCommand3);
+    const { mixtapeListCommand: mixtapeListCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapeList(options, mixtapeListCommand2);
   });
   adminMixtapes.command("get").description("Show one mixtape by id or log id").argument("[idOrLogId]").option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
-    const { mixtapeGetCommand: mixtapeGetCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
-    await runMixtapeGet(idOrLogId, options, mixtapeGetCommand3);
+    const { mixtapeGetCommand: mixtapeGetCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapeGet(idOrLogId, options, mixtapeGetCommand2);
   });
   adminMixtapes.command("distribute").description("Mint + push a mixtape to YouTube (video) and Mixcloud (audio)").argument("[idOrLogId]").option("--video <file>", "Video file for YouTube").option("--audio <file>", "Audio file for Mixcloud").option("--youtube", "Only distribute to YouTube").option("--mixcloud", "Only distribute to Mixcloud").option("--set-video", "Also stage a 1080p set-video rendition (from --video) to R2 + flip setVideoAt for the /log player").option("--unlisted", "Keep Mixcloud private too (YouTube is always unlisted until publish-youtube)").option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
-    const { mixtapeDistributeCommand: mixtapeDistributeCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    const { mixtapeDistributeCommand: mixtapeDistributeCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
     await runMixtapeDistribute(idOrLogId, options, mixtapeDistributeCommand3);
   });
   adminMixtapes.command("publish-youtube").description("Flip a distributed mixtape's YouTube video from unlisted to public").argument("[idOrLogId]").option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
@@ -7304,7 +7261,7 @@ function addAdminCommands(program2) {
     const { authLastfmCommand: authLastfmCommand2 } = await Promise.resolve().then(() => (init_auth_lastfm(), exports_auth_lastfm));
     await authLastfmCommand2(options);
   });
-  const backfill = configureCommand(admin.command("backfills").alias("backfill").description("Backfill operator-only archives"));
+  const backfill = configureCommand(admin.command("backfills").description("Backfill operator-only archives"));
   backfill.action(() => {
     backfill.outputHelp();
   });
@@ -7798,8 +7755,8 @@ async function runMixtapeDelete(id, options, mixtapeDeleteCommand3) {
   }
   console.log(`Discarded draft ${id}.`);
 }
-async function runMixtapeList(options, mixtapeListCommand3) {
-  const mixtapes = await mixtapeListCommand3();
+async function runMixtapeList(options, mixtapeListCommand2) {
+  const mixtapes = await mixtapeListCommand2();
   if (options.json) {
     printJson({ mixtapes, ok: true });
     return;
@@ -7840,11 +7797,11 @@ async function runClipsCut(clipId, options, clipCutCommand2) {
   }
   console.log(`Cut ${result.clipId} \u2192 ${result.url} (${(result.sizeBytes / 1e6).toFixed(1)} MB).`);
 }
-async function runMixtapeGet(idOrLogId, options, mixtapeGetCommand3) {
+async function runMixtapeGet(idOrLogId, options, mixtapeGetCommand2) {
   if (!idOrLogId) {
     throw new Error("Missing mixtape id or log id. Usage: fluncle admin mixtapes get <id|logId>");
   }
-  const mixtape = await mixtapeGetCommand3(idOrLogId);
+  const mixtape = await mixtapeGetCommand2(idOrLogId);
   if (options.json) {
     printJson(mixtape);
     return;
@@ -8011,7 +7968,6 @@ function parseListLimit(value) {
 async function runAdminQueue(options, queueCommand2) {
   const limit = parseListLimit(options.limit);
   const tracks = await queueCommand2(limit, {
-    hasContext: options.hasContext ? true : undefined,
     hasObservation: options.hasObservation ? true : undefined
   });
   if (options.json) {