fluncle 0.86.0 → 0.87.0

package/bin/fluncle.mjs

@@ -538,7 +538,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.86.0".trim() ? "0.86.0".trim() : "0.1.0";
+  currentVersion = "0.87.0".trim() ? "0.87.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -2251,7 +2251,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.86.0".trim() ? "0.86.0".trim() : "0.1.0";
+  currentVersion2 = "0.87.0".trim() ? "0.87.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -4014,238 +4014,6 @@ var init_recordings = __esm(() => {
   init_mixtape_set_video();
 });
 
-// src/commands/mixtapes.ts
-var exports_mixtapes2 = {};
-__export(exports_mixtapes2, {
-  mixtapesCommand: () => mixtapesCommand2,
-  mixtapeUpdateCommand: () => mixtapeUpdateCommand2,
-  mixtapeResyncCommand: () => mixtapeResyncCommand2,
-  mixtapePublishCommand: () => mixtapePublishCommand2,
-  mixtapeMembersCommand: () => mixtapeMembersCommand2,
-  mixtapeListCommand: () => mixtapeListCommand,
-  mixtapeGetCommand: () => mixtapeGetCommand,
-  mixtapeDistributeCommand: () => mixtapeDistributeCommand2,
-  mixtapeDeleteCommand: () => mixtapeDeleteCommand2,
-  mixtapeCreateCommand: () => mixtapeCreateCommand2
-});
-import { existsSync as existsSync4, readFileSync as readFileSync4 } 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}`);
-  }
-  if (mixtape.status === "draft") {
-    throw new CliError2("mixtape_not_promoted", `${mixtape.id} is still a draft — promote its recording first:
-` + "  fluncle admin recordings promote <recordingId>");
-  }
-  const both = !options.youtube && !options.mixcloud;
-  const doYoutube = both || Boolean(options.youtube);
-  const doMixcloud = both || Boolean(options.mixcloud);
-  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>");
-  }
-  const mixtapeId = mixtape.id;
-  const logId = mixtape.logId;
-  if (!logId) {
-    throw new CliError2("missing_log_id", "The mixtape has no Log ID — was it promoted successfully?");
-  }
-  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 === "published") {
-    onProgress(`Already published (${logId}); re-distributing.`);
-  } else {
-    onProgress(`Distributing ${logId} (promoted — coordinate already minted).`);
-  }
-  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}`);
-  }
-  return { logId, mixtapeId, results };
-}
-async function mixtapeResyncCommand2(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}`);
-  }
-  if (!mixtape.logId) {
-    throw new CliError2("mixtape_no_log_id", "The mixtape isn't published yet — distribute it before re-syncing.");
-  }
-  const mixtapeId = mixtape.id;
-  const explicit = Boolean(options.youtube) || Boolean(options.mixcloud);
-  let doYoutube = Boolean(options.youtube);
-  let doMixcloud = Boolean(options.mixcloud);
-  if (!explicit) {
-    const social = await adminApiGet(`/api/admin/mixtapes/${encodeURIComponent(mixtapeId)}/social`);
-    const platforms = new Set(social.posts.map((post) => post.platform));
-    doYoutube = platforms.has("youtube");
-    doMixcloud = platforms.has("mixcloud");
-    if (!doYoutube && !doMixcloud) {
-      throw new CliError2("mixtape_not_distributed", "The mixtape has no YouTube or Mixcloud link to re-sync.");
-    }
-  }
-  const results = [];
-  if (doYoutube) {
-    onProgress("YouTube: re-syncing description + chapters…");
-    const { resyncYoutube: resyncYoutube3 } = await Promise.resolve().then(() => (init_mixtape_youtube(), exports_mixtape_youtube));
-    const result = await resyncYoutube3(mixtapeId);
-    results.push({ platform: "youtube", url: result.url });
-    onProgress(`YouTube: ${result.url}`);
-  }
-  if (doMixcloud) {
-    onProgress("Mixcloud: re-syncing sections…");
-    const { resyncMixcloud: resyncMixcloud2 } = await Promise.resolve().then(() => (init_mixtape_mixcloud(), exports_mixtape_mixcloud));
-    const result = await resyncMixcloud2(mixtapeId);
-    results.push({ platform: "mixcloud", url: result.url });
-    onProgress(`Mixcloud: ${result.url}`);
-  }
-  return { logId: mixtape.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 (!existsSync4(filePath)) {
-    throw new CliError2("file_not_found", `Cue file not found: ${filePath}`);
-  }
-  const text = readFileSync4(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, {
@@ -4321,9 +4089,6 @@ async function clipsListCommand(filter = {}) {
   if (filter.recordingId) {
     params.set("recordingId", filter.recordingId);
   }
-  if (filter.mixtapeId) {
-    params.set("mixtapeId", filter.mixtapeId);
-  }
   if (filter.status) {
     params.set("status", filter.status);
   }
@@ -4332,28 +4097,17 @@ async function clipsListCommand(filter = {}) {
   return response.clips;
 }
 async function resolveClipSource(clip) {
-  if (clip.recordingId) {
-    const { recordingGet: recordingGet2 } = await Promise.resolve().then(() => (init_recordings(), exports_recordings));
-    const recording = await recordingGet2(clip.recordingId);
-    if (!recording.r2Key) {
-      throw new CliError2("recording_not_staged", `Recording ${clip.recordingId} has no staged set video`);
-    }
-    return {
-      setUrl: `${FOUND_BASE3}/${recording.r2Key.split("/").map(encodeURIComponent).join("/")}`
-    };
-  }
-  if (!clip.mixtapeId) {
-    throw new CliError2("clip_unlinked", `Clip ${clip.id} is linked to neither a recording nor a mixtape`);
+  if (!clip.recordingId) {
+    throw new CliError2("clip_unlinked", `Clip ${clip.id} is linked to no recording`);
   }
-  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`);
+  const { recordingGet: recordingGet2 } = await Promise.resolve().then(() => (init_recordings(), exports_recordings));
+  const recording = await recordingGet2(clip.recordingId);
+  if (!recording.r2Key) {
+    throw new CliError2("recording_not_staged", `Recording ${clip.recordingId} has no staged set video`);
   }
