@audiofool/moondog 0.2.2 → 0.3.0-beta.2

package/src/core/moondog-application.mjs

@@ -5,6 +5,8 @@ import { compactListenerProfile, readListenerProfile } from "../profile/listener
 import { mixCounts, songKeys } from "../profile/moondog-suggestions.mjs";
 import { ARTIST_CREDIT_SEPARATORS } from "./listener-avoids.mjs";
 import { textNamesSong } from "./track-title.mjs";
+import { compileTaste, tasteSources } from "../profile/taste-compiler.mjs";
+import { stableAudioPrompt } from "../integrations/stable-audio/local-generator.mjs";
 
 import {
   readAppleMusicSourceStatus,
@@ -221,6 +223,8 @@ export class MoondogApplication {
     musicSimilarity = null,
     musicPreviewPlayer = null,
     neteasePlayer = null,
+    localGenerator = null,
+    atmosphereStream = null,
     musicApp = null,
     agentHostNotes = [],
     artistIdentityResolver = null,
@@ -266,6 +270,10 @@ export class MoondogApplication {
     this.musicPreviewPlayer = musicPreviewPlayer;
     // NetEase Cloud Music through ncm-cli (src/integrations/netease), shared by every conversation.
     this.neteasePlayer = neteasePlayer;
+    // Stable Audio 3 on this Mac (src/integrations/stable-audio), shared by every conversation, so one track is made at a time.
+    this.localGenerator = localGenerator;
+    // Moondog's atmosphere stream on that generator, one per room (src/integrations/stable-audio).
+    this.atmosphereStream = atmosphereStream;
     // The Music app on this Mac (src/integrations/apple-music/music-app.mjs), read for what the
     // listener plays there themselves.
     this.musicApp = musicApp;
@@ -523,6 +531,204 @@ export class MoondogApplication {
     return this.neteasePlayer;
   }
 
+  // Moondog makes music on this Mac once the listener turned it on and the install is ready, in a
+  // host whose player can play a local track: the terminal room and the window, not one-shot commands.
+  localGenerationReady() {
+    return this.localGenerator?.ready?.() === true && typeof this.musicPreviewPlayer?.playGenerated === "function";
+  }
+
+  generationStatus() {
+    return this.localGenerator?.status?.() ?? null;
+  }
+
+  // Moondog's newest tracks and how each landed, for the agent to calibrate the next one by. They
+  // are outcomes of Moondog's own picks, never the listener's taste.
+  // Each reply reads the made tracks again, so the other surface's tracks and outcomes show too.
+  async refreshMadeTracks() {
+    if (this.localGenerationReady()) await this.localGenerator.load?.();
+  }
+
+  madeTracks() {
+    if (!this.localGenerationReady()) return null;
+    const tracks = this.localGenerator.recentTracks?.(5) ?? [];
+    return tracks.length ? tracks : null;
+  }
+
+  // Plays a track Moondog made again. A track the listener named in their own words is their pick:
+  // it stays out of the ledger and counts as their replay. Otherwise it is Moondog's pick again.
+  async playMadeTrack({ id } = {}, { request = null, signal } = {}) {
+    if (!this.localGenerationReady()) throw Object.assign(new Error("Local generation is not ready. The listener can turn it on in Settings or with /generation."), { code: "generation_not_ready" });
+    const receipt = await this.localGenerator.receipt(id);
+    if (!receipt) throw Object.assign(new Error("There is no track Moondog made with that id on this Mac."), { code: "made_track_not_found" });
+    const file = await this.localGenerator.trackFile(id);
+    if (!file) throw Object.assign(new Error("That track was part of a stream, which keeps only its newest tracks' audio; its receipt is still here."), { code: "made_track_audio_not_kept" });
+    // Playing one of Moondog's tracks again ends its stream, on every surface.
+    const endedStream = await this.#endStream("replaced");
+    const title = String(receipt.title ?? "");
+    // Named means quoted, or the title with Moondog, as on every play path: an open request shares
+    // words with the plain titles Moondog gives its records ("something for a rainy day").
+    const named = typeof request === "string" && textNamesSong(request, title, ["Moondog"]);
+    await this.quietOtherPlayers("apple_music", { signal });
+    // A reply stopped before the track starts plays nothing, and no replay is recorded.
+    if (signal?.aborted) throw Object.assign(new Error("Nothing was played, because the reply was stopped."), { code: "generation_stopped" });
+    // Nothing waits between this check and the play; the replay is written once it plays. The ended
+    // stream's track it cuts off, or its queued one that started meanwhile, says nothing about the listener.
+    if (endedStream) this.localGenerator.discard?.();
+    this.localGenerator.restart?.(id);
+    this.musicPreviewPlayer.playGenerated({ id, title, seconds: receipt.audio?.duration_seconds, file });
+    if (!named) this.#noteGeneratedPlay({ id, title });
+    await this.localGenerator.recordReplay?.(id, named ? "listener" : "moondog");
+    return { state: "playing", track: { id, title, seconds: receipt.audio?.duration_seconds ?? null }, chosen_by: named ? "listener" : "moondog" };
+  }
+
+  // Makes one instrumental track from the listener's taste and plays it in Moondog's own player.
+  // The agent proposes sound descriptors, each with its source; the taste compiler keeps only the
+  // ones it can trace and none that names an artist or a song. The track and its receipt stay on
+  // this Mac, and its play goes in the ledger as Moondog's own, never as the listener's attention.
+  // moment and request come from the agent's host, not from the model.
+  async makeTrack({ descriptors, bpm, bpmSource, seconds, title } = {}, { moment = null, request = null, transient = false, signal, onProgress } = {}) {
+    const { compiled, receipt } = await this.#compileForGeneration({ descriptors, bpm, bpmSource, title }, { moment, request, transient });
+    if (!compiled.usable) {
+      return { state: "not_made", reason: compiled.descriptors.length ? "needs_a_sound" : "no_traceable_descriptors", dropped: compiled.dropped };
+    }
+    const prompt = stableAudioPrompt(compiled);
+    const endedStream = await this.#endStream("replaced");
+    const made = await this.localGenerator.generate({ prompt, seconds, title: compiled.title, receipt }, { signal, onProgress });
+    // A reply stopped as the track finished keeps the track, but plays nothing over what is on now.
+    await this.quietOtherPlayers("apple_music", { signal });
+    // The terminal plays the file itself; the window asks for it by id and never sees the path.
+    const file = await this.localGenerator.trackFile(made.id);
+    // A reply stopped while the track was made, or while the other players paused, keeps the track but plays nothing.
+    if (signal?.aborted) throw Object.assign(new Error("The track was made but not played, because the reply was stopped."), { code: "generation_stopped" });
+    // The replaced stream's track it cuts off was stopped by Moondog, not left by the listener.
+    if (endedStream) this.localGenerator.discard?.();
+    this.musicPreviewPlayer.playGenerated({ id: made.id, title: made.title, seconds: made.duration_seconds, file });
+    this.#noteGeneratedPlay(made);
+    return { state: "playing", track: { id: made.id, title: made.title, seconds: made.duration_seconds, seed: made.seed },
+      prompt, shaped_by: compiled.descriptors, sources: tasteSources(compiled.descriptors), left_out: compiled.dropped,
+      ...(compiled.bpm ? { bpm: compiled.bpm } : {}), elapsed_ms: made.elapsed_ms };
+  }
+
+  // The taste compiled for a track or a stream, and what its receipts keep of why.
+  async #compileForGeneration({ descriptors, bpm, bpmSource, title }, { moment, request, transient }) {
+    if (!this.localGenerationReady()) throw Object.assign(new Error("Local generation is not ready. The listener can turn it on in Settings or with /generation."), { code: "generation_not_ready" });
+    this.requireListenerAvoids();
+    const context = await this.#tasteContext({ descriptors, moment, request });
+    const compiled = compileTaste({ descriptors, bpm, bpm_source: bpmSource, title }, context);
+    return { compiled, receipt: {
+      shaped_by: compiled.descriptors, left_out: compiled.dropped,
+      ...(compiled.bpm ? { bpm: compiled.bpm, bpm_source: compiled.bpm_source } : {}),
+      // A conversation that read Spotify stays out of memory, and its words out of the receipt too.
+      ...(typeof request === "string" && !transient && !this.transientSpotifyContext ? { request: Array.from(request).slice(0, 300).join("") } : {}),
+      avoids_in_force: context.avoids.length,
+    } };
+  }
+
+  // A stream needs a player that can queue a made track behind the one playing.
+  streamReady() {
+    return this.localGenerationReady() && typeof this.atmosphereStream?.start === "function" &&
+      typeof this.musicPreviewPlayer?.enqueueGenerated === "function";
+  }
+
+  streamStatus() {
+    return this.atmosphereStream?.status?.() ?? null;
+  }
+
+  // Starts Moondog's atmosphere stream from the listener's taste: its first track plays now, and
+  // each next one is made while the last plays. Every track goes in the ledger as Moondog's pick.
+  async startStream({ descriptors, bpm, bpmSource, seconds, minutes, title } = {}, { moment = null, request = null, transient = false, signal, onProgress } = {}) {
+    if (!this.streamReady()) throw Object.assign(new Error("A stream can't run here. Music making must be on, in the terminal room or the window."), { code: "stream_not_ready" });
+    const { compiled, receipt } = await this.#compileForGeneration({ descriptors, bpm, bpmSource, title }, { moment, request, transient });
+    if (!compiled.usable) {
+      return { state: "not_made", reason: compiled.descriptors.length ? "needs_a_sound" : "no_traceable_descriptors", dropped: compiled.dropped };
+    }
+    await this.#endStream("replaced");
+    // Other music pauses only once the first track exists, as for a single track.
+    let started;
+    try {
+      started = await this.atmosphereStream.start({ compiled, title: compiled.title, seconds, minutes, receipt },
+        { signal, onProgress, onTrack: (track) => this.#noteGeneratedPlay(track), beforePlay: () => this.quietOtherPlayers("apple_music", { signal }) });
+    } catch (error) {
+      // The listener turned it off while its first track was made: their choice, not a failure to retry.
+      if (error?.code === "generation_stopped" && error.ended === "asked" && !signal?.aborted) return { state: "not_made", reason: "stopped_by_listener" };
+      throw error;
+    }
+    const { made, prompt } = started;
+    return { state: "streaming", minutes, track: { id: made.id, title: made.title, seconds: made.duration_seconds, seed: made.seed },
+      prompt, shaped_by: compiled.descriptors, sources: tasteSources(compiled.descriptors), left_out: compiled.dropped,
+      ...(compiled.bpm ? { bpm: compiled.bpm } : {}), elapsed_ms: made.elapsed_ms };
+  }
+
+  // A single track or a new stream takes over from a running stream, once its next track stops being made.
+  // The stream's track plays on until the new one starts, so nothing goes silent while that is made.
+  // Says whether a stream ended.
+  async #endStream(reason) {
+    if (!this.atmosphereStream?.active?.()) return false;
+    this.atmosphereStream.stop(reason);
+    for (let waited = 0; this.localGenerator?.busy?.() && waited < 5_000; waited += 100) await delay(100);
+    return true;
+  }
+
+  stopStream() {
+    const stopped = this.atmosphereStream?.stop?.("asked") ?? null;
+    return stopped ? { state: "stopped", tracks_made: stopped.tracks_made } : { state: "not_running" };
+  }
+
+  // What the window and the terminal show of the stream: { phase, started_at, ends_at, tracks_made }, or null.
+  streamView() {
+    return this.atmosphereStream?.view?.() ?? null;
+  }
+
+  // Each change of the stream, as { view, ended }; a host without a stream hears nothing.
+  subscribeStream(listener) {
+    return this.atmosphereStream?.subscribe?.(listener) ?? (() => {});
+  }
+
+  // Whether a Spotify device is this Mac, where its music and Moondog's would play over each other.
+  spotifyOnThisMac(device) {
+    return spotifyOnThisMac(device);
+  }
+
+  // What the compiler may trace a descriptor to. Each cited finding is read from the saved reading.
+  async #tasteContext({ descriptors, moment, request }) {
+    const choices = this.domainServices?.listenerChoices?.()?.items ?? [];
+    // Every Avoid in force, not only the newest choices, so an old one still keeps its artist out.
+    let avoids = null;
+    try { avoids = this.domainServices?.activeAvoids?.() ?? null; } catch { /* The newest choices still hold. */ }
+    const recent = this.domainServices?.recentAttention?.() ?? null;
+    const cited = [...new Set((Array.isArray(descriptors) ? descriptors : [])
+      .filter((descriptor) => descriptor?.source === "reading" && typeof descriptor.from === "string").map((descriptor) => descriptor.from.trim()))].slice(0, 12);
+    const claims = new Map();
+    let revisionId = null;
+    for (const claimId of cited) {
+      try {
+        const reading = await this.getListenerProfile({ claimId });
+        if (reading?.claim) { claims.set(claimId, reading.claim); revisionId ??= reading.revision_id ?? null; }
+      } catch { /* Not a finding of the saved reading; the compiler drops it. */ }
+    }
+    let listened = null;
+    try { listened = this.domainServices?.listenedNames?.() ?? null; } catch { /* Without a history, only choices are checked. */ }
+    return {
+      claim: (id) => claims.get(id) ?? null, revisionId,
+      likes: choices.filter((choice) => choice.stance === "like"),
+      avoids: Array.isArray(avoids) ? avoids : choices.filter((choice) => choice.stance === "avoid"),
+      recentArtists: recent?.top_artists ?? [],
+      ...(recent?.from_date ? { recentWindow: { from_date: recent.from_date, through_date: recent.through_date } } : {}),
+      historyArtists: listened?.artists ?? [], historyTitles: listened?.titles ?? [],
+      avoidsName: (name) => !this.avoidAllows({ artist_credit: name, artists: [name] }),
+      moment, request,
+    };
+  }
+
+  // A track Moondog made and played is its own pick by definition, so no listener-named check applies.
+  #noteGeneratedPlay(made) {
+    if (typeof this.domainServices?.recordMoondogSuggestions !== "function") return;
+    try {
+      this.domainServices.recordMoondogSuggestions([{ service: "moondog", action: "generated.play", providerTrackId: `moondog:generated:${made.id}`,
+        title: made.title, artistCredit: "", requestedAt: new Date(this.spotifyContextClock()).toISOString() }]);
+    } catch { /* The track still plays; only its origin goes unrecorded. The receipt stays. */ }
+  }
+
   async searchNetease({ query, limit, intent } = {}) {
     const songs = await this.requireNetease().search({ query, limit, intent });
     return Array.isArray(songs) ? this.#withSuggestedBefore(songs, song => ({ service: "netease",
@@ -532,10 +738,13 @@ export class MoondogApplication {
   async playNetease({ items, mode, intent } = {}) {
     const player = this.requireNetease();
     this.requireListenerAvoids();
-    if (mode !== "queue") await this.quietOtherPlayers("netease");
+    const quiet = () => this.quietOtherPlayers("netease");
+    if (mode !== "queue") await quiet();
     // A found song lists its artists; a song asked for by name has only the name it was asked by.
-    const receipt = await player.play({ items, mode, intent, allow: (song) => this.avoidAllows(Array.isArray(song.artists)
-      ? { title: song.title, artist_credit: song.artists.join(", "), artists: song.artists } : song) });
+    // A queue with nothing loaded starts its first song, and quiets the others just before.
+    const receipt = await player.play({ items, mode, intent, ...(mode === "queue" ? { beforePlay: quiet } : {}),
+      allow: (song) => this.avoidAllows(Array.isArray(song.artists)
+        ? { title: song.title, artist_credit: song.artists.join(", "), artists: song.artists } : song) });
     if (["playing", "queued"].includes(receipt?.mode)) {
       const songs = receipt.songs ?? [];
       const slots = this.#mixSlots(songs.map((song) => ({ title: song.title, artists: song.artists })));
@@ -550,8 +759,13 @@ export class MoondogApplication {
 
   async controlNetease({ action, positionSeconds } = {}) {
     const player = this.requireNetease();
+    const quiet = () => this.quietOtherPlayers("netease");
+    if (action === "resume") await quiet();
     if (action === "seek") await player.seek({ positionMs: Math.max(0, Number(positionSeconds) || 0) * 1000 });
-    else if (["pause", "resume", "next", "previous", "stop"].includes(action)) await player[action]();
+    // Next and previous start a song, so the other players go quiet just before; a refusal or a
+    // previous that only rewinds starts none.
+    else if (action === "next" || action === "previous") await player[action]({ beforePlay: quiet });
+    else if (["pause", "resume", "stop"].includes(action)) await player[action]();
     else throw Object.assign(new Error(`Unknown NetEase action: ${action}`), { code: "netease_failed" });
     return await player.nowPlaying();
   }
@@ -645,16 +859,21 @@ export class MoondogApplication {
         if (starting !== "netease" && this.neteaseReady() && (await this.neteasePlayer.nowPlaying()).state === "playing") await this.neteasePlayer.pause();
       })(),
       (async () => {
-        if (starting !== "apple_music") this.musicPreviewPlayer?.stop?.();
+        if (starting === "apple_music") return;
+        // Other music ends Moondog's stream too, even while its next track is still being made.
+        this.atmosphereStream?.stop?.("other_music");
+        this.musicPreviewPlayer?.stop?.();
       })(),
     ]);
   }
 
-  // The service just left stops playing, so two services never play at once.
+  // The service just left stops playing, so two services never play at once. Moondog's stream is its
+  // own channel, not a service: its made tracks play on, and it ends only when a service song plays.
   async #stopPlaybackService(service) {
     try {
       if (service === "apple_music") {
-        this.musicPreviewPlayer?.stop?.();
+        // Apple Music's songs in Moondog's player stop; a player that can't say what it holds stops, as before.
+        if (this.musicPreviewPlayer?.holdsCatalogSongs?.() !== false) this.musicPreviewPlayer?.stop?.();
         // The listener's own Music app too, when it plays.
         if ((await this.musicApp?.nowPlaying?.())?.state === "playing") await this.musicApp.pause();
       } else if (service === "netease" && this.neteasePlayer?.ready?.() === true) await this.neteasePlayer.stop();
@@ -706,6 +925,9 @@ export class MoondogApplication {
     }
     if (avoided) found.skipped_avoided_count = avoided;
     if (found.played.length) {
+      // Songs Moondog plays end its stream, even one whose first track is still being made; the
+      // stream's own tracks also start through quietOtherPlayers("apple_music"), so it can't do this.
+      this.atmosphereStream?.stop?.("other_music");
       await this.quietOtherPlayers("apple_music");
       await this.musicPreviewPlayer.play(structuredClone(found.played), found.album ? { album: structuredClone(found.album) } : {});
     }
@@ -1910,8 +2132,6 @@ export class MoondogApplication {
     this.requireSpotifyNonRemovalAction();
     const transaction = this.pendingPlaylistPromptTransaction;
     if (!transaction) throw spotifyResolutionError("spotify_queue_request_required", "Queueing runs inside a listener request.");
-    // An idle device starts the first song.
-    await this.quietOtherPlayers("spotify", { signal });
     // The model acts on the listener's words, as for a single queue entry. A parsed
     // count only sizes the batch; failing to parse a phrasing never blocks it.
     const intent = transaction.queueIntent ?? null;
@@ -3106,8 +3326,11 @@ export class MoondogApplication {
         const service = this.requireSpotifyService();
         target ??= await service.queueTarget({ ...(deviceId ? { deviceId } : {}) }, { signal });
         const device = target.deviceId ? { deviceId: target.deviceId } : {};
-        // Nothing is playing, so a queue entry has nowhere to go: start this song instead.
+        // Nothing is playing, so a queue entry has nowhere to go: start this song instead. That starts
+        // music, so the other players go quiet first; a queue behind a song already there starts none.
         const start = async () => {
+          await this.quietOtherPlayers("spotify", { signal });
+          signal?.throwIfAborted();
           dispatching = true;
           const receipt = await service.resume({ uris: [uri], ...device }, { signal });
           started = label(track);
@@ -3298,15 +3521,18 @@ export class MoondogApplication {
         ...this.webLookupOptions(),
       musicPreviewReady: this.musicPreviewReady(),
       tasteChoicesReady: this.tasteChoicesReady(),
+      localGenerationReady: this.localGenerationReady(),
       }).map(capability => capability.state === "enabled" && this.#playbackServiceExcludes(capability.id)
         ? { ...capability, state: "blocked", blocked_by: capability.id === "listening.now" ? "no_readable_player" : capability.id === "music_app.control" ? "no_music_app" : capability.id === "playback.service" ? "no_playback_service"
-          : neteaseCapabilities.has(capability.id) ? "netease_not_ready" : "playback_service_not_spotify" } : capability),
+          : neteaseCapabilities.has(capability.id) ? "netease_not_ready" : capability.id.startsWith("music.generate.stream") ? "stream_not_ready"
+          : "playback_service_not_spotify" } : capability),
     };
   }
 
   // With another music service chosen, Spotify does not play or queue anything; NetEase's
   // tools exist only while it plays. What the listener plays is read wherever it can be.
   #playbackServiceExcludes(capabilityId) {
+    if (capabilityId.startsWith("music.generate.stream")) return !this.streamReady();
     if (capabilityId === "listening.now") return !this.listeningReadable();
     if (capabilityId === "music_app.control") return this.musicApp?.available !== true;
     if (capabilityId === "playback.service") return !this.playbackStatus().services.some((entry) => entry.available);
@@ -3333,6 +3559,7 @@ export class MoondogApplication {
       ...this.webLookupOptions(),
       musicPreviewReady: this.musicPreviewReady(),
       tasteChoicesReady: this.tasteChoicesReady(),
+      localGenerationReady: this.localGenerationReady(),
     }).filter(descriptor => !this.#playbackServiceExcludes(descriptor.capability_id));
   }
 
