fluncle 0.68.0 → 0.70.0

package/bin/fluncle.mjs

@@ -423,7 +423,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.68.0".trim() ? "0.68.0".trim() : "0.1.0";
+  currentVersion = "0.70.0".trim() ? "0.70.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -1047,7 +1047,214 @@ 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
+});
+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
+  ];
+}
+async function stageSetVideo(mixtapeId, masterPath, onProgress = () => {}) {
+  if (!existsSync(masterPath)) {
+    throw new CliError2("file_not_found", `Set-video master not found: ${masterPath}`);
+  }
+  await assertFfmpeg();
+  const renditionPath = join4(tmpdir(), `fluncle-set-${randomUUID()}.mp4`);
+  onProgress("Set video: deriving the 1080p faststart rendition (ffmpeg)…");
+  await deriveRendition(masterPath, renditionPath);
+  try {
+    const size = statSync2(renditionPath).size;
+    const plan = planMultipart(size);
+    onProgress(`Set video: uploading ${(size / 1e9).toFixed(2)} GB in ${plan.partCount} part(s)…`);
+    const presign = await adminApiPost(`/api/admin/mixtapes/${encodeURIComponent(mixtapeId)}/set-video/presign`, { partCount: plan.partCount });
+    const urlByPart = new Map(presign.parts.map((part) => [part.partNumber, part.url]));
+    const completed = [];
+    try {
+      for (const part of plan.parts) {
+        const url = urlByPart.get(part.partNumber);
+        if (!url) {
+          throw new CliError2("presign_missing", `Worker did not sign part ${part.partNumber} of ${plan.partCount}`);
+        }
+        onProgress(`Set video: part ${part.partNumber}/${plan.partCount}`);
+        const etag = await putPart(url, renditionPath, part);
+        completed.push({ etag, partNumber: part.partNumber });
+      }
+      await completeUpload(presign.completeUrl, completed);
+    } catch (error) {
+      await abortUpload(presign.abortUrl).catch(() => {});
+      throw error;
+    }
+    await adminApiPatch(`/api/admin/mixtapes/${encodeURIComponent(mixtapeId)}`, { setVideoAt: new Date().toISOString() });
+    onProgress("Set video: flipped setVideoAt — the /log player + video SEO are live.");
+    return { key: presign.key, url: `${FOUND_BASE}/${presign.key}` };
+  } finally {
+    rmSync2(renditionPath, { force: true });
+  }
+}
+async function putPart(url, path2, part) {
+  const response = await fetch(url, {
+    body: Bun.file(path2).slice(part.start, part.end),
+    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;
@@ -1060,6 +1267,206 @@ async function mixtapeGetCommand(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();
@@ -1213,40 +1620,40 @@ var init_mixtape_mixcloud = __esm(() => {
 });
 
 // src/commands/mixtapes.ts
-var exports_mixtapes = {};
-__export(exports_mixtapes, {
-  mixtapesCommand: () => mixtapesCommand,
-  mixtapeUpdateCommand: () => mixtapeUpdateCommand,
-  mixtapePublishCommand: () => mixtapePublishCommand,
-  mixtapeMembersCommand: () => mixtapeMembersCommand,
+var exports_mixtapes2 = {};
+__export(exports_mixtapes2, {
+  mixtapesCommand: () => mixtapesCommand2,
+  mixtapeUpdateCommand: () => mixtapeUpdateCommand2,
+  mixtapePublishCommand: () => mixtapePublishCommand2,
+  mixtapeMembersCommand: () => mixtapeMembersCommand2,
   mixtapeListCommand: () => mixtapeListCommand2,
   mixtapeGetCommand: () => mixtapeGetCommand2,
-  mixtapeDistributeCommand: () => mixtapeDistributeCommand,
-  mixtapeDeleteCommand: () => mixtapeDeleteCommand,
-  mixtapeCreateCommand: () => mixtapeCreateCommand
+  mixtapeDistributeCommand: () => mixtapeDistributeCommand2,
+  mixtapeDeleteCommand: () => mixtapeDeleteCommand2,
+  mixtapeCreateCommand: () => mixtapeCreateCommand2
 });
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-async function mixtapesCommand() {
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+async function mixtapesCommand2() {
   const response = await publicApiGet("/api/mixtapes");
   return response.mixtapes;
 }
-async function mixtapeCreateCommand(options) {
-  return adminApiPost("/api/admin/mixtapes", buildBody(options));
+async function mixtapeCreateCommand2(options) {
+  return adminApiPost("/api/admin/mixtapes", buildBody2(options));
 }
-async function mixtapeUpdateCommand(id, options) {
-  return adminApiPatch(`/api/admin/mixtapes/${encodeURIComponent(id)}`, buildBody(options));
+async function mixtapeUpdateCommand2(id, options) {
+  return adminApiPatch(`/api/admin/mixtapes/${encodeURIComponent(id)}`, buildBody2(options));
 }
-async function mixtapeMembersCommand(id, refs, options) {
+async function mixtapeMembersCommand2(id, refs, options) {
   const members = refs.map((ref) => ({ ref }));
   if (options.from) {
-    members.push(...parseCueFile(options.from));
+    members.push(...parseCueFile2(options.from));
   }
   return adminApiPut(`/api/admin/mixtapes/${encodeURIComponent(id)}/members`, { members });
 }
-async function mixtapePublishCommand(id) {
+async function mixtapePublishCommand2(id) {
   return adminApiPost(`/api/admin/mixtapes/${encodeURIComponent(id)}/publish`);
 }
-async function mixtapeDeleteCommand(id) {
+async function mixtapeDeleteCommand2(id) {
   return adminApiDelete(`/api/admin/mixtapes/${encodeURIComponent(id)}`);
 }
 async function mixtapeListCommand2() {
@@ -1261,33 +1668,37 @@ async function mixtapeGetCommand2(idOrLogId) {
   }
   return match;
 }
-async function mixtapeDistributeCommand(idOrLogId, options, onProgress = () => {}) {
+async function mixtapeDistributeCommand2(idOrLogId, options, onProgress = () => {}) {
   const mixtape = await mixtapeGetCommand2(idOrLogId);
   if (!mixtape.id) {
     throw new CliError2("mixtape_not_found", `No mixtape with id or log id ${idOrLogId}`);
   }
-  const both = !options.youtube && !options.mixcloud;
+  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;
+    const durationMs = source ? await probeDurationMs2(source) : undefined;
     if (durationMs) {
-      await mixtapeUpdateCommand(mixtapeId, { durationMs: String(durationMs), json: false });
+      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 mixtapePublishCommand(mixtapeId);
+    const published = await mixtapePublishCommand2(mixtapeId);
     logId = published.mixtape.logId;
     onProgress(`Minted ${logId}.`);
   } else if (mixtape.status === "published") {
@@ -1319,9 +1730,19 @@ async function mixtapeDistributeCommand(idOrLogId, options, onProgress = () => {
     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) {
+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();
@@ -1332,7 +1753,7 @@ async function probeDurationMs(filePath) {
     return;
   }
 }
-function buildBody(options) {
+function buildBody2(options) {
   const body = {};
   if (options.note !== undefined) {
     body.note = options.note;
@@ -1344,7 +1765,7 @@ function buildBody(options) {
     body.soundcloudUrl = options.soundcloudUrl;
   }
   if (options.durationMs !== undefined) {
-    const parsed = parseDuration(options.durationMs);
+    const parsed = parseDuration2(options.durationMs);
     if (parsed === null) {
       throw new CliError2("invalid_duration", "Duration must be mm:ss or h:mm:ss, or a millisecond count");
     }
@@ -1352,11 +1773,11 @@ function buildBody(options) {
   }
   return body;
 }
-function parseCueFile(filePath) {
-  if (!existsSync(filePath)) {
+function parseCueFile2(filePath) {
+  if (!existsSync3(filePath)) {
     throw new CliError2("file_not_found", `Cue file not found: ${filePath}`);
   }
-  const text = readFileSync2(filePath, "utf-8");
+  const text = readFileSync3(filePath, "utf-8");
   const trimmed = text.trim();
   if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
     try {
@@ -1385,9 +1806,9 @@ function parseCueFile(filePath) {
       throw new CliError2("invalid_cue_json", `Cue JSON parse failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  return parseCueSheet(text);
+  return parseCueSheet2(text);
 }
-function parseCueSheet(text) {
+function parseCueSheet2(text) {
   const entries = [];
   for (const line of text.split(/\r?\n/)) {
     const trimmed = line.trim();
@@ -1400,7 +1821,7 @@ function parseCueSheet(text) {
       if (time === undefined || ref === undefined) {
         continue;
       }
-      const startMs = parseDuration(time);
+      const startMs = parseDuration2(time);
       if (startMs === null) {
         continue;
       }
@@ -1411,7 +1832,7 @@ function parseCueSheet(text) {
   }
   return entries;
 }
-function parseDuration(input) {
+function parseDuration2(input) {
   const trimmed = input.trim();
   if (!trimmed) {
     return null;
@@ -2138,7 +2559,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.68.0".trim() ? "0.68.0".trim() : "0.1.0";
+  currentVersion2 = "0.70.0".trim() ? "0.70.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -2673,10 +3094,8 @@ var init_src = __esm(() => {
       ],
       kind: "extension",
       name: "extension.lens",
-      operatorNotes: "Fluncle Lens (apps/extension), MV3. PENDING Chrome Web Store review — DARK until approval, then flip `pending` + set the assigned listing URL. The placeholder `url` is the store search for the listing; probeConfig is the post-approval /status check.",
-      pending: true,
-      probeConfig: { cadenceMs: PROBE_CADENCE_MS, kind: "http", timeoutMs: PROBE_TIMEOUT_MS },
-      url: "https://chromewebstore.google.com/search/Fluncle%20Lens",
+      operatorNotes: "Fluncle Lens (apps/extension), MV3, LIVE on the Chrome Web Store (published 2026-06-29). Store listing reachability is Google's, not ours, so it is not on the /status board.",
+      url: "https://chromewebstore.google.com/detail/efkkceaofendabikblfjhoepgejfpakk",
       weights: { web: "secondary" }
     },
     {
@@ -2894,7 +3313,7 @@ async function trackVideoCommand(idOrLogId, files, onProgress) {
       const detail = (await response.text().catch(() => "")).slice(0, 300);
       throw new CliError2("r2_put_failed", `R2 rejected ${spec.field} with ${response.status} ${response.statusText}${detail ? `: ${detail}` : ""}`);
     }
-    urls[spec.field] = `${FOUND_BASE}/${upload.key}`;
+    urls[spec.field] = `${FOUND_BASE2}/${upload.key}`;
   }
   const manifest = files.render ? await readManifestFields(files.render) : {};
   const videoModel = files.model?.trim().slice(0, 120) || manifest.model || DEFAULT_VIDEO_MODEL;
@@ -3004,7 +3423,7 @@ async function trackNoteCommand(idOrLogId, options) {
   const body = { note: options.note };
   return adminApiPost(`/api/admin/tracks/${encodeURIComponent(idOrLogId)}/note`, body);
 }
-var DEFAULT_VIDEO_MODEL = "anthropic/claude-opus-4-8", DEFAULT_VIDEO_REASONING = "high", FOUND_BASE = "https://found.fluncle.com", VIDEO_FIELDS;
+var DEFAULT_VIDEO_MODEL = "anthropic/claude-opus-4-8", DEFAULT_VIDEO_REASONING = "high", FOUND_BASE2 = "https://found.fluncle.com", VIDEO_FIELDS;
 var init_track = __esm(() => {
   init_api();
   init_output();
@@ -3437,7 +3856,7 @@ __export(exports_mixtape_youtube2, {
   distributeYoutube: () => distributeYoutube2,
   authYoutubeCommand: () => authYoutubeCommand2
 });
-import { statSync as statSync2 } from "node:fs";
+import { statSync as statSync3 } from "node:fs";
 async function distributeYoutube2(mixtapeId, videoPath, onProgress) {
   const contentLength = fileSize2(videoPath);
   const contentType = "video/mp4";
@@ -3569,7 +3988,7 @@ async function resolveMixtapeId2(idOrLogId) {
 }
 function fileSize2(path2) {
   try {
-    return statSync2(path2).size;
+    return statSync3(path2).size;
   } catch {
     throw new CliError2("video_not_found", `Cannot read video file at ${path2}`);
   }
@@ -3589,16 +4008,197 @@ var init_mixtape_youtube2 = __esm(() => {
   init_output();
 });
 
+// src/commands/clips.ts
+var exports_clips = {};
+__export(exports_clips, {
+  setVideoUrl: () => setVideoUrl,
+  escapeDrawtextValue: () => escapeDrawtextValue,
+  clipsListCommand: () => clipsListCommand,
+  clipFootageKey: () => clipFootageKey,
+  clipCutVideoFilter: () => clipCutVideoFilter,
+  clipCutFfmpegArgs: () => clipCutFfmpegArgs,
+  clipCutCommand: () => clipCutCommand,
+  MAX_CLIP_BYTES: () => MAX_CLIP_BYTES,
+  CLIP_WIDTH: () => CLIP_WIDTH,
+  CLIP_MAXRATE: () => CLIP_MAXRATE,
+  CLIP_HEIGHT: () => CLIP_HEIGHT,
+  CLIP_CRF: () => CLIP_CRF,
+  CLIP_BUFSIZE: () => CLIP_BUFSIZE,
+  CLIP_AUDIO_BITRATE: () => CLIP_AUDIO_BITRATE
+});
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { rmSync as rmSync3, statSync as statSync4 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join5 } from "node:path";
+function clipFootageKey(clipId) {
+  return `${clipId}/footage.mp4`;
+}
+function setVideoUrl(logId) {
+  return `${FOUND_BASE3}/${encodeURIComponent(logId)}/set.mp4`;
+}
+function escapeDrawtextValue(text) {
+  return text.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/'/g, "'\\''");
+}
+function clipCutVideoFilter(options) {
+  const xOffset = Math.max(0, Math.round(options.xOffset));
+  const crop = `crop=ih*9/16:ih:${xOffset}:0,scale=${CLIP_WIDTH}:${CLIP_HEIGHT}`;
+  const font = options.fontFile ? `:fontfile='${options.fontFile}'` : "";
+  const title = escapeDrawtextValue(options.title);
+  const coordinate2 = escapeDrawtextValue(`fluncle://${options.logId}`);
+  const titleDraw = `drawtext=text='${title}'${font}:fontcolor=white:fontsize=46:` + `x=56:y=h-208:box=1:boxcolor=black@0.55:boxborderw=18`;
+  const coordinateDraw = `drawtext=text='${coordinate2}'${font}:fontcolor=0xF4EAD7:fontsize=30:` + `x=56:y=h-132:box=1:boxcolor=black@0.55:boxborderw=12`;
+  return `${crop},${titleDraw},${coordinateDraw}`;
+}
+function clipCutFfmpegArgs(options) {
+  const inSeconds = (options.inMs / 1000).toFixed(3);
+  const durationSeconds = ((options.outMs - options.inMs) / 1000).toFixed(3);
+  const filter = clipCutVideoFilter(options);
+  return [
+    "-y",
+    "-ss",
+    inSeconds,
+    "-i",
+    options.setUrl,
+    "-t",
+    durationSeconds,
+    "-vf",
+    filter,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "veryfast",
+    "-crf",
+    String(CLIP_CRF),
+    "-maxrate",
+    CLIP_MAXRATE,
+    "-bufsize",
+    CLIP_BUFSIZE,
+    "-pix_fmt",
+    "yuv420p",
+    "-c:a",
+    "aac",
+    "-b:a",
+    CLIP_AUDIO_BITRATE,
+    "-movflags",
+    "+faststart",
+    options.outputPath
+  ];
+}
+async function clipsListCommand(filter = {}) {
+  const params = new URLSearchParams;
+  if (filter.mixtapeId) {
+    params.set("mixtapeId", filter.mixtapeId);
+  }
+  if (filter.status) {
+    params.set("status", filter.status);
+  }
+  const query = params.toString();
+  const response = await adminApiGet(`/api/admin/clips${query ? `?${query}` : ""}`);
+  return response.clips;
+}
+async function clipCutCommand(clipId, onProgress = () => {}) {
+  const clips = await clipsListCommand();
+  const clip = clips.find((candidate) => candidate.id === clipId);
+  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);
+  if (!mixtape.logId) {
+    throw new CliError2("mixtape_no_log_id", `Mixtape ${clip.mixtapeId} has no committed Log ID`);
+  }
+  if (!mixtape.setVideoAt) {
+    throw new CliError2("set_not_staged", `Mixtape ${mixtape.logId} has no staged set video — run \`distribute --set-video\` first`);
+  }
+  await assertFfmpeg2();
+  const setUrl = setVideoUrl(mixtape.logId);
+  const outputPath = join5(tmpdir2(), `fluncle-clip-${randomUUID2()}.mp4`);
+  try {
+    onProgress(`Clip ${clipId}: cutting [${clip.inMs}–${clip.outMs}ms] from ${mixtape.logId}…`);
+    await runClipCut({
+      fontFile: process.env.CLIP_FONT_FILE,
+      inMs: clip.inMs,
+      logId: mixtape.logId,
+      outMs: clip.outMs,
+      outputPath,
+      setUrl,
+      title: mixtape.title,
+      xOffset: clip.xOffset
+    });
+    const sizeBytes = statSync4(outputPath).size;
+    if (sizeBytes > MAX_CLIP_BYTES) {
+      throw new CliError2("clip_too_large", `The cut is ${(sizeBytes / 1e6).toFixed(1)} MB (> 100 MB Cloudflare MT ceiling) — shorten the window or lower the bitrate cap`);
+    }
+    onProgress(`Clip ${clipId}: uploading ${(sizeBytes / 1e6).toFixed(1)} MB…`);
+    const presign = await adminApiPost(`/api/admin/clips/${encodeURIComponent(clipId)}/cut/presign`, { contentType: "video/mp4" });
+    await putClip(presign.url, presign.contentType, outputPath);
+    await adminApiPost(`/api/admin/clips/${encodeURIComponent(clipId)}/cut/finalize`);
+    onProgress(`Clip ${clipId}: done → ${FOUND_BASE3}/${presign.key}`);
+    return {
+      clipId,
+      key: presign.key,
+      logId: mixtape.logId,
+      sizeBytes,
+      url: `${FOUND_BASE3}/${presign.key}`
+    };
+  } finally {
+    rmSync3(outputPath, { force: true });
+  }
+}
+async function putClip(url, contentType, path2) {
+  const response = await fetch(url, {
+    body: Bun.file(path2),
+    headers: { "content-type": contentType },
+    method: "PUT"
+  });
+  if (!response.ok) {
+    const detail = (await response.text().catch(() => "")).slice(0, 300);
+    throw new CliError2("r2_put_failed", `R2 rejected the clip upload (${response.status} ${response.statusText})${detail ? `: ${detail}` : ""}`);
+  }
+}
+async function assertFfmpeg2() {
+  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", "The clip cut needs ffmpeg. Install it on the box (apt-get install -y ffmpeg).");
+  }
+}
+async function runClipCut(options) {
+  if (!options.setUrl) {
+    throw new CliError2("missing_set_url", "The clip cut needs the set rendition URL");
+  }
+  const proc = Bun.spawn(["ffmpeg", ...clipCutFfmpegArgs(options)], {
+    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 cut the clip${detail ? `: ${detail}` : ""}`);
+  }
+}
+var FOUND_BASE3 = "https://found.fluncle.com", CLIP_WIDTH = 1080, CLIP_HEIGHT = 1920, CLIP_CRF = 21, CLIP_MAXRATE = "10M", CLIP_BUFSIZE = "20M", CLIP_AUDIO_BITRATE = "192k", MAX_CLIP_BYTES;
+var init_clips = __esm(() => {
+  init_api();
+  init_output();
+  MAX_CLIP_BYTES = 100 * 1024 * 1024;
+});
+
 // src/commands/newsletter.ts
 var exports_newsletter = {};
 __export(exports_newsletter, {
   newsletterUpdateCommand: () => newsletterUpdateCommand,
   newsletterSendCommand: () => newsletterSendCommand,
   newsletterListCommand: () => newsletterListCommand,
-  newsletterDraftCommand: () => newsletterDraftCommand
+  newsletterDraftCommand: () => newsletterDraftCommand,
+  newsletterDeleteCommand: () => newsletterDeleteCommand
 });
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-function buildBody2(options, { requireContent }) {
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+function buildBody3(options, { requireContent }) {
   const body = {};
   if (options.contentFile !== undefined) {
     body.contentJson = readContentFile(options.contentFile);
@@ -3617,10 +4217,10 @@ function buildBody2(options, { requireContent }) {
   return body;
 }
 function readContentFile(filePath) {
-  if (!existsSync2(filePath)) {
+  if (!existsSync4(filePath)) {
     throw new CliError2("file_not_found", `Content file not found: ${filePath}`);
   }
-  const text = readFileSync3(filePath, "utf-8");
+  const text = readFileSync4(filePath, "utf-8");
   try {
     return JSON.parse(text);
   } catch (error) {
@@ -3628,10 +4228,10 @@ function readContentFile(filePath) {
   }
 }
 async function newsletterDraftCommand(options) {
-  return adminApiPost("/api/admin/newsletter/editions", buildBody2(options, { requireContent: true }));
+  return adminApiPost("/api/admin/newsletter/editions", buildBody3(options, { requireContent: true }));
 }
 async function newsletterUpdateCommand(id, options) {
-  return adminApiPatch(`/api/admin/newsletter/editions/${encodeURIComponent(id)}`, buildBody2(options, { requireContent: false }));
+  return adminApiPatch(`/api/admin/newsletter/editions/${encodeURIComponent(id)}`, buildBody3(options, { requireContent: false }));
 }
 async function newsletterSendCommand(id) {
   return adminApiPost(`/api/admin/newsletter/editions/${encodeURIComponent(id)}/send`);
@@ -3640,6 +4240,9 @@ async function newsletterListCommand() {
   const response = await adminApiGet("/api/admin/newsletter/editions");
   return response.editions;
 }
+async function newsletterDeleteCommand(id) {
+  return adminApiDelete(`/api/admin/newsletter/editions/${encodeURIComponent(id)}`);
+}
 var init_newsletter = __esm(() => {
   init_api();
   init_output();
@@ -4254,7 +4857,7 @@ var COORD_FALLBACK2 = "—";
 var init_format2 = () => {};
 
 // src/cli.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import path2 from "path";
 
 // ../../node_modules/commander/lib/error.js
@@ -6416,8 +7019,8 @@ 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: mixtapesCommand2 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes));
-    await runMixtapes(options, mixtapesCommand2);
+    const { mixtapesCommand: mixtapesCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    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) => {
     const openCommands = await Promise.resolve().then(() => (init_open(), exports_open));
@@ -6587,41 +7190,53 @@ 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: mixtapeCreateCommand2 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes));
-    await runMixtapeCreate(options, mixtapeCreateCommand2);
+    const { mixtapeCreateCommand: mixtapeCreateCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    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: mixtapeUpdateCommand2 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes));
-    await runMixtapeUpdate(id, options, mixtapeUpdateCommand2);
+    const { mixtapeUpdateCommand: mixtapeUpdateCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    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: mixtapeMembersCommand2 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes));
-    await runMixtapeMembers(id, refs, options, mixtapeMembersCommand2);
+    const { mixtapeMembersCommand: mixtapeMembersCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    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: mixtapePublishCommand2 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes));
-    await runMixtapePublish(id, options, mixtapePublishCommand2);
+    const { mixtapePublishCommand: mixtapePublishCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    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: mixtapeDeleteCommand2 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes));
-    await runMixtapeDelete(id, options, mixtapeDeleteCommand2);
+    const { mixtapeDeleteCommand: mixtapeDeleteCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
+    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_mixtapes));
+    const { mixtapeListCommand: mixtapeListCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
     await runMixtapeList(options, mixtapeListCommand3);
   });
   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_mixtapes));
+    const { mixtapeGetCommand: mixtapeGetCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes2));
     await runMixtapeGet(idOrLogId, options, mixtapeGetCommand3);
   });
-  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("--unlisted", "Keep Mixcloud private too (YouTube is always unlisted until publish-youtube)").option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
-    const { mixtapeDistributeCommand: mixtapeDistributeCommand2 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes));
-    await runMixtapeDistribute(idOrLogId, options, mixtapeDistributeCommand2);
+  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));
+    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) => {
     const { publishYoutubeCommand: publishYoutubeCommand3 } = await Promise.resolve().then(() => (init_mixtape_youtube2(), exports_mixtape_youtube2));
     await runMixtapePublishYoutube(idOrLogId, options, publishYoutubeCommand3);
   });
+  const adminClips = configureCommand(admin.command("clips").description("Mixtape clip (Fluncle Studio) commands"));
+  adminClips.action(() => {
+    adminClips.outputHelp();
+  });
+  adminClips.command("list").description("List clips (filter by --status pending|done and/or --mixtape <id>)").option("--status <status>", "Filter by cut status (pending|done)").option("--mixtape <id>", "Filter by mixtape id").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
+    const { clipsListCommand: clipsListCommand2 } = await Promise.resolve().then(() => (init_clips(), exports_clips));
+    await runClipsList(options, clipsListCommand2);
+  });
+  adminClips.command("cut").description("Cut one clip's framed 9:16 footage from its set rendition, then ship it").argument("[clipId]").option("--json", "Print JSON", false).allowExcessArguments().action(async (clipId, options) => {
+    const { clipCutCommand: clipCutCommand2 } = await Promise.resolve().then(() => (init_clips(), exports_clips));
+    await runClipsCut(clipId, options, clipCutCommand2);
+  });
   const adminNewsletter = configureCommand(admin.command("newsletter").description("Newsletter edition commands"));
   adminNewsletter.action(() => {
     adminNewsletter.outputHelp();
@@ -6642,6 +7257,10 @@ function addAdminCommands(program2) {
     const { newsletterListCommand: newsletterListCommand2 } = await Promise.resolve().then(() => (init_newsletter(), exports_newsletter));
     await runNewsletterList(options, newsletterListCommand2);
   });
+  adminNewsletter.command("delete").description("Delete an edition (draft or sent) \u2014 OPERATOR only; reopens the send window").argument("[id]").option("--yes", "Confirm the delete", false).option("--json", "Print JSON", false).allowExcessArguments().action(async (id, options) => {
+    const { newsletterDeleteCommand: newsletterDeleteCommand2 } = await Promise.resolve().then(() => (init_newsletter(), exports_newsletter));
+    await runNewsletterDelete(id, options, newsletterDeleteCommand2);
+  });
   const submissions = configureCommand(admin.command("submissions").description("Review listener submissions"));
   submissions.option("--json", "Print JSON", false).action(async (options) => {
     const { listSubmissionsCommand: listSubmissionsCommand2 } = await Promise.resolve().then(() => (init_submissions(), exports_submissions));
@@ -6721,7 +7340,7 @@ async function runTrackPreviewArchive(idOrLogId, options, previewArchiveUploadCo
   console.log(`  mime: ${result.mime}`);
 }
 async function runTrackObserve(idOrLogId, options, trackObserveCommand2) {
-  const script = options.scriptFile ? readFileSync4(options.scriptFile, "utf8") : options.script;
+  const script = options.scriptFile ? readFileSync5(options.scriptFile, "utf8") : options.script;
   if (!idOrLogId || !script || !script.trim()) {
     throw new Error("Usage: fluncle admin tracks observe <track_id|log_id> (--script <text> | --script-file <file>) [--voice-id <id>] [--duration-ms <ms>] [--context-note <text>] [--json]");
   }
@@ -6777,7 +7396,7 @@ async function runTrackContext(idOrLogId, options, trackContextCommand2) {
   }
 }
 async function runTrackNote(idOrLogId, options, trackNoteCommand2) {
-  const note = options.scriptFile ? readFileSync4(options.scriptFile, "utf8") : options.script;
+  const note = options.scriptFile ? readFileSync5(options.scriptFile, "utf8") : options.script;
   if (!idOrLogId || !note || !note.trim()) {
     throw new Error("Usage: fluncle admin tracks note <track_id|log_id> (--script <text> | --script-file <file>) [--json]");
   }
@@ -6923,7 +7542,7 @@ async function runTrackVideo(idOrLogId, options, trackVideoCommand2) {
       return;
     }
     const candidate = path2.join(dir, name);
-    return existsSync3(candidate) ? candidate : undefined;
+    return existsSync5(candidate) ? candidate : undefined;
   };
   const resolveFile = (explicit, name) => {
     if (explicit) {
@@ -7095,56 +7714,56 @@ async function runTrackPurgeVideo(idOrLogId, options, trackPurgeVideoCommand2) {
   }
   console.log(result.noVideo ? `${result.logId} has no video \u2014 nothing to purge.` : `Purging the stale renditions for ${result.logId} from the edge. The next play picks up the fresh render.`);
 }
-async function runMixtapeCreate(options, mixtapeCreateCommand2) {
-  const result = await mixtapeCreateCommand2(options);
+async function runMixtapeCreate(options, mixtapeCreateCommand3) {
+  const result = await mixtapeCreateCommand3(options);
   if (options.json) {
     printJson(result);
     return;
   }
   console.log(`Logged draft ${result.mixtape.id}. It stays a draft until you publish it.`);
 }
-async function runMixtapeUpdate(id, options, mixtapeUpdateCommand2) {
+async function runMixtapeUpdate(id, options, mixtapeUpdateCommand3) {
   if (!id) {
     throw new Error("Missing mixtape id. Usage: fluncle admin mixtapes update <id>");
   }
-  const result = await mixtapeUpdateCommand2(id, options);
+  const result = await mixtapeUpdateCommand3(id, options);
   if (options.json) {
     printJson(result);
     return;
   }
   console.log(`Saved ${result.mixtape.id}.`);
 }
-async function runMixtapeMembers(id, refs, options, mixtapeMembersCommand2) {
+async function runMixtapeMembers(id, refs, options, mixtapeMembersCommand3) {
   if (!id) {
     throw new Error("Missing mixtape id. Usage: fluncle admin mixtapes members <id> [refs...]");
   }
   if (refs.length === 0 && !options.from) {
     throw new Error("Provide refs as arguments or a cue-sheet file with --from");
   }
-  const result = await mixtapeMembersCommand2(id, refs, options);
+  const result = await mixtapeMembersCommand3(id, refs, options);
   if (options.json) {
     printJson(result);
     return;
   }
   console.log(`Saved the tracklist: ${result.mixtape.memberCount} bangers on ${result.mixtape.id}.`);
 }
-async function runMixtapePublish(id, options, mixtapePublishCommand2) {
+async function runMixtapePublish(id, options, mixtapePublishCommand3) {
   if (!id) {
     throw new Error("Missing mixtape id. Usage: fluncle admin mixtapes publish <id>");
   }
-  const result = await mixtapePublishCommand2(id);
+  const result = await mixtapePublishCommand3(id);
   if (options.json) {
     printJson(result);
     return;
   }
   console.log(`Minted ${result.mixtape.logId} (fluncle://${result.mixtape.logId}) \u2014 distributing. ` + "Run `distribute` to push it to the platforms.");
 }
-async function runMixtapeDistribute(idOrLogId, options, mixtapeDistributeCommand2) {
+async function runMixtapeDistribute(idOrLogId, options, mixtapeDistributeCommand3) {
   if (!idOrLogId) {
     throw new Error("Missing mixtape id. Usage: fluncle admin mixtapes distribute <idOrLogId> --video <mp4> --audio <file>");
   }
   const onProgress = options.json ? () => {} : (message) => console.log(message);
-  const result = await mixtapeDistributeCommand2(idOrLogId, options, onProgress);
+  const result = await mixtapeDistributeCommand3(idOrLogId, options, onProgress);
   if (options.json) {
     printJson(result);
     return;
@@ -7165,14 +7784,14 @@ async function runMixtapePublishYoutube(idOrLogId, options, publishYoutubeComman
   }
   console.log(`YouTube video is now public: ${result.url}`);
 }
-async function runMixtapeDelete(id, options, mixtapeDeleteCommand2) {
+async function runMixtapeDelete(id, options, mixtapeDeleteCommand3) {
   if (!id) {
     throw new Error("Missing mixtape id. Usage: fluncle admin mixtapes delete <id> --yes");
   }
   if (!options.yes) {
     throw new Error("Pass --yes to confirm the discard. Published mixtapes can't be deleted.");
   }
-  await mixtapeDeleteCommand2(id);
+  await mixtapeDeleteCommand3(id);
   if (options.json) {
     printJson({ id, ok: true });
     return;
@@ -7195,6 +7814,32 @@ async function runMixtapeList(options, mixtapeListCommand3) {
     console.log(`${coordinate3}	${status}	${mixtape.memberCount} bangers	${mixtape.title}`);
   }
 }
+async function runClipsList(options, clipsListCommand2) {
+  const clips = await clipsListCommand2({ mixtapeId: options.mixtape, status: options.status });
+  if (options.json) {
+    printJson({ clips, ok: true });
+    return;
+  }
+  if (clips.length === 0) {
+    console.log("No clips.");
+    return;
+  }
+  for (const clip of clips) {
+    console.log(`${clip.id}	${clip.status}	${clip.mixtapeId}	${clip.inMs}-${clip.outMs}ms	x=${clip.xOffset}`);
+  }
+}
+async function runClipsCut(clipId, options, clipCutCommand2) {
+  if (!clipId) {
+    throw new Error("Missing clip id. Usage: fluncle admin clips cut <clipId>");
+  }
+  const onProgress = options.json ? () => {} : (message) => console.log(message);
+  const result = await clipCutCommand2(clipId, onProgress);
+  if (options.json) {
+    printJson({ ok: true, ...result });
+    return;
+  }
+  console.log(`Cut ${result.clipId} \u2192 ${result.url} (${(result.sizeBytes / 1e6).toFixed(1)} MB).`);
+}
 async function runMixtapeGet(idOrLogId, options, mixtapeGetCommand3) {
   if (!idOrLogId) {
     throw new Error("Missing mixtape id or log id. Usage: fluncle admin mixtapes get <id|logId>");
@@ -7260,6 +7905,20 @@ async function runNewsletterSend(id, options, newsletterSendCommand2) {
   const number = result.edition.number;
   console.log(number === undefined ? `Sent edition ${result.edition.id}.` : `Sent edition #${number} \u2014 it's out to the list and in the archive.`);
 }
+async function runNewsletterDelete(id, options, newsletterDeleteCommand2) {
+  if (!id) {
+    throw new Error("Missing edition id. Usage: fluncle admin newsletter delete <id> --yes");
+  }
+  if (!options.yes) {
+    throw new Error("Pass --yes to confirm \u2014 this hard-deletes the edition (draft or sent).");
+  }
+  const result = await newsletterDeleteCommand2(id);
+  if (options.json) {
+    printJson({ ...result, ok: true });
+    return;
+  }
+  console.log(`Deleted edition ${result.id}. The send window reopens to cover its finds.`);
+}
 async function runNewsletterList(options, newsletterListCommand2) {
   const editions = await newsletterListCommand2();
   if (options.json) {
@@ -7328,8 +7987,8 @@ async function runRecent(options, recentCommand3) {
   console.log(trackRows2(tracks).join(`
 `));
 }
-async function runMixtapes(options, mixtapesCommand2) {
-  const mixtapes = await mixtapesCommand2();
+async function runMixtapes(options, mixtapesCommand3) {
+  const mixtapes = await mixtapesCommand3();
   if (options.json) {
     printJson({ mixtapes, ok: true });
     return;

package/package.json

@@ -31,5 +31,5 @@
     "url": "git+https://github.com/mauricekleine/fluncle.git"
   },
   "type": "module",
-  "version": "0.68.0"
+  "version": "0.70.0"
 }