-  if (!mixtape.setVideoAt) {
-    throw new CliError2("set_not_staged", `Mixtape ${mixtape.logId} has no staged set video — run \`recordings promote <recordingId>\` first`);
-  }
-  return { setUrl: setVideoUrl(mixtape.logId) };
+  return {
+    setUrl: `${FOUND_BASE3}/${recording.r2Key.split("/").map(encodeURIComponent).join("/")}`
+  };
 }
 async function clipCutCommand(clipId, onProgress = () => {}) {
   const clips = await clipsListCommand();
@@ -4447,7 +4201,7 @@ __export(exports_recordings2, {
   recordingDeleteCommand: () => recordingDeleteCommand2,
   recordingCreateCommand: () => recordingCreateCommand2
 });
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
 async function recordingGet2(id) {
   const response = await adminApiGet(`/api/admin/recordings/${encodeURIComponent(id)}`);
   return response.recording;
@@ -4516,7 +4270,7 @@ async function recordingCreateCommand2(options = {}) {
   if (!options.video) {
     throw new CliError2("missing_video", "A recording needs a --video <file> to stage");
   }
-  if (!existsSync5(options.video)) {
+  if (!existsSync4(options.video)) {
     throw new CliError2("file_not_found", `Set-video master not found: ${options.video}`);
   }
   const created = await adminApiPost("/api/admin/recordings", {
@@ -4552,11 +4306,11 @@ async function recordingUpdateCommand2(id, options = {}) {
     body.parentId = options.parentId;
   }
   if (options.tracklistFile !== undefined) {
-    if (!existsSync5(options.tracklistFile)) {
+    if (!existsSync4(options.tracklistFile)) {
       throw new CliError2("file_not_found", `Tracklist file not found: ${options.tracklistFile}`);
     }
     try {
-      body.tracklistJson = JSON.parse(readFileSync5(options.tracklistFile, "utf8"));
+      body.tracklistJson = JSON.parse(readFileSync4(options.tracklistFile, "utf8"));
     } catch {
       throw new CliError2("invalid_tracklist", `Tracklist file is not valid JSON: ${options.tracklistFile}`);
     }
@@ -4601,12 +4355,12 @@ async function recordingReplaceCuesCommand2(id, options = {}) {
   if (!options.cuesFile) {
     throw new CliError2("missing_cues_file", "replace-cues needs a --cues-file <file> (the ordered cue array)");
   }
-  if (!existsSync5(options.cuesFile)) {
+  if (!existsSync4(options.cuesFile)) {
     throw new CliError2("file_not_found", `Cues file not found: ${options.cuesFile}`);
   }
   let cues;
   try {
-    cues = JSON.parse(readFileSync5(options.cuesFile, "utf8"));
+    cues = JSON.parse(readFileSync4(options.cuesFile, "utf8"));
   } catch {
     throw new CliError2("invalid_cues", `Cues file is not valid JSON: ${options.cuesFile}`);
   }
@@ -4632,8 +4386,8 @@ __export(exports_newsletter, {
   newsletterDraftCommand: () => newsletterDraftCommand,
   newsletterDeleteCommand: () => newsletterDeleteCommand
 });
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
-function buildBody3(options, { requireContent }) {
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+function buildBody2(options, { requireContent }) {
   const body = {};
   if (options.contentFile !== undefined) {
     body.contentJson = readContentFile(options.contentFile);
@@ -4652,10 +4406,10 @@ function buildBody3(options, { requireContent }) {
   return body;
 }
 function readContentFile(filePath) {
-  if (!existsSync6(filePath)) {
+  if (!existsSync5(filePath)) {
     throw new CliError2("file_not_found", `Content file not found: ${filePath}`);
   }
-  const text = readFileSync6(filePath, "utf-8");
+  const text = readFileSync5(filePath, "utf-8");
   try {
     return JSON.parse(text);
   } catch (error) {
@@ -4663,10 +4417,10 @@ function readContentFile(filePath) {
   }
 }
 async function newsletterDraftCommand(options) {
-  return adminApiPost("/api/admin/newsletter/editions", buildBody3(options, { requireContent: true }));
+  return adminApiPost("/api/admin/newsletter/editions", buildBody2(options, { requireContent: true }));
 }
 async function newsletterUpdateCommand(id, options) {
-  return adminApiPatch(`/api/admin/newsletter/editions/${encodeURIComponent(id)}`, buildBody3(options, { requireContent: false }));
+  return adminApiPatch(`/api/admin/newsletter/editions/${encodeURIComponent(id)}`, buildBody2(options, { requireContent: false }));
 }
 async function newsletterSendCommand(id) {
   return adminApiPost(`/api/admin/newsletter/editions/${encodeURIComponent(id)}/send`);
@@ -5290,7 +5044,7 @@ var init_format2 = __esm(() => {
 });
 
 // src/cli.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
 import path2 from "path";
 
 // ../../node_modules/commander/lib/error.js
@@ -7456,8 +7210,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: mixtapesCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
-    await runMixtapes(options, mixtapesCommand3);
+    const { mixtapesCommand: mixtapesCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapes(options, mixtapesCommand2);
   });
   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));
@@ -7619,24 +7373,24 @@ 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_mixtapes(), exports_mixtapes));
-    await runMixtapeCreate(options, mixtapeCreateCommand3);
+    const { mixtapeCreateCommand: mixtapeCreateCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapeCreate(options, mixtapeCreateCommand2);
   });
   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_mixtapes(), exports_mixtapes));
-    await runMixtapeUpdate(id, options, mixtapeUpdateCommand3);
+    const { mixtapeUpdateCommand: mixtapeUpdateCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapeUpdate(id, options, mixtapeUpdateCommand2);
   });
   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_mixtapes(), exports_mixtapes));
-    await runMixtapeMembers(id, refs, options, mixtapeMembersCommand3);
+    const { mixtapeMembersCommand: mixtapeMembersCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapeMembers(id, refs, options, mixtapeMembersCommand2);
   });
   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_mixtapes(), exports_mixtapes));
-    await runMixtapePublish(id, options, mixtapePublishCommand3);
+    const { mixtapePublishCommand: mixtapePublishCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapePublish(id, options, mixtapePublishCommand2);
   });
   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_mixtapes(), exports_mixtapes));