@@ -3806,6 +4033,12 @@ export class MoondogApplication {
         ok: true,
         state: this.spotifyReady() ? "spotify_control" : "disabled",
       },
+      {
+        id: "music.generate.local",
+        ok: this.localGenerationReady(),
+        state: this.generationStatus()?.state ?? "unavailable",
+        optional_for_local_commands: true,
+      },
       {
         id: "spotify.connection",
         ok: this.spotifyReady(),

package/src/i18n/messages/de.mjs

@@ -130,6 +130,9 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nGespeichert: Du magst ${name}. Sag mir jederzeit, wenn du das ändern willst.`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nGespeichert: Ich lasse ${name} aus allem heraus, was ich spiele und vorschlage. Sag mir jederzeit, wenn du das ändern willst.`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nZurückgenommen: deine frühere Wahl zu ${name}.`; },
+  "generate.made": ({ title, length, seed }) => `Auf diesem Mac mit Stable Audio 3 gemacht: „${title}“ (${length}, Seed ${seed}).`,
+  "generate.stream": ({ minutes }) => `Der Stream läuft auf diesem Mac weiter, jedes Mal mit einem neuen Stück, bis zu ${minutes} Minuten. Du kannst ihn jederzeit stoppen.`,
+  "onAir.request": "Geh auf Sendung: Lass die Musik für jetzt weiterlaufen",
   "turn.cancelled": "Weitere Schritte abgebrochen.",
   "turn.interrupted": "Die Antwort wurde unterbrochen. Die erfassten Spotify-Ergebnisse stehen unten; keine Aktion wurde wiederholt.",
 };

package/src/i18n/messages/en.mjs

@@ -131,6 +131,10 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nSaved: you like ${name}. Tell me any time to change it.`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nSaved: I'll keep ${name} out of what I play and suggest. Tell me any time to change it.`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nUndone: your earlier choice about ${name}.`; },
+  "generate.made": ({ title, length, seed }) => `Made on this Mac with Stable Audio 3: "${title}" (${length}, seed ${seed}).`,
+  "generate.stream": ({ minutes }) => `The stream keeps going on this Mac, a new track each time, for up to ${minutes} minutes. Stop it any time.`,
+  // What the listener says to go on air, in the language the reply follows (/onair in the terminal).
+  "onAir.request": "Go on air: keep the music going for right now",
   "turn.cancelled": "Cancelled further work.",
   "turn.interrupted": "The response was interrupted. The recorded Spotify outcomes are below; no action was replayed.",
 };

