From c9fd266bf92a1fd07f0566a5344a812595308eda Mon Sep 17 00:00:00 2001
From: snakajima <satoshi.nakajima@gmail.com>
Date: Tue, 27 Oct 2026 17:06:47 -1000
Subject: [PATCH 1/2] The pending card: status at the top, NEUTRINO's progress,
 a card that scrolls
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

#49: the rendering note (or the failure) goes right under the title, in both views.

#50: NEUTRINO runs with -t and writes its progress to a file in the work folder. The worker is
blocked while it runs, so it sends the file's path and the render pool reads it every 500 ms.
render() takes onProgress (singing 0…1, then mixing); it is only reported, never touches the
audio. manage's deferred render keeps the latest (deferredRenderProgress), and the plugin's view
asks for it once a second with a renderProgress request beside collectRenderedAudio.

#51: MulmoChat gives the view an overflow: hidden box, and the card did not scroll itself, so long
sheet music could not be scrolled before playback. The card is now height 100%, overflow-y auto.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 PLAN.md                           | 18 +++++++++
 gui-plugin/README.md              |  5 ++-
 gui-plugin/demo/main.ts           | 29 ++++++++++-----
 gui-plugin/src/audio-request.ts   | 33 +++++++++++++++-
 gui-plugin/src/index.ts           | 16 +++++---
 gui-plugin/src/vue/View.vue       | 56 ++++++++++++++++++++++++----
 gui-plugin/src/vue/playback.ts    | 12 +++++-
 gui-plugin/tests/playback.test.ts |  9 +++++
 gui-plugin/tests/plugin.test.ts   | 22 ++++++++++-
 src/core.ts                       |  2 +-
 src/deferred-renders.ts           | 14 ++++++-
 src/index.ts                      |  2 +-
 src/manage.ts                     | 19 +++++++---
 src/render-pool.ts                | 43 ++++++++++++++++++---
 src/render-worker.ts              | 22 ++++++++---
 src/render.ts                     | 17 ++++++++-
 src/singer/neutrino.ts            | 37 +++++++++++++++---
 tests/browser.test.ts             |  1 +
 tests/deferred-renders.test.ts    | 21 ++++++++++-
 tests/render-pool.test.ts         | 62 ++++++++++++++++++++++++++++++-
 tests/singer-neutrino.test.ts     | 29 ++++++++++++++-
 21 files changed, 410 insertions(+), 59 deletions(-)

diff --git a/PLAN.md b/PLAN.md
index f46749c..b4bc0ce 100644
--- a/PLAN.md
+++ b/PLAN.md
@@ -1544,3 +1544,21 @@ Decided:
   getSchema() and the published schema files are unchanged. Not measured with the LLM eval. checkScore of a
   score that sings now also checks NEUTRINO and its voice (an error on the sung track), so a model
   can find out whether it can sing before rendering instead of guessing.