-    await runMixtapeDelete(id, options, mixtapeDeleteCommand3);
+    const { mixtapeDeleteCommand: mixtapeDeleteCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapeDelete(id, options, mixtapeDeleteCommand2);
   });
   adminMixtapes.command("list").description("List all mixtapes (including drafts)").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
     const { mixtapeListCommand: mixtapeListCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
@@ -7647,22 +7401,22 @@ function addAdminCommands(program2) {
     await runMixtapeGet(idOrLogId, options, mixtapeGetCommand2);
   });
   adminMixtapes.command("distribute").description("Push a promoted mixtape to YouTube (video) and Mixcloud (audio). The mixtape must already be promoted (`recordings promote`) \u2014 distribute is push-only.").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: mixtapeDistributeCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
-    await runMixtapeDistribute(idOrLogId, options, mixtapeDistributeCommand3);
+    const { mixtapeDistributeCommand: mixtapeDistributeCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapeDistribute(idOrLogId, options, mixtapeDistributeCommand2);
   });
   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);
   });
   adminMixtapes.command("resync").description("Re-push a published mixtape's YouTube chapters + Mixcloud sections from its current cues (no re-upload)").argument("[idOrLogId]").option("--youtube", "Only re-sync YouTube").option("--mixcloud", "Only re-sync Mixcloud").option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