package/src/i18n/messages/es.mjs

@@ -130,6 +130,9 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nGuardado: te gusta ${name}. Dímelo cuando quieras cambiarlo.`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nGuardado: dejaré ${name} fuera de lo que pongo y te sugiero. Dímelo cuando quieras cambiarlo.`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nDeshecho: tu elección anterior sobre ${name}.`; },
+  "generate.made": ({ title, length, seed }) => `Hecho en este Mac con Stable Audio 3: «${title}» (${length}, semilla ${seed}).`,
+  "generate.stream": ({ minutes }) => `El flujo sigue en este Mac, con una pista nueva cada vez, hasta ${minutes} minutos. Puedes pararlo cuando quieras.`,
+  "onAir.request": "Sal al aire: que la música siga sonando para este momento",
   "turn.cancelled": "Cancelé el resto.",
   "turn.interrupted": "La respuesta se interrumpió. Abajo están los resultados registrados en Spotify; no se repitió ninguna acción.",
 };

package/src/i18n/messages/fr.mjs

@@ -130,6 +130,9 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `« ${title} » de ${artist}` : artist; return `\n\nEnregistré : vous aimez ${name}. Dites-le-moi quand vous voulez pour le changer.`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `« ${title} » de ${artist}` : artist; return `\n\nEnregistré : je laisserai ${name} de côté dans ce que je joue et propose. Dites-le-moi quand vous voulez pour le changer.`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `« ${title} » de ${artist}` : artist; return `\n\nAnnulé : votre choix précédent sur ${name}.`; },
+  "generate.made": ({ title, length, seed }) => `Fait sur ce Mac avec Stable Audio 3 : « ${title} » (${length}, graine ${seed}).`,
+  "generate.stream": ({ minutes }) => `Le flux continue sur ce Mac, avec un nouveau morceau à chaque fois, jusqu'à ${minutes} minutes. Vous pouvez l'arrêter à tout moment.`,
+  "onAir.request": "Prends l'antenne : que la musique continue pour ce moment",
   "turn.cancelled": "Suite annulée.",
   "turn.interrupted": "La réponse a été interrompue. Les résultats Spotify enregistrés figurent ci-dessous ; aucune action n'a été relancée.",
 };

package/src/i18n/messages/it.mjs

@@ -130,6 +130,9 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `"${title}" di ${artist}` : artist; return `\n\nSalvato: ti piace ${name}. Dimmelo quando vuoi cambiarlo.`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `"${title}" di ${artist}` : artist; return `\n\nSalvato: terrò ${name} fuori da ciò che suono e ti propongo. Dimmelo quando vuoi cambiarlo.`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" di ${artist}` : artist; return `\n\nAnnullato: la tua scelta precedente su ${name}.`; },
+  "generate.made": ({ title, length, seed }) => `Fatto su questo Mac con Stable Audio 3: «${title}» (${length}, seed ${seed}).`,
+  "generate.stream": ({ minutes }) => `Il flusso continua su questo Mac, con un brano nuovo ogni volta, fino a ${minutes} minuti. Puoi fermarlo quando vuoi.`,
+  "onAir.request": "Vai in onda: tieni la musica accesa per adesso",
   "turn.cancelled": "Ho annullato il resto.",
   "turn.interrupted": "La risposta si è interrotta. Gli esiti di Spotify registrati sono qui sotto; nessuna azione è stata ripetuta.",
 };