+- 2026-10-27 — The pending card (#49, #50, #51). User: the rendering note should be at the top in
+  both views; NEUTRINO takes the longest, so show how far it is; the sheet music cannot be
+  scrolled by hand before playback. NEUTRINO prints `progress = N %` with `-t`; checked on the
+  real one that it arrives during the run through a pipe (8 s song: 8 % at 1.1 s … 100 % at
+  13.7 s). It now runs with `-t` and its output in a file in the work folder; the worker thread
+  is blocked while it runs, so it sends the file's path and the pool reads it every 500 ms.
+  `render()` takes `onProgress` (singing 0…1, then mixing; in place only the two stages); it is
+  only reported and never touches the audio. `-t` itself: NEUTRINO's output differs run to run
+  by about as much as the signal (that is why it is cached), and with `-t` it differs by the same,
+  so no effect could be seen. manage's deferred render keeps the latest progress
+  (`deferredRenderProgress`); the plugin's view asks for it once a second (a `renderProgress`
+  request beside `collectRenderedAudio`) and shows the status, or the failure, under the title.
+  The sheet music would not scroll: MulmoChat's box is `overflow: hidden` and the card did not
+  scroll itself (during playback OSMD's `scrollIntoView` moved the clipped box, which looked like
+  scrolling). The card is now `height: 100%; overflow-y: auto`. Browser check with the demo's
+  stand-in runtime: status right under the title, 0 % → 84 % → audio; sheet music in a 300 px
+  box scrolled 400 px with the wheel; no console errors. Both packages 1.1.0 (new `onProgress`
+  and `deferredRenderProgress`; the plugin's peer ^1.1.0).
diff --git a/gui-plugin/README.md b/gui-plugin/README.md
index 9fdaaa8..e0db297 100644
--- a/gui-plugin/README.md
+++ b/gui-plugin/README.md
@@ -36,8 +36,9 @@ the data also carries the score that was rendered. Every other action answers th
 to minutes. In a host that gives the view a runtime (`dispatch`) and tells `execute` so with
 `deferredAudio: true` in its context, `renderScore` waits at most a second for the audio: a short
 jingle comes back finished as before; a longer one comes back at once as a `pending` card that
-shows the score, its lanes, cues, lyrics and sheet music, says "Rendering the audio…", and keeps
-play disabled. The view collects the finished audio through the host's dispatch (a request that
+shows the score, its lanes, cues, lyrics and sheet music, says at the top that the audio is
+rendering, and keeps play disabled. While NEUTRINO sings, it says how far it is ("Singing the
+vocal… 52 %", then "Mixing…"), asked once a second through the same dispatch. The view collects the finished audio through the host's dispatch (a request that
 reaches the same `execute`), saves it into the result with `onUpdateResult` (so the chat keeps it),
 and only then plays. `autoplay` waits for the audio in the same way, and counts as fresh from when
 it was ready; the voice rules above still apply. If the audio cannot be made after all, the card
diff --git a/gui-plugin/demo/main.ts b/gui-plugin/demo/main.ts
index ac81b89..c4ec2cb 100644
--- a/gui-plugin/demo/main.ts
+++ b/gui-plugin/demo/main.ts
@@ -9,6 +9,7 @@ import { z } from "zod";
 // The schema modules alone: the library's index needs Node (ffmpeg), which a page cannot load.
 import { ScoreBaseSchema } from "../../src/score-schema.ts";
 import { TimingSchema } from "../../src/timing.ts";
+import { PROGRESS_REQUEST } from "../src/audio-request.ts";
 import Preview from "../src/vue/Preview.vue";
 import View from "../src/vue/View.vue";
 
@@ -62,21 +63,31 @@ const collectedById = new Map(
   parsed.data.flatMap((sample) => (sample.data.pending && sample.collected ? [[sample.data.pending, sample.collected] as const] : [])),
 );
 
-/** A stand-in for the host's runtime: its dispatch answers a pending card's request for its audio. */
+const loadedAt = Date.now();
+
+/** How far the stand-in render is: NEUTRINO singing for most of COLLECT_MS, then the mix. */
+function standInProgress(): object {
+  const done = (Date.now() - loadedAt) / (0.8 * COLLECT_MS);
+  return done < 1 ? { progress: { stage: "singing", done }, message: "" } : { progress: { stage: "mixing" }, message: "" };
+}
+
+/** A stand-in for the host's runtime: its dispatch answers a pending card's requests for its audio and its progress. */
 const runtime: BrowserPluginRuntime = {
   pubsub: { subscribe: () => () => undefined },
   locale: ref("en"),
   log: { debug: () => undefined, info: () => undefined, warn: () => undefined, error: () => undefined },
   openUrl: (url: string) => window.open(url, "_blank", "noopener,noreferrer"),
   dispatch: (args: object) =>
-    new Promise((resolve) => {
-      const id: unknown = Reflect.get(args, "id");
-      const data = typeof id === "string" ? collectedById.get(id) : undefined;
-      setTimeout(
-        () => resolve(data ? { outcome: "ready", data, message: "The audio is ready." } : { outcome: "gone", message: "Not in this demo." }),
-        COLLECT_MS,
-      );
-    }),
+    Reflect.get(args, "kind") === PROGRESS_REQUEST
+      ? Promise.resolve(standInProgress())
+      : new Promise((resolve) => {
+          const id: unknown = Reflect.get(args, "id");
+          const data = typeof id === "string" ? collectedById.get(id) : undefined;
+          setTimeout(
+            () => resolve(data ? { outcome: "ready", data, message: "The audio is ready." } : { outcome: "gone", message: "Not in this demo." }),
+            COLLECT_MS,
+          );
+        }),
 };
 
 /** What the views would send the LLM, listed on the page. */
diff --git a/gui-plugin/src/audio-request.ts b/gui-plugin/src/audio-request.ts
index 793664b..751f631 100644
--- a/gui-plugin/src/audio-request.ts
+++ b/gui-plugin/src/audio-request.ts
@@ -1,8 +1,8 @@
 // The view's request for audio that was still rendering when its card appeared (a `pending`
-// PlayerData), and the answer. The view sends it through the host's runtime dispatch, which reaches
+// PlayerData), and the answer; and its request for how far that render is, asked while it waits. The view sends it through the host's runtime dispatch, which reaches
 // the same execute as the LLM's tool calls; execute answers it before reading the call as a tool
 // call. Shared by both entries, so the two sides cannot drift apart.
-import type { PlayerData } from "jinglescript";
+import type { PlayerData, RenderProgress } from "jinglescript";
 
 /** `kind` of the view's request; not a manageJingleScript action, so the LLM never sends it. */
 export const AUDIO_REQUEST = "collectRenderedAudio";
@@ -16,6 +16,21 @@ export interface AudioRequest {
 /** What execute answers: the finished PlayerData, why the render failed, or that it is not on the server (any more). */
 export type AudioReply = { outcome: "ready"; data: PlayerData; message: string } | { outcome: "failed" | "gone"; message: string };
 
+/** `kind` of the view's request for how far a pending render is; answered at once. */
+export const PROGRESS_REQUEST = "renderProgress";
+
+export interface ProgressRequest {
+  kind: typeof PROGRESS_REQUEST;
+  /** The pending PlayerData's `pending` id. */
+  id: string;
+}
+
+/** What execute answers: how far the render is, when it has said (nothing for a render without a sung track, or one that is done or gone). */
+export interface ProgressReply {
+  progress?: RenderProgress;
+  message: string;
+}
+
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null;
 
 export function isAudioRequest(args: unknown): args is AudioRequest {
@@ -42,3 +57,17 @@ export function parseAudioReply(raw: unknown): AudioReply | undefined {
   if (raw["outcome"] === "failed" || raw["outcome"] === "gone") return { outcome: raw["outcome"], message };
   return undefined;
 }
+
+export function isProgressRequest(args: unknown): args is ProgressRequest {
+  return isRecord(args) && args["kind"] === PROGRESS_REQUEST && typeof args["id"] === "string";
+}
+
+/** The progress in a reply as the view receives it, checked; undefined when there is none. */
+export function parseProgressReply(raw: unknown): RenderProgress | undefined {
+  const progress = isRecord(raw) ? raw["progress"] : undefined;
+  if (!isRecord(progress)) return undefined;
+  if (progress["stage"] === "mixing") return { stage: "mixing" };
+  const done = progress["done"];
+  if (progress["stage"] === "singing" && typeof done === "number" && done >= 0 && done <= 1) return { stage: "singing", done };
+  return undefined;
+}
diff --git a/gui-plugin/src/index.ts b/gui-plugin/src/index.ts
index 4395a31..e505c40 100644
--- a/gui-plugin/src/index.ts
+++ b/gui-plugin/src/index.ts
@@ -4,10 +4,10 @@
 // A score `path` is read through the host's `files.byPath` (as presentDocument's is): the host
 // decides what a path may reach and what a relative one means. Without it, `path` is refused.
 // A host whose view can call back (`deferredAudio`) gets the card before a long render's audio:
-// the view collects it with an AudioRequest, answered here.
+// the view collects it with an AudioRequest, answered here, and asks how far it is meanwhile.
 import type { FileOps, ToolContext, ToolPluginCore, ToolResult } from "gui-chat-protocol";
-import { awaitDeferredPlayer, MANAGE_TOOL, ManageInputSchema, manage, type PlayerData } from "jinglescript";
-import { isAudioRequest, type AudioReply, type AudioRequest } from "./audio-request.ts";
+import { awaitDeferredPlayer, deferredRenderProgress, MANAGE_TOOL, ManageInputSchema, manage, type PlayerData } from "jinglescript";
+import { isAudioRequest, isProgressRequest, type AudioReply, type AudioRequest, type ProgressReply, type ProgressRequest } from "./audio-request.ts";
 import { TOOL_DEFINITION } from "./definition.ts";
 
 export { TOOL_DEFINITION };
@@ -38,6 +38,12 @@ export async function collectAudio(request: AudioRequest): Promise<AudioReply> {
   }
 }
 
+/** The answer to a view's ProgressRequest: how far the render it names is, at once. */
+export function renderProgress(request: ProgressRequest): Promise<ProgressReply> {
+  const progress = deferredRenderProgress(request.id);
+  return Promise.resolve(progress === undefined ? { message: "No progress to tell." } : { progress, message: `Rendering: ${progress.stage}.` });
+}
+
 export async function executeManage(context: ManageContext, args: object): Promise<ToolResult<PlayerData, never>> {
   const input = ManageInputSchema.safeParse(args);
   if (!input.success) {
@@ -77,8 +83,8 @@ export function instructionsFor(player: PlayerData): string {
 
 export const pluginCore: ToolPluginCore<PlayerData, never, object> = {
   toolDefinition: TOOL_DEFINITION,
-  // The view's AudioRequest comes through the same execute (the host's dispatch route) as the tool calls.
-  execute: (context, args) => (isAudioRequest(args) ? collectAudio(args) : executeManage(context, args)),
+  // The view's requests come through the same execute (the host's dispatch route) as the tool calls.
+  execute: (context, args) => (isAudioRequest(args) ? collectAudio(args) : isProgressRequest(args) ? renderProgress(args) : executeManage(context, args)),
   generatingMessage: "Rendering the jingle…",
   isEnabled: () => true,
 };
diff --git a/gui-plugin/src/vue/View.vue b/gui-plugin/src/vue/View.vue
index d9999ff..8905250 100644
--- a/gui-plugin/src/vue/View.vue
+++ b/gui-plugin/src/vue/View.vue
@@ -7,14 +7,26 @@
 // host (`isAudioPlaying`), what plays by itself waits until the voice has been quiet a moment, and
 // pauses while it speaks again. A card shown while its audio still renders (`pending`) shows the
 // score at once, collects the audio through the host's runtime dispatch, keeps it in the result, and
-// only then can play (by itself too, when that was asked for).
+// only then can play (by itself too, when that was asked for); meanwhile it asks how far the render
+// is and says so at the top. The card scrolls itself: a host may give it a box that does not.
 import type { ToolResult, ToolResultComplete } from "gui-chat-protocol";
 import { PLUGIN_RUNTIME_KEY } from "gui-chat-protocol/vue";
-import type { PlayerData, PlayerView } from "jinglescript";
+import type { PlayerData, PlayerView, RenderProgress } from "jinglescript";
 import { computed, defineAsyncComponent, inject, nextTick, onBeforeUnmount, onMounted, ref, watch } from "vue";
-import { AUDIO_REQUEST, parseAudioReply } from "../audio-request.ts";
+import { AUDIO_REQUEST, parseAudioReply, parseProgressReply, PROGRESS_REQUEST } from "../audio-request.ts";
 import { formatTime, karaoke, lanes, waveformPath, WIDTH, xOf } from "./layout.ts";
-import { failedMessage, finishedMessage, memoryOf, quietWait, shouldAutoplay, VIEW_LABELS, type PlayerMemory, type VoiceState } from "./playback.ts";
+import {
+  failedMessage,
+  finishedMessage,
+  memoryOf,
+  PROGRESS_POLL_MS,
+  quietWait,
+  renderingLabel,
+  shouldAutoplay,
+  VIEW_LABELS,
+  type PlayerMemory,
+  type VoiceState,
+} from "./playback.ts";
 
 // The default keeps a host that never passes isAudioPlaying apart from one whose voice is quiet:
 // Vue would otherwise turn a missing boolean prop into false.
@@ -39,6 +51,9 @@ const collected = ref<PlayerData | undefined>(undefined);
 const failure = ref<string | undefined>(undefined);
 const data = computed(() => collected.value ?? props.selectedResult.data);
 const pending = computed(() => data.value?.pending !== undefined);
+/** How far a pending card's render is, as the server last said. */
+const renderProgress = ref<RenderProgress | undefined>(undefined);
+let progressTimer: ReturnType<typeof setTimeout> | undefined;
 const memory = ref<PlayerMemory>(memoryOf(props.selectedResult.viewState));
 /** The view a result opens in: as last shown, else as the LLM asked; the waveform when there is no sheet music. */
 const firstView = (): PlayerView => (data.value?.musicxml === undefined ? "waveform" : (memory.value.view ?? data.value.presentation?.view ?? "waveform"));
@@ -178,6 +193,20 @@ async function collect(): Promise<void> {
   if (!disposed) autoplay();
 }
 
+/** Asks how far the pending render is, again and again until the card has its audio or failed. */
+async function followProgress(): Promise<void> {
+  clearTimeout(progressTimer);
+  const id = data.value?.pending;
+  if (id === undefined || runtime === null || disposed || failure.value !== undefined) return;
+  try {
+    const progress = parseProgressReply(await runtime.dispatch({ kind: PROGRESS_REQUEST, id }));
+    if (data.value?.pending === id) renderProgress.value = progress;
+  } catch {
+    // only the label is missing: the audio still comes through collect()
+  }
+  if (!disposed && data.value?.pending === id && failure.value === undefined) progressTimer = setTimeout(() => void followProgress(), PROGRESS_POLL_MS);
+}
+
 /** No audio after all: shown in the card, and told to the LLM once when it expected it to play. */
 function fail(reason: string): void {
   failure.value = reason;
@@ -191,8 +220,11 @@ function fail(reason: string): void {
 /** What a card does when it appears: collect its audio, or play by itself when asked. */
 function start(): void {
   appeared();
-  if (pending.value) void collect();
-  else autoplay();
+  renderProgress.value = undefined;
+  if (pending.value) {
+    void collect();
+    void followProgress();
+  } else autoplay();
 }
 
 /** Plays what plays by itself once the voice has been quiet long enough; pauses it while the voice speaks. */
@@ -266,6 +298,7 @@ onBeforeUnmount(() => {
   disposed = true;
   cancelAnimationFrame(frame);
   clearTimeout(quietTimer);
+  clearTimeout(progressTimer);
 });
 </script>
 
@@ -289,6 +322,9 @@ onBeforeUnmount(() => {
       </span>
     </header>
 
+    <p v-if="failure" class="status failure" role="alert">{{ failure }}</p>
+    <p v-else-if="pending" class="status rendering" role="status">{{ renderingLabel(renderProgress) }}</p>
+
     <template v-if="view === 'notation' && data.musicxml !== undefined">
       <Notation :musicxml="data.musicxml" :tempo="data.timing.tempo" :now="now" />
       <div
@@ -360,8 +396,6 @@ onBeforeUnmount(() => {
         <svg v-else viewBox="0 0 16 16" aria-hidden="true"><path d="M4 2 L14 8 L4 14 Z" /></svg>
       </button>
       <span class="time">{{ formatTime(now) }} / {{ formatTime(data.duration) }}</span>
-      <span v-if="failure" class="failure">{{ failure }}</span>
-      <span v-else-if="pending" class="rendering" role="status">Rendering the audio…</span>
       <span v-if="blocked" class="blocked">Press play to listen</span>
       <span class="downloads">
         <a v-if="!pending" :href="data.audio" :download="`${data.title}.${extension}`">Download {{ extension.toUpperCase() }}</a>
@@ -397,6 +431,9 @@ onBeforeUnmount(() => {
   padding: 16px;
   box-sizing: border-box;
   width: 100%;
+  /* A host's box may clip (overflow: hidden): long sheet music scrolls here. */
+  height: 100%;
+  overflow-y: auto;
 }
 @media (prefers-color-scheme: dark) {
   .jingle {
@@ -593,6 +630,9 @@ h2 {
   height: 100%;
   background: var(--wave);
 }
+.status {
+  margin: 0 0 10px;
+}
 .blocked,
 .failure {
   color: var(--cue);
diff --git a/gui-plugin/src/vue/playback.ts b/gui-plugin/src/vue/playback.ts
index 0ca6306..e1cc767 100644
--- a/gui-plugin/src/vue/playback.ts
+++ b/gui-plugin/src/vue/playback.ts
@@ -2,7 +2,7 @@
 // heard, what it remembers, and where the sheet-music cursor stands. Hosts mount every card of a
 // chat and remount them often (a reload, another session, the pane reopened), so what happened
 // once is kept in the result's viewState, and only a fresh render plays by itself.
-import type { Presentation } from "jinglescript";
+import type { Presentation, RenderProgress } from "jinglescript";
 
 /** A render older than this is history: shown again, never autoplayed. */
 export const FRESH_MS = 120_000;
@@ -108,3 +108,13 @@ export function cursorIndex(positions: readonly number[], seconds: number): numb
   }
   return found;
 }
+
+/** How often a pending card asks how far its render is, ms. */
+export const PROGRESS_POLL_MS = 1000;
+
+/** What a pending card says while its audio renders, with how far it is when the render has said. */
+export function renderingLabel(progress: RenderProgress | undefined): string {
+  if (progress?.stage === "singing") return `Singing the vocal… ${Math.floor(progress.done * 100)} %`;
+  if (progress?.stage === "mixing") return "Mixing the vocal with the accompaniment…";
+  return "Rendering the audio…";
+}
diff --git a/gui-plugin/tests/playback.test.ts b/gui-plugin/tests/playback.test.ts
index 5075769..79877b0 100644
--- a/gui-plugin/tests/playback.test.ts
+++ b/gui-plugin/tests/playback.test.ts
@@ -10,6 +10,7 @@ import {
   QUIET_MS,
   quietWait,
   REPLY_MS,
+  renderingLabel,
   shouldAutoplay,
   type VoiceState,
 } from "../src/vue/playback.ts";
@@ -109,6 +110,14 @@ describe("the message when a pending card's audio could not be made", () => {
   });
 });
 
+describe("what a pending card says", () => {
+  it("says how far NEUTRINO is, then that it mixes; without word from the render, only that it renders", () => {
+    expect(renderingLabel({ stage: "singing", done: 0.526 })).toBe("Singing the vocal… 52 %");
+    expect(renderingLabel({ stage: "mixing" })).toBe("Mixing the vocal with the accompaniment…");
+    expect(renderingLabel(undefined)).toBe("Rendering the audio…");
+  });
+});
+
 describe("memoryOf", () => {
   it("reads only what it wrote, and ignores anything else in viewState", () => {
     expect(memoryOf({ autoplayed: true, notified: "yes", view: "notation", other: 1 })).toEqual({
diff --git a/gui-plugin/tests/plugin.test.ts b/gui-plugin/tests/plugin.test.ts
index 4ea99c7..9029211 100644
--- a/gui-plugin/tests/plugin.test.ts
+++ b/gui-plugin/tests/plugin.test.ts
@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 import { definitionText } from "../scripts/definition.ts";
-import { AUDIO_REQUEST, isAudioRequest, parseAudioReply } from "../src/audio-request.ts";
+import { AUDIO_REQUEST, isAudioRequest, isProgressRequest, parseAudioReply, parseProgressReply, PROGRESS_REQUEST } from "../src/audio-request.ts";
 import { manage } from "jinglescript";
 import { executeManage, instructionsFor, pluginCore, TOOL_DEFINITION } from "../src/index.ts";
 import { karaoke, lanes, waveformPath, xOf } from "../src/vue/layout.ts";
@@ -149,6 +149,26 @@ describe("a card shown before its audio (a host that sets deferredAudio)", () =>
     expect(parseAudioReply("nope")).toBeUndefined();
   });
 
+  it("answers how far a render is at once: nothing to tell for one that is done or not on the server", async () => {
+    const pending = (await manage({ action: "renderScore", score }, { player: true, deferAudio: { waitMs: 0 } })).player;
+    if (pending?.pending === undefined) throw new Error("expected a pending card");
+    // An unsung score reports no stages; the answer is still immediate.
+    expect(parseProgressReply(await pluginCore.execute({}, { kind: PROGRESS_REQUEST, id: pending.pending }))).toBeUndefined();
+    await pluginCore.execute({}, { kind: AUDIO_REQUEST, id: pending.pending });
+    expect(await pluginCore.execute({}, { kind: PROGRESS_REQUEST, id: pending.pending })).toEqual({ message: "No progress to tell." });
+    expect(await pluginCore.execute({}, { kind: PROGRESS_REQUEST, id: "no-such-render" })).toEqual({ message: "No progress to tell." });
+  });
+
+  it("checks the view's progress request and the server's answer", () => {
+    expect(isProgressRequest({ kind: PROGRESS_REQUEST, id: "x" })).toBe(true);
+    expect(isProgressRequest({ kind: AUDIO_REQUEST, id: "x" })).toBe(false);
+    expect(parseProgressReply({ progress: { stage: "singing", done: 0.52 }, message: "" })).toEqual({ stage: "singing", done: 0.52 });
+    expect(parseProgressReply({ progress: { stage: "mixing" }, message: "" })).toEqual({ stage: "mixing" });
+    expect(parseProgressReply({ progress: { stage: "singing", done: 7 }, message: "" })).toBeUndefined();
+    expect(parseProgressReply({ message: "No progress to tell." })).toBeUndefined();
+    expect(parseProgressReply("nope")).toBeUndefined();
+  });
+
   it("tells the LLM the audio is on its way", () => {
     const pending = { presentation: { view: "waveform" as const, autoplay: true, notifyWhenDone: false }, pending: "id" };
     expect(instructionsFor({ ...pending } as never)).toMatch(/still rendering.*plays? .*when the audio is ready/s);
diff --git a/src/core.ts b/src/core.ts
index b5a24fd..013c82b 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -10,7 +10,7 @@ export { pitchToMidi } from "./pitch.ts";
 export { parseCueRef, resolveAt } from "./time.ts";
 export type { At } from "./time.ts";
 export { render, samplesNeeded, DEFAULT_SAMPLE_RATE, SAMPLE_RATES, SingerUnavailableError } from "./render.ts";
-export type { RenderOptions, RenderResult, SampleRate } from "./render.ts";
+export type { RenderOptions, RenderProgress, RenderResult, SampleRate } from "./render.ts";
 export { TimingSchema, TIMING_FORMAT } from "./timing.ts";
 export type { TimingMap, TimingNote, TimingLyricLine } from "./timing.ts";
 export type { MasterStats } from "./dsp/master.ts";
diff --git a/src/deferred-renders.ts b/src/deferred-renders.ts
index 46c1562..c29f852 100644
--- a/src/deferred-renders.ts
+++ b/src/deferred-renders.ts
@@ -5,6 +5,7 @@
 // DEFERRED_KEEP_MS, and only the newest MAX_DEFERRED. An id that is unknown (dropped, or the
 // server restarted) answers "gone" and the view asks for a new render.
 import type { PlayerData } from "./player.ts";
+import type { RenderProgress } from "./render.ts";
 
 /** How long a finished render is kept for a view that has not collected it yet (a card mounted late). */
 export const DEFERRED_KEEP_MS = 30 * 60_000;
@@ -19,6 +20,8 @@ export type DeferredOutcome = { kind: "ready"; player: PlayerData } | { kind: "f
 interface Entry {
   outcome: Promise<DeferredOutcome>;
   settled: boolean;
+  /** How far the render is, as last reported. */
+  progress: () => RenderProgress | undefined;
 }
 
 /** In the order they were deferred. */
@@ -40,8 +43,8 @@ function trim(): void {
   }
 }
 
-/** Keeps `player` (still rendering) under a new id, and returns the id. */
-export function deferRender(player: Promise<PlayerData>): string {
+/** Keeps `player` (still rendering) under a new id, and returns the id; `progress` tells how far it is. */
+export function deferRender(player: Promise<PlayerData>, progress: () => RenderProgress | undefined = () => undefined): string {
   const id = crypto.randomUUID();
   const entry: Entry = {
     outcome: player.then(
@@ -49,6 +52,7 @@ export function deferRender(player: Promise<PlayerData>): string {
       (error: unknown): DeferredOutcome => ({ kind: "failed", message: error instanceof Error ? error.message : String(error) }),
     ),
     settled: false,
+    progress,
   };
   entries.set(id, entry);
   void entry.outcome.then(() => {
@@ -68,3 +72,9 @@ export async function awaitDeferredPlayer(id: string): Promise<DeferredOutcome>
   if (outcome.kind === "ready") dropAfter(id, COLLECTED_KEEP_MS);
   return outcome;
 }
+
+/** How far the deferred render `id` is, as last reported; undefined when nothing was (or it is finished or gone). */
+export function deferredRenderProgress(id: string): RenderProgress | undefined {
+  const entry = entries.get(id);
+  return entry === undefined || entry.settled ? undefined : entry.progress();
+}
diff --git a/src/index.ts b/src/index.ts
index 4272dcf..a039ce3 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -11,7 +11,7 @@ export type { LoadSamplesOptions } from "./samples/load.ts";
 export { renderToFiles } from "./output.ts";
 export { manage, ManageInputSchema, manageInputJsonSchema, MANAGE_TOOL, MANAGE_ACTIONS, MANAGE_DESCRIPTION } from "./manage.ts";
 export type { ManageInput, ManageResult, ManageOptions, ManageAction } from "./manage.ts";
-export { awaitDeferredPlayer, DEFERRED_KEEP_MS } from "./deferred-renders.ts";
+export { awaitDeferredPlayer, deferredRenderProgress, DEFERRED_KEEP_MS } from "./deferred-renders.ts";
 export type { DeferredOutcome } from "./deferred-renders.ts";
 export { FfmpegMissingError } from "./encode.ts";
 export { AUDIO_FORMATS } from "./audio-format.ts";
diff --git a/src/manage.ts b/src/manage.ts
index 61dfaac..0aac525 100644
--- a/src/manage.ts
+++ b/src/manage.ts
@@ -23,7 +23,7 @@ import {
   type PlayerData,
   type Presentation,
 } from "./player.ts";
-import { render, type RenderResult } from "./render.ts";
+import { render, type RenderProgress, type RenderResult } from "./render.ts";
 import "./render-pool.ts";
 import { SampleDownloadError } from "./samples/fetch-sample.ts";
 import { loadSamples } from "./samples/load.ts";
@@ -362,8 +362,13 @@ function renderSummary(input: ManageInput, score: Score, result: RenderResult, w
 }
 
 /** The audio for a player, rendered and embedded; `renderedAt` is when it was ready. */
-async function renderPlayer(score: Score, stem: string, presentation: Presentation): Promise<{ result: RenderResult; player: PlayerData }> {
-  const result = await render(score, { samples: await loadSamples(score) });
+async function renderPlayer(
+  score: Score,
+  stem: string,
+  presentation: Presentation,
+  onProgress?: (progress: RenderProgress) => void,
+): Promise<{ result: RenderResult; player: PlayerData }> {
+  const result = await render(score, { samples: await loadSamples(score), ...(onProgress ? { onProgress } : {}) });
   const player = toPlayerData(score, result, stem, await embeddedAudio(result, score), { ...presentation, renderedAt: Date.now() });
   return { result, player };
 }
@@ -377,7 +382,8 @@ const FULL_TIMING_AT = "render again with includeTiming: true to get them";
  */
 async function deferredRenderAction(input: ManageInput, score: Score, stem: string, warnings: readonly ScoreProblem[], waitMs: number): Promise<ManageResult> {
   const presentation = presentationOf(input);
-  const rendering = renderPlayer(score, stem, presentation);
+  let progress: RenderProgress | undefined;
+  const rendering = renderPlayer(score, stem, presentation, (latest) => (progress = latest));
   let done: { result: RenderResult; player: PlayerData } | undefined;
   try {
     // A render that runs in place (no worker) can finish before even a 0 ms timer: 0 does not wait at all.
@@ -388,7 +394,10 @@ async function deferredRenderAction(input: ManageInput, score: Score, stem: stri
   }
   if (done !== undefined)
     return { text: json({ ok: true, ...renderSummary(input, score, done.result, warnings, FULL_TIMING_AT) }), isError: false, player: done.player };
-  const id = deferRender(rendering.then(({ player }) => player));
+  const id = deferRender(
+    rendering.then(({ player }) => player),
+    () => progress,
+  );
   const player = pendingPlayerData(score, stem, presentation, id);
   const summary = {
     ok: true,
diff --git a/src/render-pool.ts b/src/render-pool.ts
index 5616968..da9ab35 100644
--- a/src/render-pool.ts
+++ b/src/render-pool.ts
@@ -4,16 +4,19 @@
 // and the rest wait their turn. Idle workers are kept for the next render and unref'd, so they never
 // keep the process alive. Importing this module registers the pool with render(); where no worker
 // can run (a bundle that left the worker file behind) it says so once, and render() works in place.
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { availableParallelism } from "node:os";
 import { fileURLToPath } from "node:url";
 import { SHARE_ENV, Worker } from "node:worker_threads";
 import type { RenderJob, RenderReply, SerializedError } from "./render-worker.ts";
-import { samplesNeeded, setRenderRunner, SingerUnavailableError, sungTrack, type RenderOptions, type RenderResult } from "./render.ts";
+import { samplesNeeded, setRenderRunner, SingerUnavailableError, sungTrack, type RenderOptions, type RenderProgress, type RenderResult } from "./render.ts";
 import { SampleDownloadError } from "./samples/fetch-sample.ts";
 import { loadedSamples, SamplesNotLoadedError, type SampleData, type SampleSource } from "./samples/source.ts";
 import { JingleScriptError, type Score } from "./score.ts";
-import { NeutrinoMissingError, NeutrinoVoiceMissingError } from "./singer/neutrino.ts";
+import { NeutrinoMissingError, NeutrinoVoiceMissingError, neutrinoProgress } from "./singer/neutrino.ts";
+
+/** How often the file a running NEUTRINO reports its progress in is read, ms. */
+const PROGRESS_POLL_MS = 500;
 
 /** Renders at once: one per core but one, at most two (a GUI host may start several cards together). */
 const POOL_SIZE = Math.max(1, Math.min(2, availableParallelism() - 1));
@@ -64,7 +67,8 @@ function samplesFor(score: Score, source: SampleSource | undefined, seed: number
 }
 
 /**
- * The render options a worker receives: every field of RenderOptions but the samples (sent as data),
+ * The render options a worker receives: every field of RenderOptions but the samples (sent as data)
+ * and onProgress (the pool calls it with what the worker reports),
  * named one by one so a field added to RenderOptions is a type error here until it is passed on, and
  * so whatever else a caller's options object carries (renderToFiles' onDownload callback) stays behind.
  */
@@ -84,6 +88,7 @@ function sings(score: Score): boolean {
 interface Task {
   job: Omit<RenderJob, "id">;
   sung: boolean;
+  onProgress: ((progress: RenderProgress) => void) | undefined;
   resolve: (result: RenderResult) => void;
   reject: (error: Error) => void;
 }
@@ -108,12 +113,33 @@ function startWorker(url: URL): Worker {
   return worker;
 }
 
+/** Reads NEUTRINO's progress from `file` until cleared: the worker running it is blocked meanwhile. */
+function pollNeutrino(file: string, onProgress: (progress: RenderProgress) => void): ReturnType<typeof setInterval> {
+  let last: number | undefined;
+  const timer = setInterval(() => {
+    let printed: string;
+    try {
+      printed = readFileSync(file, "utf8");
+    } catch {
+      return; // not written yet, or removed as NEUTRINO finished
+    }
+    const done = neutrinoProgress(printed);
+    if (done === undefined || done === last) return;
+    last = done;
+    onProgress({ stage: "singing", done });
+  }, PROGRESS_POLL_MS);
+  timer.unref();
+  return timer;
+}
+
 function run(url: URL, worker: Worker, task: Task): void {
   const id = nextId++;
   let settled = false;
+  let polling: ReturnType<typeof setInterval> | undefined;
   if (task.sung) singing++;
   const settle = (): void => {
     settled = true;
+    clearInterval(polling);
     if (task.sung) singing--;
     worker.off("message", onMessage);
     worker.off("error", onError);
@@ -122,6 +148,13 @@ function run(url: URL, worker: Worker, task: Task): void {
   };
   const onMessage = (reply: RenderReply): void => {
     if (reply.id !== id || settled) return;
+    if ("progress" in reply || "neutrinoLog" in reply) {
+      clearInterval(polling);
+      if (task.onProgress === undefined) return;
+      polling = "neutrinoLog" in reply ? pollNeutrino(reply.neutrinoLog, task.onProgress) : undefined;
+      if ("progress" in reply) task.onProgress(reply.progress);
+      return;
+    }
     settle();
     if ("error" in reply) task.reject(revive(reply.error));
     else task.resolve(reply.result);
@@ -175,7 +208,7 @@ if (workerUrl === undefined) {
     (score, options) =>
       new Promise<RenderResult>((resolve, reject) => {
         const job = { score, options: workerOptions(options), samples: samplesFor(score, options.samples, options.seed) };
-        queue.push({ job, sung: sings(score), resolve, reject });
+        queue.push({ job, sung: sings(score), onProgress: options.onProgress, resolve, reject });
         pump(workerUrl);
       }),
   );
diff --git a/src/render-worker.ts b/src/render-worker.ts
index 215e585..93d9045 100644
--- a/src/render-worker.ts
+++ b/src/render-worker.ts
@@ -1,17 +1,18 @@
 // A render worker thread (started by render-pool.ts): renders one score at a time with renderNow and
 // sends the audio back without copying it. NEUTRINO is registered here, so a sung track's vocal is
-// also made on this thread, and only this thread waits for it.
+// also made on this thread, and only this thread waits for it. Progress goes out as it comes; while
+// NEUTRINO runs this thread is blocked, so it sends the file NEUTRINO writes its progress to instead.
 import { parentPort } from "node:worker_threads";
-import { renderNow, type RenderOptions, type RenderResult } from "./render.ts";
+import { renderNow, type RenderOptions, type RenderProgress, type RenderResult } from "./render.ts";
 import { sampleSourceOf, type SampleData } from "./samples/source.ts";
 import type { Score } from "./score.ts";
-import "./singer/neutrino.ts";
+import { onNeutrinoProgressLog } from "./singer/neutrino.ts";
 
 /** One render, as the pool sends it: the samples as plain data (a SampleSource holds a function). */
 export interface RenderJob {
   id: number;
   score: Score;
-  options: Omit<RenderOptions, "samples">;
+  options: Omit<RenderOptions, "samples" | "onProgress">;
   samples: ReadonlyMap<string, SampleData>;
 }
 
@@ -24,7 +25,12 @@ export interface SerializedError {
   props: Record<string, unknown>;
 }
 
-export type RenderReply = { id: number; result: RenderResult } | { id: number; error: SerializedError };
+/** The render's outcome, or (before it) how far it is: a stage, or the file NEUTRINO reports its progress in. */
+export type RenderReply =
+  | { id: number; result: RenderResult }
+  | { id: number; error: SerializedError }
+  | { id: number; progress: RenderProgress }
+  | { id: number; neutrinoLog: string };
 
 function serialize(error: unknown): SerializedError {
   if (!(error instanceof Error)) return { name: "Error", message: String(error), stack: undefined, props: {} };
@@ -44,11 +50,15 @@ if (port === null) throw new Error("render-worker.ts runs only as a worker threa
 
 port.on("message", (job: RenderJob) => {
   let result: RenderResult;
+  const onProgress = (progress: RenderProgress): void => port.postMessage({ id: job.id, progress } satisfies RenderReply);
+  onNeutrinoProgressLog((neutrinoLog) => port.postMessage({ id: job.id, neutrinoLog } satisfies RenderReply));
   try {
-    result = renderNow(job.score, { ...job.options, samples: sampleSourceOf(job.samples) });
+    result = renderNow(job.score, { ...job.options, samples: sampleSourceOf(job.samples), onProgress });
   } catch (error) {
     port.postMessage({ id: job.id, error: serialize(error) } satisfies RenderReply);
     return;
+  } finally {
+    onNeutrinoProgressLog(undefined);
   }
   // The audio buffers move to the caller instead of being copied.
   const buffers = result.audio.flatMap((channel) => (channel.buffer instanceof ArrayBuffer ? [channel.buffer] : []));
diff --git a/src/render.ts b/src/render.ts
index 66bdfb9..6fc3b92 100644
--- a/src/render.ts
+++ b/src/render.ts
@@ -25,8 +25,20 @@ export interface RenderOptions {
    * PCM at `sampleRate` from time 0, mixed in place of the track's own instrument, before mastering.
    */
   prerendered?: ReadonlyMap<number, Float32Array>;
+  /**
+   * Told how far the render is, for a carrier to show (a view waiting for the audio). Only reported:
+   * it never changes the audio. A render on a worker thread reports NEUTRINO's share as it goes; one
+   * in place reports only when singing starts and ends.
+   */
+  onProgress?: (progress: RenderProgress) => void;
 }
 
+/**
+ * How far a render is: NEUTRINO singing the sung track (`done` 0…1, from NEUTRINO's own count of
+ * the seconds it has made), then the mix of the vocal with the other tracks.
+ */
+export type RenderProgress = { stage: "singing"; done: number } | { stage: "mixing" };
+
 export interface RenderResult {
   /** Left and right channels. */
   audio: [Float32Array, Float32Array];
@@ -249,7 +261,10 @@ function withSinging(score: Score, options: RenderOptions): RenderOptions {
   const track = sungTrack(score);
   if (track === undefined || options.prerendered?.has(track)) return options;
   if (singer === undefined) throw new SingerUnavailableError(score.tracks[track]?.sing?.engine ?? "a singer");
-  return { ...options, prerendered: new Map([...(options.prerendered ?? []), [track, singer(score, options, track)]]) };
+  options.onProgress?.({ stage: "singing", done: 0 });
+  const vocal = singer(score, options, track);
+  options.onProgress?.({ stage: "mixing" });
+  return { ...options, prerendered: new Map([...(options.prerendered ?? []), [track, vocal]]) };
 }
 
 /** Runs renderNow somewhere other than here: the Node entry registers a worker-thread pool (render-pool.ts). Internal. */
diff --git a/src/singer/neutrino.ts b/src/singer/neutrino.ts
index 279b338..6d39c73 100644
--- a/src/singer/neutrino.ts
+++ b/src/singer/neutrino.ts
@@ -5,7 +5,7 @@
 // The NEUTRINO folder is only read: labels, f0, mel and wav are written to a work dir in the cache.
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, mkdtempSync, openSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { cpus } from "node:os";
 import { join } from "node:path";
 import { parseEnv } from "node:util";
@@ -242,23 +242,46 @@ interface NeutrinoOptions {
 /** Default loudness of a NEUTRINO vocal over its accompaniment, LU. */
 export const VOCAL_LEVEL_DB = 4;
 
-/** Runs a NEUTRINO tool; `cwd` is the install (musicXMLtoLabel reads settings/dic relative to it). */
-export type NeutrinoExec = (file: string, args: readonly string[], env: NodeJS.ProcessEnv, cwd: string) => void;
+/**
+ * Runs a NEUTRINO tool; `cwd` is the install (musicXMLtoLabel reads settings/dic relative to it).
+ * `stdout`: a file for what the tool prints (NEUTRINO's progress), else it is dropped.
+ */
+export type NeutrinoExec = (file: string, args: readonly string[], env: NodeJS.ProcessEnv, cwd: string, stdout?: string) => void;
 
 /**
  * Runs synchronously (execFileSync) inside renderNow, which in Node runs on a render worker thread
  * (render-pool.ts): only that worker waits for NEUTRINO (tens of seconds uncached), not the caller.
  */
-const defaultExec: NeutrinoExec = (file, args, env, cwd) => {
+const defaultExec: NeutrinoExec = (file, args, env, cwd, stdout) => {
+  const out = stdout === undefined ? "ignore" : openSync(stdout, "w");
   try {
-    execFileSync(file, [...args], { env, cwd, maxBuffer: 64 * 1024 * 1024, stdio: ["ignore", "ignore", "pipe"] });
+    execFileSync(file, [...args], { env, cwd, maxBuffer: 64 * 1024 * 1024, stdio: ["ignore", out, "pipe"] });
   } catch (error) {
     const stderr = error instanceof Error && "stderr" in error && error.stderr instanceof Buffer ? error.stderr.toString() : "";
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`${file} failed: ${message}\n${stderr.slice(-2000)}`, { cause: error });
+  } finally {
+    if (out !== "ignore") closeSync(out);
   }
 };
 
+/**
+ * Told the file a NEUTRINO run writes its progress to, as it starts: the thread waiting for it is
+ * blocked meanwhile, so another one reads the file (render-pool.ts) with neutrinoProgress. Internal.
+ */
+let progressLogListener: ((file: string) => void) | undefined;
+/** Internal (render-worker.ts): where to hear of each NEUTRINO run's progress file; undefined stops. */
+export function onNeutrinoProgressLog(listener: ((file: string) => void) | undefined): void {
+  progressLogListener = listener;
+}
+
+/** NEUTRINO's latest `progress = N %` in what it printed (with -t), as 0…1; undefined before the first. */
+export function neutrinoProgress(printed: string): number | undefined {
+  const matches = [...printed.matchAll(/progress = (\d+) %/g)];
+  const last = matches.at(-1)?.[1];
+  return last === undefined ? undefined : Math.min(1, Number(last) / 100);
+}
+
 /** The render cache key: the MusicXML, the voice, the options that change the sound, and the install's version. */
 export function neutrinoCacheKey(xml: string, voice: string, options: Pick<NeutrinoOptions, "transpose" | "styleShift">, version: string): string {
   return createHash("sha256")
@@ -304,6 +327,8 @@ function neutrinoWav(install: NeutrinoInstall, voice: string, xml: string, optio
     writeFileSync(p("score.musicxml"), xml);
     exec(join(bin, "musicXMLtoLabel"), [p("score.musicxml"), p("full.lab"), p("mono.lab")], env, install.dir);
     const threads = options.threads ?? Math.max(1, cpus().length);
+    const log = p("progress.log");
+    progressLogListener?.(log);
     exec(
       join(bin, "neutrino"),
       [
@@ -323,9 +348,11 @@ function neutrinoWav(install: NeutrinoInstall, voice: string, xml: string, optio
         String(NEUTRINO_SAMPLE_RATE),
         "-b",
         "16",
+        "-t", // prints its progress
       ],
       env,
       install.dir,
+      log,
     );
     const wav = readFileSync(p("out.wav"));
     writeFileSync(file, wav);
diff --git a/tests/browser.test.ts b/tests/browser.test.ts
index 2cac22e..b910593 100644
--- a/tests/browser.test.ts
+++ b/tests/browser.test.ts
@@ -75,6 +75,7 @@ describe("jinglescript/browser", () => {
       "NeutrinoMissingError",
       "NeutrinoVoiceMissingError",
       "awaitDeferredPlayer",
+      "deferredRenderProgress",
       "DEFERRED_KEEP_MS",
     ];
     const browserOnly = ["DEFAULT_SFX_BASE_URL", "DEFAULT_CACHE_NAME"];
diff --git a/tests/deferred-renders.test.ts b/tests/deferred-renders.test.ts
index 3ec6c2f..02fc1e5 100644
--- a/tests/deferred-renders.test.ts
+++ b/tests/deferred-renders.test.ts
@@ -1,5 +1,6 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { awaitDeferredPlayer, COLLECTED_KEEP_MS, DEFERRED_KEEP_MS, deferRender, MAX_DEFERRED } from "../src/deferred-renders.ts";
+import { awaitDeferredPlayer, COLLECTED_KEEP_MS, DEFERRED_KEEP_MS, deferRender, deferredRenderProgress, MAX_DEFERRED } from "../src/deferred-renders.ts";
+import type { RenderProgress } from "../src/render.ts";
 import type { PlayerData } from "../src/player.ts";
 
 const player = {} as PlayerData;
@@ -58,4 +59,22 @@ describe("deferred renders", () => {
     finish?.(player);
     expect((await waiting).kind).toBe("ready");
   });
+
+  it("tell how far a render is while it renders, and nothing once it is done or for an unknown id", async () => {
+    const reported: { latest?: RenderProgress } = {};
+    let finish: ((done: PlayerData) => void) | undefined;
+    const id = deferRender(
+      new Promise<PlayerData>((resolve) => {
+        finish = resolve;
+      }),
+      () => reported.latest,
+    );
+    expect(deferredRenderProgress(id)).toBeUndefined();
+    reported.latest = { stage: "singing", done: 0.4 };
+    expect(deferredRenderProgress(id)).toEqual({ stage: "singing", done: 0.4 });
+    finish?.(player);
+    await awaitDeferredPlayer(id);
+    expect(deferredRenderProgress(id)).toBeUndefined();
+    expect(deferredRenderProgress("no-such-render")).toBeUndefined();
+  });
 });
diff --git a/tests/render-pool.test.ts b/tests/render-pool.test.ts
index 24fa380..c1c8302 100644
--- a/tests/render-pool.test.ts
+++ b/tests/render-pool.test.ts
@@ -1,7 +1,9 @@
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { describe, expect, it } from "vitest";
-import { JingleScriptError, NeutrinoMissingError, parseScore, render, SamplesNotLoadedError, type Score } from "../src/index.ts";
+import { JingleScriptError, NeutrinoMissingError, parseScore, render, SamplesNotLoadedError, type RenderProgress, type Score } from "../src/index.ts";
 import { renderNow } from "../src/render.ts";
 import { fixtureSamples } from "./sample-fixture.ts";
 
@@ -29,6 +31,50 @@ const sung = parseScore({
   tracks: [{ instrument: "organ", sing: { engine: "neutrino" }, notes: [{ at: 1, pitch: "C4", lyric: "か" }] }],
 });
 
+/**
+ * A stand-in NEUTRINO install: musicXMLtoLabel writes empty labels; neutrino prints its progress as
+ * the real one does with -t (\r-separated), taking about a second, then writes 6 s of quiet tone.
+ */
+function fakeNeutrino(): string {
+  const dir = mkdtempSync(join(tmpdir(), "neutrino-progress-"));
+  mkdirSync(join(dir, "bin"));
+  mkdirSync(join(dir, "model", "REINA"), { recursive: true });
+  writeFileSync(join(dir, "model", "REINA", "info.toml"), "");
+  writeFileSync(join(dir, "model", "REINA", "version_information.txt"), "REINA v3.2.2");
+  const node = `#!${process.execPath}\nconst fs = require("node:fs");\nconst args = process.argv.slice(2);\n`;
+  writeFileSync(join(dir, "bin", "musicXMLtoLabel"), `${node}fs.writeFileSync(args[1], ""); fs.writeFileSync(args[2], "");\n`);
+  writeFileSync(
+    join(dir, "bin", "neutrino"),
+    `${node}const wait = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+for (const p of [10, 40, 70]) { process.stdout.write("   progress = " + p + " % (x / y sec)"); wait(400); }
+process.stdout.write("   progress = 100 % (y / y sec)finish\\n");
+const rate = 48000, n = rate * 6, wav = Buffer.alloc(44 + n * 2);
+wav.write("RIFF", 0); wav.writeUInt32LE(36 + n * 2, 4); wav.write("WAVEfmt ", 8); wav.writeUInt32LE(16, 16);
+wav.writeUInt16LE(1, 20); wav.writeUInt16LE(1, 22); wav.writeUInt32LE(rate, 24); wav.writeUInt32LE(rate * 2, 28);
+wav.writeUInt16LE(2, 32); wav.writeUInt16LE(16, 34); wav.write("data", 36); wav.writeUInt32LE(n * 2, 40);
+for (let i = 0; i < n; i++) wav.writeInt16LE(i % 100 < 50 ? 1000 : -1000, 44 + i * 2);
+fs.writeFileSync(args[4], wav);
+`,
+  );
+  chmodSync(join(dir, "bin", "musicXMLtoLabel"), 0o755);
+  chmodSync(join(dir, "bin", "neutrino"), 0o755);
+  return dir;
+}
+
+/** Runs `body` with these environment variables set (the worker shares the environment), then restores them. */
+async function withEnv(vars: Record<string, string>, body: () => Promise<void>): Promise<void> {
+  const before = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]));
+  Object.assign(process.env, vars);
+  try {
+    await body();
+  } finally {
+    for (const [key, value] of Object.entries(before)) {
+      if (value === undefined) Reflect.deleteProperty(process.env, key);
+      else process.env[key] = value;
+    }
+  }
+}
+
 describe("render() on a worker thread", () => {
   it("gives the same audio, timing and stats as rendering in place", async () => {
     const options = { samples: fixtureSamples };
@@ -73,4 +119,16 @@ describe("render() on a worker thread", () => {
       else process.env.NEUTRINO_DIR = before;
     }
   });
+
+  it.runIf(onWorker && process.platform !== "win32")("reports NEUTRINO's progress while it sings, then the mix", async () => {
+    await withEnv({ NEUTRINO_DIR: fakeNeutrino(), JINGLESCRIPT_CACHE: mkdtempSync(join(tmpdir(), "jinglescript-cache-")) }, async () => {
+      const progress: RenderProgress[] = [];
+      await render(sung, { onProgress: (p) => progress.push(p) });
+      const singing = progress.flatMap((p) => (p.stage === "singing" ? [p.done] : []));
+      expect(singing[0]).toBe(0);
+      expect(singing.some((done) => done > 0 && done < 1)).toBe(true); // heard while NEUTRINO ran
+      expect(singing).toEqual([...singing].sort((a, b) => a - b));
+      expect(progress.at(-1)).toEqual({ stage: "mixing" });
+    });
+  });
 });
diff --git a/tests/singer-neutrino.test.ts b/tests/singer-neutrino.test.ts
index a399e10..9f090ab 100644
--- a/tests/singer-neutrino.test.ts
+++ b/tests/singer-neutrino.test.ts
@@ -5,10 +5,11 @@ import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { afterEach } from "vitest";
 import { parseScore } from "../src/score.ts";
-import { render, setSinger, SingerUnavailableError } from "../src/render.ts";
+import { render, setSinger, SingerUnavailableError, type RenderProgress } from "../src/render.ts";
 import {
   findNeutrino,
   neutrinoCacheKey,
+  neutrinoProgress,
   DEFAULT_NEUTRINO_DIR,
   neutrinoDir,
   neutrinoMusicXml,
@@ -125,6 +126,14 @@ describe("cache key", () => {
   });
 });
 
+describe("NEUTRINO's progress", () => {
+  it("is the last `progress = N %` it printed (with -t), as 0…1", () => {
+    expect(neutrinoProgress("load models : 0.000 [sec]\n")).toBeUndefined();
+    expect(neutrinoProgress("   progress = 32 % (2.590 / 8.000 sec)   progress = 92 % (7.400 / 8.000 sec)")).toBeCloseTo(0.92, 9);
+    expect(neutrinoProgress("progress = 100 % (8.000 / 8.000 sec)finish : 4.863 [sec]")).toBe(1);
+  });
+});
+
 describe("NEUTRINO through render() (mocked)", () => {
   afterEach(() => configureNeutrino({}));
   it("runs the two tools in the install, trims the lead-in, resamples and caches", async () => {
@@ -142,7 +151,7 @@ describe("NEUTRINO through render() (mocked)", () => {
     const sung = singTrack(score, 0, options, 44100);
     expect(calls.map((c) => c.file)).toEqual([join(dir, "bin", "musicXMLtoLabel"), join(dir, "bin", "neutrino")]);
     expect(calls.every((c) => c.cwd === dir)).toBe(true);
-    expect(calls[1]?.args.slice(5)).toEqual([join(dir, "model", "REINA") + "/", "-n", "2", "-k", "0", "-f", "1", "-s", "48000", "-b", "16"]);
+    expect(calls[1]?.args.slice(5)).toEqual([join(dir, "model", "REINA") + "/", "-n", "2", "-k", "0", "-f", "1", "-s", "48000", "-b", "16", "-t"]);
     expect(sung.voice).toBe("REINA");
     expect(sung.pcm).toHaveLength(44100);
     expect(Math.abs((sung.pcm[22050] ?? 0) - 0.5)).toBeLessThan(0.01);
@@ -150,6 +159,22 @@ describe("NEUTRINO through render() (mocked)", () => {
     expect(again.cached).toBe(true);
     expect(calls).toHaveLength(2);
   });
+  it("tells onProgress when singing starts and ends, and has NEUTRINO print its progress to a file", async () => {
+    const dir = await fakeInstall();
+    const cacheDir = await mkdtemp(join(tmpdir(), "neutrino-cache-"));
+    const logs: (string | undefined)[] = [];
+    const exec: NeutrinoExec = (file, args, _env, _cwd, stdout) => {
+      if (!file.endsWith("neutrino")) return;
+      logs.push(stdout);
+      writeFileSync(args[4] ?? "", toWav([new Float32Array(48000 * 6).fill(0.1)], 48000, 16));
+    };
+    configureNeutrino({ dir, cacheDir, exec });
+    const progress: RenderProgress[] = [];
+    await render(parseScore({ ...rawScore, tracks: [{ ...rawScore.tracks[0], sing: { engine: "neutrino" } }] }), { onProgress: (p) => progress.push(p) });
+    expect(progress).toEqual([{ stage: "singing", done: 0 }, { stage: "mixing" }]);
+    expect(logs).toHaveLength(1);
+    expect(logs[0]).toMatch(/progress\.log$/);
+  });
   it("without NEUTRINO, or without the voice: a clear error, no fallback", async () => {
     const sung = parseScore({ ...rawScore, tracks: [{ ...rawScore.tracks[0], sing: { engine: "neutrino" } }] });
     configureNeutrino({ dir: "/nonexistent" });

From 1b8b2ba94beefe24785605b814701055f489bf77 Mon Sep 17 00:00:00 2001
From: snakajima <satoshi.nakajima@gmail.com>
Date: Tue, 27 Oct 2026 17:07:00 -1000
Subject: [PATCH 2/2] 1.1.0 (both packages; the plugin's peer ^1.1.0)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 gui-plugin/package.json | 4 ++--
 package.json            | 2 +-
 src/version.ts          | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/gui-plugin/package.json b/gui-plugin/package.json
index 97bf7a9..c9b2288 100644
--- a/gui-plugin/package.json
+++ b/gui-plugin/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@gui-chat-plugin/jinglescript",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "GUI Chat Protocol plugin for JingleScript: the manageJingleScript tool, with a player view for rendered jingles (waveform, cues, beats, notes).",
   "keywords": [
     "gui-chat-protocol",
@@ -55,7 +55,7 @@
   },
   "peerDependencies": {
     "gui-chat-protocol": "^2.3.0",
-    "jinglescript": "^1.0.3",
+    "jinglescript": "^1.1.0",
     "vue": "^3.5.43"
   },
   "devDependencies": {
diff --git a/package.json b/package.json
index 3bcbd91..12f74e6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jinglescript",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "A score language for short jingles and sound effects that an LLM writes, rendered to audio plus a timing map for syncing animation.",
   "keywords": [
     "jingle",
diff --git a/src/version.ts b/src/version.ts
index 277e2d3..f19c16a 100644
--- a/src/version.ts
+++ b/src/version.ts
@@ -1,7 +1,7 @@
 // Generated by scripts/write-version.ts from package.json (run by `npm version` / `yarn version`) — do not edit.
 // The package's version, for the CLI's --version, the MCP server's handshake and the browser
 // loader's default CDN URL; a constant, so the browser entry needs no file read.
-export const PACKAGE_VERSION = "1.0.3";
+export const PACKAGE_VERSION = "1.1.0";
 
 export function packageVersion(): string {
   return PACKAGE_VERSION;