-    const { mixtapeResyncCommand: mixtapeResyncCommand3 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
-    await runMixtapeResync(idOrLogId, options, mixtapeResyncCommand3);
+    const { mixtapeResyncCommand: mixtapeResyncCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
+    await runMixtapeResync(idOrLogId, options, mixtapeResyncCommand2);
   });
   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, --recording <id>, and/or --mixtape <id>)").option("--status <status>", "Filter by cut status (pending|done)").option("--recording <id>", "Filter by recording id").option("--mixtape <id>", "Filter by mixtape id").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
+  adminClips.command("list").description("List clips (filter by --status pending|done and/or --recording <id>)").option("--status <status>", "Filter by cut status (pending|done)").option("--recording <id>", "Filter by recording 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);
   });
@@ -7805,7 +7559,7 @@ async function runTrackPreviewArchive(idOrLogId, options, previewArchiveUploadCo
   console.log(`  mime: ${result.mime}`);
 }
 async function runTrackObserve(idOrLogId, options, trackObserveCommand2) {
-  const script = options.scriptFile ? readFileSync7(options.scriptFile, "utf8") : options.script;
+  const script = options.scriptFile ? readFileSync6(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]");
   }
@@ -7861,7 +7615,7 @@ async function runTrackContext(idOrLogId, options, trackContextCommand2) {
   }
 }
 async function runTrackNote(idOrLogId, options, trackNoteCommand2) {
-  const note = options.scriptFile ? readFileSync7(options.scriptFile, "utf8") : options.script;
+  const note = options.scriptFile ? readFileSync6(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]");
   }
@@ -8007,7 +7761,7 @@ async function runTrackVideo(idOrLogId, options, trackVideoCommand2) {
       return;
     }
     const candidate = path2.join(dir, name);