package/src/i18n/messages/ja.mjs

@@ -130,6 +130,9 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `${artist}の「${title}」` : artist; return `\n\n保存しました: ${name}が好き。変えたいときはいつでも言ってください。`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `${artist}の「${title}」` : artist; return `\n\n保存しました: ${name}は再生にもおすすめにも入れません。変えたいときはいつでも言ってください。`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `${artist}の「${title}」` : artist; return `\n\n取り消しました: ${name}についての前の選択。`; },
+  "generate.made": ({ title, length, seed }) => `この Mac の Stable Audio 3 で作りました：「${title}」（${length}、シード ${seed}）。`,
+  "generate.stream": ({ minutes }) => `この Mac で一曲ずつ新しい曲を作り続けます（最長 ${minutes} 分）。いつでも止められます。`,
+  "onAir.request": "オンエアして。今の気分に合わせて音楽をかけ続けて",
   "turn.cancelled": "以降の処理をキャンセルしました。",
   "turn.interrupted": "返事が中断されました。記録された Spotify の操作結果は下のとおりです。操作は繰り返していません。",
 };

package/src/i18n/messages/ko.mjs

@@ -130,6 +130,9 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `${artist}의 "${title}"` : artist; return `\n\n저장했습니다: ${name}을(를) 좋아하신다고요. 바꾸고 싶으면 언제든 말씀해 주세요.`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `${artist}의 "${title}"` : artist; return `\n\n저장했습니다: ${name}은(는) 재생하거나 추천하지 않겠습니다. 바꾸고 싶으면 언제든 말씀해 주세요.`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `${artist}의 "${title}"` : artist; return `\n\n취소했습니다: ${name}에 대한 이전 선택.`; },
+  "generate.made": ({ title, length, seed }) => `이 Mac의 Stable Audio 3로 만들었습니다: "${title}" (${length}, 시드 ${seed}).`,
+  "generate.stream": ({ minutes }) => `이 Mac에서 매번 새 곡을 만들며 최대 ${minutes}분 동안 이어집니다. 언제든 멈출 수 있습니다.`,
+  "onAir.request": "방송 시작해 줘. 지금 분위기에 맞춰 음악을 계속 틀어 줘",
   "turn.cancelled": "남은 작업을 취소했습니다.",
   "turn.interrupted": "답변이 중단되었습니다. 기록된 Spotify 결과는 아래와 같으며, 어떤 작업도 다시 실행하지 않았습니다.",
 };

package/src/i18n/messages/pt.mjs

@@ -130,6 +130,9 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nSalvo: você gosta de ${name}. É só me dizer quando quiser mudar.`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nSalvo: vou deixar ${name} fora do que eu toco e sugiro. É só me dizer quando quiser mudar.`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nDesfeito: sua escolha anterior sobre ${name}.`; },
+  "generate.made": ({ title, length, seed }) => `Feito neste Mac com o Stable Audio 3: "${title}" (${length}, semente ${seed}).`,
+  "generate.stream": ({ minutes }) => `O fluxo continua neste Mac, com uma faixa nova a cada vez, por até ${minutes} minutos. Pare quando quiser.`,
+  "onAir.request": "Entre no ar: mantenha a música tocando para agora",
   "turn.cancelled": "Cancelei o resto.",
   "turn.interrupted": "A resposta foi interrompida. Abaixo estão os resultados registrados no Spotify; nenhuma ação foi repetida.",
 };

package/src/i18n/messages/zh-Hant.mjs

@@ -130,6 +130,9 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已儲存：你喜歡${name}。想改的話隨時告訴我。`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已儲存：我播放和推薦時都會避開${name}。想改的話隨時告訴我。`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已撤銷：你之前對${name}的選擇。`; },
+  "generate.made": ({ title, length, seed }) => `用這台 Mac 上的 Stable Audio 3 做的：「${title}」（${length}，種子 ${seed}）。`,
+  "generate.stream": ({ minutes }) => `音樂流會在這台 Mac 上一首接一首地做下去，最多 ${minutes} 分鐘，隨時可以停。`,
+  "onAir.request": "開播吧，照著現在的感覺一直放下去",
   "turn.cancelled": "已取消後續操作。",
   "turn.interrupted": "回覆中斷了。已記錄的 Spotify 結果如下；沒有重新執行任何操作。",
 };