-    return existsSync7(candidate) ? candidate : undefined;
+    return existsSync6(candidate) ? candidate : undefined;
   };
   const resolveFile = (explicit, name) => {
     if (explicit) {
@@ -8184,56 +7938,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, mixtapeCreateCommand3) {
-  const result = await mixtapeCreateCommand3(options);
+async function runMixtapeCreate(options, mixtapeCreateCommand2) {
+  const result = await mixtapeCreateCommand2(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, mixtapeUpdateCommand3) {
+async function runMixtapeUpdate(id, options, mixtapeUpdateCommand2) {
   if (!id) {
     throw new Error("Missing mixtape id. Usage: fluncle admin mixtapes update <id>");
   }
-  const result = await mixtapeUpdateCommand3(id, options);
+  const result = await mixtapeUpdateCommand2(id, options);
   if (options.json) {
     printJson(result);
     return;
   }
   console.log(`Saved ${result.mixtape.id}.`);
 }
-async function runMixtapeMembers(id, refs, options, mixtapeMembersCommand3) {
+async function runMixtapeMembers(id, refs, options, mixtapeMembersCommand2) {
   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 mixtapeMembersCommand3(id, refs, options);
+  const result = await mixtapeMembersCommand2(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, mixtapePublishCommand3) {
+async function runMixtapePublish(id, options, mixtapePublishCommand2) {
   if (!id) {
     throw new Error("Missing mixtape id. Usage: fluncle admin mixtapes publish <id>");
   }
-  const result = await mixtapePublishCommand3(id);
+  const result = await mixtapePublishCommand2(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, mixtapeDistributeCommand3) {
+async function runMixtapeDistribute(idOrLogId, options, mixtapeDistributeCommand2) {
   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 mixtapeDistributeCommand3(idOrLogId, options, onProgress);
+  const result = await mixtapeDistributeCommand2(idOrLogId, options, onProgress);
   if (options.json) {
     printJson(result);
     return;
@@ -8254,12 +8008,12 @@ async function runMixtapePublishYoutube(idOrLogId, options, publishYoutubeComman
   }
   console.log(`YouTube video is now public: ${result.url}`);
 }
-async function runMixtapeResync(idOrLogId, options, mixtapeResyncCommand3) {
+async function runMixtapeResync(idOrLogId, options, mixtapeResyncCommand2) {
   if (!idOrLogId) {
     throw new Error("Missing mixtape id. Usage: fluncle admin mixtapes resync <idOrLogId>");
   }
   const onProgress = options.json ? () => {} : (message) => console.log(message);
-  const result = await mixtapeResyncCommand3(idOrLogId, options, onProgress);
+  const result = await mixtapeResyncCommand2(idOrLogId, options, onProgress);
   if (options.json) {
     printJson(result);
     return;
@@ -8269,14 +8023,14 @@ async function runMixtapeResync(idOrLogId, options, mixtapeResyncCommand3) {
   console.log(`Re-synced ${result.logId} (fluncle://${result.logId}).
 ${links}`);
 }
-async function runMixtapeDelete(id, options, mixtapeDeleteCommand3) {
+async function runMixtapeDelete(id, options, mixtapeDeleteCommand2) {
   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 mixtapeDeleteCommand3(id);
+  await mixtapeDeleteCommand2(id);
   if (options.json) {
     printJson({ id, ok: true });
     return;
@@ -8301,7 +8055,6 @@ async function runMixtapeList(options, mixtapeListCommand2) {
 }
 async function runClipsList(options, clipsListCommand2) {
   const clips = await clipsListCommand2({
-    mixtapeId: options.mixtape,
     recordingId: options.recording,
     status: options.status
   });
@@ -8314,7 +8067,7 @@ async function runClipsList(options, clipsListCommand2) {
     return;
   }
   for (const clip of clips) {
-    const source = clip.recordingId ?? clip.mixtapeId ?? "\u2014";
+    const source = clip.recordingId ?? "\u2014";
     console.log(`${clip.id}	${clip.status}	${source}	${clip.inMs}-${clip.outMs}ms	x=${clip.xOffset}`);
   }
 }
@@ -8477,8 +8230,8 @@ async function runRecent(options, recentCommand3) {
   console.log(trackRows2(tracks).join(`
 `));
 }
-async function runMixtapes(options, mixtapesCommand3) {
-  const mixtapes = await mixtapesCommand3();
+async function runMixtapes(options, mixtapesCommand2) {
+  const mixtapes = await mixtapesCommand2();
   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.86.0"
+  "version": "0.87.0"
 }