package/src/i18n/messages/zh.mjs

@@ -130,6 +130,9 @@ export default {
   "choice.like": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已保存：你喜欢${name}。想改的话随时告诉我。`; },
   "choice.avoid": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已保存：我播放和推荐时都会避开${name}。想改的话随时告诉我。`; },
   "choice.retract": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已撤销：你之前对${name}的选择。`; },
+  "generate.made": ({ title, length, seed }) => `用这台 Mac 上的 Stable Audio 3 做的：「${title}」（${length}，种子 ${seed}）。`,
+  "generate.stream": ({ minutes }) => `音乐流会在这台 Mac 上一首接一首地做下去，最多 ${minutes} 分钟，随时可以停。`,
+  "onAir.request": "开播吧，照着现在的感觉一直放下去",
   "turn.cancelled": "已取消后续操作。",
   "turn.interrupted": "回复中断；已确认的 Spotify 操作结果如下。未重新执行任何操作。",
 };

package/src/i18n/screen/es.mjs

@@ -1027,4 +1027,37 @@ export default {
   "Skipped. /service and /model are here when you want them.": "Omitido. /service y /model siguen aquí cuando los quieras.",
   "Saving your music service...": "Guardando tu servicio de música...",
   "Choose where Moondog plays music": "Elige dónde pone Moondog la música",
+  "Make music on this Mac with Stable Audio 3": "Hacer música en este Mac con Stable Audio 3",
+  "Stop making music here": "Dejar de hacer música aquí",
+  "Making music on this Mac": "Hacer música en este Mac",
+  "Made by Moondog": "Hecho por Moondog",
+  "Stable Audio 3 needs a Mac with Apple silicon, so Moondog can't make music here.": "Stable Audio 3 necesita un Mac con Apple silicon, así que Moondog no puede hacer música aquí.",
+  "Moondog makes music on this Mac with Stable Audio 3, powered by Stability AI. Ask for a track. Stable Audio 3 runs offline, and the track stays on this Mac.": "Moondog hace música en este Mac con Stable Audio 3, powered by Stability AI. Pide una pista. Stable Audio 3 funciona sin conexión y la pista se queda en este Mac.",
+  "Making music on this Mac is off. Stable Audio 3 is ready at {folder}; turn it on with /generation on.": "Hacer música en este Mac está desactivado. Stable Audio 3 está listo en {folder}; actívalo con /generation on.",
+  "Making music on this Mac is off, and Stable Audio 3 isn't at {folder}. Install Stability AI's MLX build from github.com/Stability-AI/stable-audio-3, then use /generation on with its folder.": "Hacer música en este Mac está desactivado, y Stable Audio 3 no está en {folder}. Instala la versión MLX de Stability AI desde github.com/Stability-AI/stable-audio-3 y luego usa /generation on con su carpeta.",
+  "Making music on this Mac is off, and Stable Audio 3 at {folder} isn't fully installed. Run ./install.sh --download medium there, then use /generation on.": "Hacer música en este Mac está desactivado, y Stable Audio 3 en {folder} no está instalado del todo. Ejecuta ./install.sh --download medium ahí y luego usa /generation on.",
+  "Stable Audio 3 at {folder} doesn't have the Medium model yet. Run ./install.sh --download medium there, then use /generation again.": "Stable Audio 3 en {folder} aún no tiene el modelo Medium. Ejecuta ./install.sh --download medium ahí y vuelve a usar /generation.",
+  "Stable Audio 3 at {folder} isn't installed yet. Run ./install.sh --download medium there, then use /generation again.": "Stable Audio 3 en {folder} aún no está instalado. Ejecuta ./install.sh --download medium ahí y vuelve a usar /generation.",
+  "Stable Audio 3 isn't at {folder}. Use /generation on with the folder that holds its sa3 script.": "Stable Audio 3 no está en {folder}. Usa /generation on con la carpeta que contiene su script sa3.",
+  "Use /generation, /generation on [folder], or /generation off.": "Usa /generation, /generation on [carpeta] o /generation off.",
+  "Music making on.": "Creación de música activada.",
+  "Music making off.": "Creación de música desactivada.",
+  "Music making isn't ready.": "La creación de música no está lista.",
+  "warming up": "calentando",
+  "reading your taste": "leyendo tus gustos",
+  "composing": "componiendo",
+  "pressing the record": "prensando el disco",
+  "saving it": "guardándolo",
+  "Let Moondog make music on this Mac": "Deja que Moondog haga música en este Mac",
+  "Make a track": "Hacer una pista",
+  "Play a track Moondog made": "Volver a poner una pista que hizo Moondog",
+  "Start a stream": "Empezar un flujo",
+  "Stop the stream": "Parar el flujo",
+  "Go on air: Moondog keeps making music from your taste": "Sal al aire: Moondog sigue haciendo música a tu gusto",
+  "on air until {time}": "al aire hasta las {time}",
+  "Cutting the next record": "Grabando el siguiente disco",
+  "Off air: the next record couldn't be made.": "Fuera del aire: no se pudo hacer el siguiente disco.",
+  "The next record is still being cut.": "El siguiente disco aún se está grabando.",
+  "Off air.": "Fuera del aire.",
+  "Turn on music making first: /generation on.": "Primero activa la creación de música: /generation on.",
 };

package/src/i18n/screen/ja.mjs

@@ -1027,4 +1027,37 @@ export default {
   "Skipped. /service and /model are here when you want them.": "スキップしました。/service と /model はいつでも使えます。",
   "Saving your music service...": "音楽サービスを保存しています...",
   "Choose where Moondog plays music": "Moondog が音楽を流す場所を選ぶ",
+  "Make music on this Mac with Stable Audio 3": "Stable Audio 3 でこの Mac で音楽を作る",
+  "Stop making music here": "ここでの音楽作りをやめる",
+  "Making music on this Mac": "この Mac での音楽作り",
+  "Made by Moondog": "Moondog 制作",
+  "Stable Audio 3 needs a Mac with Apple silicon, so Moondog can't make music here.": "Stable Audio 3 には Apple シリコン搭載の Mac が必要なので、ここでは Moondog は音楽を作れません。",
+  "Moondog makes music on this Mac with Stable Audio 3, powered by Stability AI. Ask for a track. Stable Audio 3 runs offline, and the track stays on this Mac.": "Moondog はこの Mac の Stable Audio 3 で音楽を作ります。Powered by Stability AI。曲をリクエストしてください。Stable Audio 3 はオフラインで動き、曲はこの Mac に残ります。",
+  "Making music on this Mac is off. Stable Audio 3 is ready at {folder}; turn it on with /generation on.": "この Mac での音楽作りはオフです。Stable Audio 3 は {folder} で準備できています。/generation on でオンにしてください。",
+  "Making music on this Mac is off, and Stable Audio 3 isn't at {folder}. Install Stability AI's MLX build from github.com/Stability-AI/stable-audio-3, then use /generation on with its folder.": "この Mac での音楽作りはオフで、{folder} に Stable Audio 3 がありません。github.com/Stability-AI/stable-audio-3 から Stability AI の MLX 版をインストールしてから、そのフォルダを付けて /generation on を使ってください。",
+  "Making music on this Mac is off, and Stable Audio 3 at {folder} isn't fully installed. Run ./install.sh --download medium there, then use /generation on.": "この Mac での音楽作りはオフで、{folder} の Stable Audio 3 はインストールが終わっていません。そこで ./install.sh --download medium を実行してから、/generation on を使ってください。",
+  "Stable Audio 3 at {folder} doesn't have the Medium model yet. Run ./install.sh --download medium there, then use /generation again.": "{folder} の Stable Audio 3 にはまだ Medium モデルがありません。そこで ./install.sh --download medium を実行してから、もう一度 /generation を使ってください。",
+  "Stable Audio 3 at {folder} isn't installed yet. Run ./install.sh --download medium there, then use /generation again.": "{folder} の Stable Audio 3 はまだインストールされていません。そこで ./install.sh --download medium を実行してから、もう一度 /generation を使ってください。",
+  "Stable Audio 3 isn't at {folder}. Use /generation on with the folder that holds its sa3 script.": "{folder} に Stable Audio 3 がありません。sa3 スクリプトのあるフォルダを付けて /generation on を使ってください。",
+  "Use /generation, /generation on [folder], or /generation off.": "/generation、/generation on [フォルダ]、または /generation off を使ってください。",
+  "Music making on.": "音楽作りをオンにしました。",
+  "Music making off.": "音楽作りをオフにしました。",
+  "Music making isn't ready.": "音楽作りはまだ準備できていません。",
+  "warming up": "ウォームアップ中",
+  "reading your taste": "好みを読んでいます",
+  "composing": "作曲中",
+  "pressing the record": "レコードをプレス中",
+  "saving it": "保存中",
+  "Let Moondog make music on this Mac": "この Mac で Moondog に音楽を作らせる",
+  "Make a track": "曲を作る",
+  "Play a track Moondog made": "Moondog が作った曲をもう一度かける",
+  "Start a stream": "音楽の流れを始める",
+  "Stop the stream": "音楽の流れを止める",
+  "Go on air: Moondog keeps making music from your taste": "オンエア：あなたの好みから Moondog が音楽を作り続ける",
+  "on air until {time}": "{time} までオンエア",
+  "Cutting the next record": "次のレコードをカッティング中",
+  "Off air: the next record couldn't be made.": "オフエア：次のレコードを作れませんでした。",
+  "The next record is still being cut.": "次のレコードはまだカッティング中です。",
+  "Off air.": "オフエアにしました。",
+  "Turn on music making first: /generation on.": "先に音楽作りをオンにしてください：/generation on。",
 };

package/src/i18n/screen/pt.mjs

@@ -1027,4 +1027,37 @@ export default {
   "Skipped. /service and /model are here when you want them.": "Pulado. /service e /model continuam aqui quando você quiser.",
   "Saving your music service...": "Salvando seu serviço de música...",
   "Choose where Moondog plays music": "Escolha onde o Moondog toca música",
+  "Make music on this Mac with Stable Audio 3": "Fazer música neste Mac com o Stable Audio 3",
+  "Stop making music here": "Parar de fazer música aqui",
+  "Making music on this Mac": "Fazer música neste Mac",
+  "Made by Moondog": "Feito pelo Moondog",
+  "Stable Audio 3 needs a Mac with Apple silicon, so Moondog can't make music here.": "O Stable Audio 3 precisa de um Mac com Apple silicon, então o Moondog não pode fazer música aqui.",
+  "Moondog makes music on this Mac with Stable Audio 3, powered by Stability AI. Ask for a track. Stable Audio 3 runs offline, and the track stays on this Mac.": "O Moondog faz música neste Mac com o Stable Audio 3, powered by Stability AI. Peça uma faixa. O Stable Audio 3 funciona offline, e a faixa fica neste Mac.",
+  "Making music on this Mac is off. Stable Audio 3 is ready at {folder}; turn it on with /generation on.": "Fazer música neste Mac está desativado. O Stable Audio 3 está pronto em {folder}; ative com /generation on.",
+  "Making music on this Mac is off, and Stable Audio 3 isn't at {folder}. Install Stability AI's MLX build from github.com/Stability-AI/stable-audio-3, then use /generation on with its folder.": "Fazer música neste Mac está desativado, e o Stable Audio 3 não está em {folder}. Instale a versão MLX da Stability AI a partir de github.com/Stability-AI/stable-audio-3 e depois use /generation on com a pasta dela.",
+  "Making music on this Mac is off, and Stable Audio 3 at {folder} isn't fully installed. Run ./install.sh --download medium there, then use /generation on.": "Fazer música neste Mac está desativado, e o Stable Audio 3 em {folder} não está totalmente instalado. Execute ./install.sh --download medium lá e depois use /generation on.",
+  "Stable Audio 3 at {folder} doesn't have the Medium model yet. Run ./install.sh --download medium there, then use /generation again.": "O Stable Audio 3 em {folder} ainda não tem o modelo Medium. Execute ./install.sh --download medium lá e use /generation de novo.",
+  "Stable Audio 3 at {folder} isn't installed yet. Run ./install.sh --download medium there, then use /generation again.": "O Stable Audio 3 em {folder} ainda não está instalado. Execute ./install.sh --download medium lá e use /generation de novo.",
+  "Stable Audio 3 isn't at {folder}. Use /generation on with the folder that holds its sa3 script.": "O Stable Audio 3 não está em {folder}. Use /generation on com a pasta que contém o script sa3.",
+  "Use /generation, /generation on [folder], or /generation off.": "Use /generation, /generation on [pasta] ou /generation off.",
+  "Music making on.": "Criação de música ativada.",
+  "Music making off.": "Criação de música desativada.",
+  "Music making isn't ready.": "A criação de música não está pronta.",
+  "warming up": "aquecendo",
+  "reading your taste": "lendo seu gosto",
+  "composing": "compondo",
+  "pressing the record": "prensando o disco",
+  "saving it": "salvando",
+  "Let Moondog make music on this Mac": "Deixe o Moondog fazer música neste Mac",
+  "Make a track": "Fazer uma faixa",
+  "Play a track Moondog made": "Tocar de novo uma faixa que o Moondog fez",
+  "Start a stream": "Começar um fluxo",
+  "Stop the stream": "Parar o fluxo",
+  "Go on air: Moondog keeps making music from your taste": "Entre no ar: o Moondog segue fazendo música a partir do seu gosto",
+  "on air until {time}": "no ar até {time}",
+  "Cutting the next record": "Gravando o próximo disco",
+  "Off air: the next record couldn't be made.": "Fora do ar: não deu para fazer o próximo disco.",
+  "The next record is still being cut.": "O próximo disco ainda está sendo gravado.",
+  "Off air.": "Fora do ar.",
+  "Turn on music making first: /generation on.": "Ative a criação de música primeiro: /generation on.",
 };