@hraness/dawg 0.5.0 → 0.6.0

package/src/tui/menu.ts

@@ -13,6 +13,7 @@ import { HINTS } from "../../tui/grammar.ts";
 import { arrangeDetail, arrangeNodes } from "./arrange-menu.ts";
 import { auditionKey, isStageable, type AuditionKey } from "./audition.ts";
 import { performanceDetail, performanceNodes } from "./performance-menu.ts";
+import { malletsMenu, modalParameterNodes } from "./modal-menu.ts";
 import type { FaderSpec } from "./fader.ts";
 import {
   openingMeterCommand,
@@ -25,6 +26,7 @@ import {
   automationPoints,
   automationRange,
   REVERB_IR_BUILTINS,
+  SAMPLE_FIT_MODES,
   SAMPLE_UNITS,
   SCORE_LIMITS,
   isTrackAutomationParameter,
@@ -42,6 +44,9 @@ import {
   CORE_EFFECTS,
   EFFECT_NAMES,
   FX_LANES,
+  RIG_PRESETS,
+  RIG_STAGES,
+  rigPresetOf,
   effectPresetNames,
   effectSpec,
   type EffectName,
@@ -85,6 +90,22 @@ import {
   SYNTH_SIMPLE,
   normalizeSynth,
 } from "../../core/synth.ts";
+import {
+  isStringTrack,
+  STRING_PARAMS,
+  STRING_PRESET_NAMES,
+  STRING_PRESETS,
+  STRING_SIMPLE_PARAMS,
+  stringPresetOf,
+} from "../../core/strings.ts";
+import {
+  KEYS_PARAMS,
+  KEYS_PRESETS,
+  KEYS_SIMPLE,
+  PIANO_FAMILIES,
+  isPianoFamily,
+  resolvedKeys,
+} from "../../core/keys.ts";
 import type { PickerItem } from "../../tui/app.ts";
 import { BUILTIN_TABLES, BUILTIN_TABLE_NAMES } from "../audio/wavetable.ts";
 import {
@@ -114,6 +135,12 @@ import {
   type Tuning,
 } from "../../core/tuning.ts";
 import { rootName, tuningStepsText } from "../commands/tuning.ts";
+import {
+  granularBrowseNodes,
+  granularMenuDetail,
+  granularMenuLabel,
+  granularMenuNodes,
+} from "./granular-menu.ts";
 import {
   ARP_RATES,
   CHORD_MODES,
@@ -321,7 +348,7 @@ const TRACK_LANE_LABEL: Readonly<Record<TrackAutomationParameter, string>> = {
 const FX_LANE_INFO = new Map(FX_LANES.map((entry) => [entry.lane, entry]));
 
 /** Nudge for a number spec: linear by its step, or a sixth of an octave. */
-function specStep(
+export function specStep(
   spec: NumberParam,
 ): (value: number, direction: 1 | -1) => number {
   if (spec.step === "log")
@@ -354,7 +381,12 @@ function laneLabel(lane: AutomationParameter): string {
   if (!info) return lane;
   const unit = info.spec.unit ? ` (${info.spec.unit})` : "";
   const owner =
-    info.effect === "synth" ? "synth" : effectSpec(info.effect).label;
+    info.effect === "synth" ||
+    info.effect === "string" ||
+    info.effect === "keys" ||
+    info.effect === "modal"
+      ? info.effect
+      : effectSpec(info.effect).label;
   return `${owner} ${info.param}${unit}`;
 }
 
@@ -486,8 +518,42 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
           },
         ]
       : [];
+  const grainLabel = granularMenuLabel(track);
+  const granular: MenuNode[] =
+    track && grainLabel
+      ? [
+          {
+            kind: "menu",
+            id: "granular",
+            label: grainLabel,
+            detail: granularMenuDetail(track),
+            help: "grain clouds: preset, source, position, scan, grain size, pitch, shimmer",
+            build: (inner) => granularMenuNodes(focused(inner)),
+          },
+        ]
+      : [];
+  const keys: MenuNode[] =
+    track && isPianoFamily(track.instrument) && track.keys
+      ? [
+          {
+            kind: "menu",
+            id: "keys",
+            label: "keys",
+            detail: `${track.instrument}${track.keys.preset ? ` · ${track.keys.preset}` : ""}`,
+            help: "the modelled piano: preset, touch, hammers, dampers, stretch",
+            build: (inner) => {
+              const current = focused(inner);
+              return current
+                ? keysNodes(current, Object.keys(KEYS_PARAMS))
+                : [];
+            },
+          },
+        ]
+      : [];
   return [
     ...parameterNodes(context),
+    ...granular,
+    ...keys,
     ...tuning,
     {
       kind: "menu",
@@ -903,7 +969,7 @@ function trackNodes(context: MenuContext): MenuNode[] {
 }
 
 function instrumentNode(track: Track): MenuNode {
-  const options: string[] = [...AVAILABLE_INSTRUMENTS];
+  const options: string[] = [...AVAILABLE_INSTRUMENTS, ...PIANO_FAMILIES];
   if (!options.includes(track.instrument)) options.push(track.instrument);
   return {
     kind: "choice",
@@ -956,6 +1022,30 @@ function parameterNodes(context: MenuContext): MenuNode[] {
   // A wavetable track also has the synth voice's envelope, filters and FM.
   if (isWavetableInstrument(track.instrument))
     nodes.push(...wavetableNodes(track, context.projectRoot));
+  if (isStringTrack(track)) {
+    nodes.push(...stringNodes(track, STRING_SIMPLE_PARAMS));
+    nodes.push({
+      kind: "menu",
+      id: "string:advanced",
+      label: "advanced",
+      detail: `all ${Object.keys(STRING_PARAMS).length} params`,
+      help: "every string parameter: exciter, loss, body, buzz, sympathetics",
+      build: (inner) => {
+        const current = focused(inner);
+        return current
+          ? stringNodes(current, Object.keys(STRING_PARAMS), false)
+          : [];
+      },
+    });
+    if (Object.keys(track.string ?? {}).some((key) => key !== "preset"))
+      nodes.push({
+        kind: "action",
+        label: "reset to preset",
+        command: "string reset",
+        help: "drop this track's string overrides, keep the preset",
+      });
+    return nodes;
+  }
   if (track.sampler) {
     nodes.push({
       kind: "info",
@@ -982,6 +1072,22 @@ function parameterNodes(context: MenuContext): MenuNode[] {
       label: "add a voice",
       value: "/sample <path> [as <voice>]",
     });
+  } else if (isPianoFamily(track.instrument) && track.keys) {
+    nodes.push(...keysNodes(track, KEYS_SIMPLE));
+    nodes.push({
+      kind: "menu",
+      id: "keys:all",
+      label: "all piano params",
+      detail: `all ${Object.keys(KEYS_PARAMS).length} params`,
+      help: "every modelled piano parameter",
+      build: (inner) => {
+        const current = focused(inner);
+        return current ? keysNodes(current, Object.keys(KEYS_PARAMS)) : [];
+      },
+    });
+  } else if (track.instrument === "modal") {
+    // 0.6 modal percussion: preset, mallet and MODAL_PARAMS rows.
+    nodes.push(...modalParameterNodes(track));
   } else if (!isDrumInstrument(track.instrument)) {
     nodes.push(...synthNodes(track, SYNTH_SIMPLE));
     nodes.push({
@@ -1089,6 +1195,44 @@ function sampleVoiceNodes(context: MenuContext, voice: string): MenuNode[] {
       label: "cut / loopAt",
       value: `/sample set ${voice} cut hats · loopAt 2`,
     },
+    // 0.6 fit: the sample's own tempo, its length in beats, and how it fits.
+    {
+      kind: "number",
+      label: "bpm",
+      value: ref.bpm,
+      start: Math.round(context.score.tempoBpm),
+      off: "off",
+      min: SCORE_LIMITS.minSampleBpm,
+      max: SCORE_LIMITS.maxSampleBpm,
+      step: linear(1, SCORE_LIMITS.minSampleBpm, SCORE_LIMITS.maxSampleBpm),
+      format: num,
+      command: (value) => `/bpm ${num(value)} ${voice}`,
+      reset: `/bpm off ${voice}`,
+      help: SAMPLE_CONTROLS.bpm,
+    },
+    {
+      kind: "choice",
+      label: "fitmode",
+      // off: unset (plays as repitch); auto suggests one from the sound.
+      value: ref.fitmode ?? "off",
+      options: ["off", ...SAMPLE_FIT_MODES, "auto"],
+      command: (option) => `/fitmode ${option} ${voice}`,
+      help: `${SAMPLE_CONTROLS.fitmode} · beats for drums, tones for pads · set bpm or len first`,
+    },
+    {
+      kind: "number",
+      label: "len",
+      value: ref.len,
+      start: 4,
+      off: "off",
+      min: 0.25,
+      max: SCORE_LIMITS.maxSampleLenBeats,
+      step: linear(0.25, 0.25, SCORE_LIMITS.maxSampleLenBeats),
+      format: num,
+      command: (value) => `/len ${num(value)} ${voice}`,
+      reset: `/len off ${voice}`,
+      help: SAMPLE_CONTROLS.len,
+    },
   );
   return nodes;
 }
@@ -1105,6 +1249,57 @@ function matchingSynthPreset(track: Track): string | undefined {
   )?.[0];
 }
 
+/** Modelled piano rows: the preset, then each parameter (`keys <p> <v>`). */
+function keysNodes(track: Track, params: readonly string[]): MenuNode[] {
+  const effective = resolvedKeys(track.instrument, track.keys);
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "preset",
+      value: track.keys?.preset ?? "—",
+      options: Object.keys(KEYS_PRESETS),
+      command: (preset) => `keys preset ${preset}`,
+      help: "a starting piano; every value stays editable",
+    },
+  ];
+  for (const key of params) {
+    const param = KEYS_PARAMS[key]!;
+    const stored = track.keys?.[key];
+    if (param.kind === "number") {
+      const base = effective[key] as number;
+      nodes.push({
+        kind: "number",
+        label: key,
+        value: typeof stored === "number" ? stored : undefined,
+        start: base,
+        off: withUnit(formatParam(param, base), param.unit),
+        min: param.min,
+        max: param.max,
+        step: specStep(param),
+        format: (value) => withUnit(formatParam(param, value), param.unit),
+        command: (value) => `keys ${key} ${formatParam(param, value)}`,
+        reset: `keys ${key} off`,
+        help: param.doc,
+      });
+    } else if (param.kind === "enum")
+      nodes.push({
+        kind: "choice",
+        label: key,
+        value: typeof stored === "string" ? stored : String(effective[key]),
+        options: param.values,
+        command: (option) => `keys ${key} ${option}`,
+        help: param.doc,
+      });
+  }
+  nodes.push({
+    kind: "action",
+    label: "reset to the family",
+    command: "keys reset",
+    help: "clear every override and the preset, and the effects the preset added (keeps the family's own sound)",
+  });
+  return nodes;
+}
+
 function synthNodes(track: Track, keys: readonly string[]): MenuNode[] {
   const nodes: MenuNode[] = [];
   if (keys === SYNTH_SIMPLE)
@@ -1175,6 +1370,57 @@ const SYNTH_LABEL: Readonly<Record<string, string>> = {
   fm: "FM amount",
 };
 
+/** String preset first (simple view), then one row per parameter. */
+function stringNodes(
+  track: Track,
+  keys: readonly string[],
+  withPreset = true,
+): MenuNode[] {
+  const nodes: MenuNode[] = [];
+  const preset = STRING_PRESETS[stringPresetOf(track.string)]!;
+  if (withPreset)
+    nodes.push({
+      kind: "choice",
+      label: "preset",
+      help: preset.doc,
+      value: stringPresetOf(track.string),
+      options: STRING_PRESET_NAMES,
+      command: (name) => `string preset ${name}`,
+    });
+  for (const key of keys) {
+    const param = STRING_PARAMS[key]!;
+    const own = track.string?.[key];
+    const base = preset.values[key] ?? param.default;
+    if (param.kind === "number")
+      nodes.push({
+        kind: "number",
+        label: param.unit ? `${key} ${param.unit}` : key,
+        help: param.doc,
+        value: typeof own === "number" ? own : undefined,
+        start: typeof base === "number" ? base : param.default,
+        off: formatParam(
+          param,
+          typeof base === "number" ? base : param.default,
+        ),
+        min: param.min,
+        max: param.max,
+        step: specStep(param),
+        format: (value) => formatParam(param, value),
+        command: (value) => `string ${key} ${formatParam(param, value)}`,
+      });
+    else if (param.kind === "enum")
+      nodes.push({
+        kind: "choice",
+        label: key,
+        help: param.doc,
+        value: typeof own === "string" ? own : String(base),
+        options: param.values,
+        command: (option) => `string ${key} ${option}`,
+      });
+  }
+  return nodes;
+}
+
 /** Every synth parameter, grouped (amplitude, oscillator, FM 1..8, …). */
 function synthAdvancedNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
@@ -1324,10 +1570,38 @@ function effectNodes(context: MenuContext): MenuNode[] {
       build: (inner) => effectParamNodes(inner, effect, false),
     };
   };
-  const more = EFFECT_NAMES.filter((effect) => !CORE_EFFECTS.includes(effect));
+  const rigStages = RIG_STAGES as readonly string[];
+  const more = EFFECT_NAMES.filter(
+    (effect) => !CORE_EFFECTS.includes(effect) && !rigStages.includes(effect),
+  );
   const moreOn = more.filter((effect) => effectValues(track, effect));
+  // 0.6 guitar rig: stomp → head (with its gate) → cab, plus whole rigs.
+  const rigOn = RIG_STAGES.filter((stage) => effectValues(track, stage));
+  const rig: MenuNode = {
+    kind: "menu",
+    id: "guitar rig",
+    label: "Guitar rig",
+    help: "stomp box, amp head with noise gate and speaker cabinet; `rig <name>` loads a whole rig",
+    detail:
+      rigOn.length === 0 ? "off" : (rigPresetOf(track.fx) ?? rigOn.join(" → ")),
+    build: (inner) => {
+      const current = focused(inner);
+      return [
+        {
+          kind: "choice",
+          label: "rig",
+          value: rigPresetOf(current?.fx) ?? "—",
+          options: [...Object.keys(RIG_PRESETS), "reset"],
+          command: (name) => `rig ${name}`,
+          help: "a whole rig (stomp, head, cab); every stage stays editable",
+        },
+        ...RIG_STAGES.map(node),
+      ];
+    },
+  };
   return [
     ...CORE_EFFECTS.map(node),
+    rig,
     {
       kind: "menu",
       id: "more effects",
@@ -1495,6 +1769,9 @@ function automationNodes(context: MenuContext): MenuNode[] {
     const info = FX_LANE_INFO.get(lane as FxLane);
     if (info?.effect === "synth")
       return track.synth?.[info.param] !== undefined;
+    if (info?.effect === "string") return track.string !== undefined;
+    if (info?.effect === "keys") return track.keys !== undefined;
+    if (info?.effect === "modal") return track.modal !== undefined;
     return info !== undefined && effectValues(track, info.effect) !== undefined;
   });
   const hidden = AUTOMATION_PARAMETERS.filter((lane) => !shown.includes(lane));
@@ -1676,14 +1953,54 @@ function patternsMenu(): MenuNode {
   };
 }
 
+const GRANULAR_PRESETS_COUNT = granularBrowseNodes().length;
+
 function soundNodes(): MenuNode[] {
   return [
+    {
+      kind: "menu",
+      id: "group:keys",
+      label: "Keys",
+      help: "modelled pianos, built in (no download)",
+      detail: Object.keys(KEYS_PRESETS).join(" "),
+      build: () =>
+        Object.entries(KEYS_PRESETS).map(([name, preset]): MenuNode => ({
+          kind: "action",
+          label: `${name.padEnd(10)} ${preset.doc}`,
+          command: `piano ${name}`,
+          help: preset.styles,
+        })),
+    },
     {
       kind: "action",
       label: "wavetable synth  basic shapes morph · built-in",
       command: "wt basic",
       help: "switch this track to the morphing wavetable synth",
     },
+    // 0.6 instrument groups, one per lane.
+    malletsMenu(),
+    {
+      kind: "menu",
+      id: "strings",
+      label: "Strings",
+      help: "plucked strings: guitars, basses, sitar, harpsichord, oud, koto…",
+      detail: `${STRING_PRESET_NAMES.length} plucked · built-in`,
+      build: () =>
+        STRING_PRESET_NAMES.map((name): MenuNode => ({
+          kind: "action",
+          label: `${name.padEnd(12)} ${STRING_PRESETS[name]!.doc}`,
+          command: `string ${name}`,
+          help: STRING_PRESETS[name]!.styles,
+        })),
+    },
+    {
+      kind: "menu",
+      id: "granular-browse",
+      label: "Granular",
+      help: "grain clouds from a built-in synth or this track's own sound",
+      detail: `${GRANULAR_PRESETS_COUNT} presets · built-in`,
+      build: granularBrowseNodes,
+    },
     {
       kind: "menu",
       id: "instruments",
@@ -2372,11 +2689,17 @@ export class EditMenu {
                     candidate.kind === "choice" &&
                     candidate.label === node.label,
                 ) ?? node;
-            return live.options.map((option) => ({
-              kind: "action",
-              label: option === live.value ? `${option}  ✓` : option,
-              command: live.command(option),
-            }));
+            // The current value is shown, not re-run: re-confirming a
+            // legacy `piano` would otherwise re-voice it as the grand.
+            return live.options.map((option): MenuNode =>
+              option === live.value
+                ? { kind: "info", label: `${option}  ✓`, value: "current" }
+                : {
+                    kind: "action",
+                    label: option,
+                    command: live.command(option),
+                  },
+            );
           },
         });
         return { type: "handled" };

package/src/tui/modal-menu.ts

@@ -0,0 +1,118 @@
+/**
+ * Ctrl-k menu rows for modal percussion (0.6): the "Mallets and bells"
+ * group under Sound › browse sounds, and the MODAL_PARAMS rows under
+ * Sound › Parameters on a modal track. Every row runs a `modal …` command.
+ */
+import type { EnumParam, NumberParam } from "../../core/params.ts";
+import {
+  MODAL_INSTRUMENT,
+  MODAL_MALLET_NAMES,
+  MODAL_PARAMS,
+  MODAL_PRESETS,
+  MODAL_PRESET_NAMES,
+  MODAL_SIMPLE,
+  modalSettings,
+} from "../../core/resonators.ts";
+import type { Track } from "../../core/score.ts";
+import { num, specStep, type MenuNode } from "./menu.ts";
+
+/** Sound › browse sounds › Mallets and bells: one row per preset. */
+export function malletsMenu(): MenuNode {
+  return {
+    kind: "menu",
+    id: "mallets",
+    label: "Mallets and bells",
+    detail: `${MODAL_PRESET_NAMES.length} modal presets · marimba, vibes, gong …`,
+    help: "struck bars, bells and bowls on the modal resonator engine",
+    build: () =>
+      MODAL_PRESET_NAMES.map((name): MenuNode => ({
+        kind: "action",
+        label: `${name}  ${MODAL_PRESETS[name].doc}`,
+        command: `modal ${name}`,
+        help: MODAL_PRESETS[name].styles,
+      })),
+  };
+}
+
+function numberRow(
+  name: string,
+  spec: NumberParam,
+  value: number,
+  fallback: number,
+): MenuNode {
+  return {
+    kind: "number",
+    label: name,
+    value,
+    min: spec.min,
+    max: spec.max,
+    step: specStep(spec),
+    format: (v) => (spec.unit ? `${num(v)} ${spec.unit}` : num(v)),
+    command: (v) => `modal ${name} ${num(v)}`,
+    reset: `modal ${name} off`,
+    help: `${spec.doc} · preset ${num(fallback)} · x resets`,
+  };
+}
+
+/** Sound › Parameters rows on a modal track. */
+export function modalParameterNodes(track: Track): MenuNode[] {
+  if (track.instrument !== MODAL_INSTRUMENT) return [];
+  const modal = track.modal;
+  const preset = MODAL_PRESETS[modal?.preset ?? "marimba"].settings;
+  const resolved = modalSettings(modal) as Readonly<
+    Record<string, number | string>
+  >;
+  const row = (name: string): MenuNode | undefined => {
+    const spec = MODAL_PARAMS[name]!;
+    if (name === "mallet")
+      return {
+        kind: "choice",
+        label: "mallet",
+        value: modal?.mallet ?? "preset",
+        options: ["preset", ...MODAL_MALLET_NAMES],
+        command: (option) =>
+          option === "preset" ? "modal mallet off" : `modal mallet ${option}`,
+        help: (spec as EnumParam).doc,
+      };
+    if (spec.kind !== "number") return undefined;
+    return numberRow(
+      name,
+      spec,
+      Number(resolved[name]),
+      Number(preset[name as keyof typeof preset]),
+    );
+  };
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "preset",
+      value: modal?.preset ?? "marimba",
+      options: MODAL_PRESET_NAMES,
+      command: (option) => `modal preset ${option}`,
+      help: "the instrument: mode table, mallet and ring",
+    },
+  ];
+  for (const name of MODAL_SIMPLE) {
+    const node = row(name);
+    if (node) nodes.push(node);
+  }
+  const rest = Object.keys(MODAL_PARAMS).filter(
+    (name) => !(MODAL_SIMPLE as readonly string[]).includes(name),
+  );
+  nodes.push({
+    kind: "menu",
+    id: "modal:advanced",
+    label: "advanced",
+    detail: `motor, ombak, buzz, click, strike glide, gain`,
+    help: "every modal parameter",
+    build: () => rest.flatMap((name) => row(name) ?? []),
+  });
+  if (modal && Object.keys(modal).some((key) => key !== "preset"))
+    nodes.push({
+      kind: "action",
+      label: "reset to preset",
+      command: "modal reset",
+      help: "clear overrides, keep the preset",
+    });
+  return nodes;
+}

package/src/tui/play-session.ts

@@ -48,11 +48,13 @@ import {
   transportBarStart,
 } from "../../core/tempo.ts";
 import {
+  LiveFullRenderer,
   LiveSynth,
   MAX_LIVE_NOTE_SECONDS,
   type LiveNotePcm,
 } from "../audio/live.ts";
 import type { SampleBank } from "../audio/samples.ts";
+import { fitting, onFitReady } from "../audio/fit.ts";
 import {
   DEFAULT_STRUM,
   perform,
@@ -91,6 +93,8 @@ export interface LiveEngine {
   setLeadMs(ms: number | undefined): void;
   noteOn(id: number, note: LiveNotePcm): number;
   noteOff(id: number): void;
+  /** Frames of voice `id` mixed so far, or undefined once it has ended. */
+  voicePosition?(id: number): number | undefined;
   setClick(click: ClickBus | undefined): void;
 }
 
@@ -134,6 +138,8 @@ export const GRIDS: readonly Readonly<{ label: string; beats: number }>[] =
 export const DEFAULT_GRID = "1/16";
 /** Play mode's queue lead: short enough that a key feels immediate. */
 export const PLAY_LEAD_MS = 60;
+/** Status while a long fitted sample window computes (fit.ts). */
+const FITTING_STATUS = "fitting · the sample plays once ready";
 export const FLASH_MS = 110;
 
 export function gridBeats(label: string): number | undefined {
@@ -221,11 +227,16 @@ export class PlaySession {
   public countInBars = 1;
   public grid = DEFAULT_GRID;
   public status: string | undefined;
+  /** Unsubscribes the pending "fit ready" listener (fit.ts). */
+  private stopFitWait: (() => void) | undefined;
   /** Scale-degree layout on (`i`); follows key and tuning changes. */
   public degreesOn = false;
   private degreeKey: string | undefined;
   private active = false;
   private synth: LiveSynth | undefined;
+  /** Rig voices awaiting their full render: id → released since. */
+  private readonly windows = new Map<number, boolean>();
+  private readonly fullRenderer = new LiveFullRenderer();
   private readonly pending = new Map<number, Pending>();
   /** Sustain changes while recording (Tab latch or Shift), as pedal events. */
   private pendingPedal: { beat: number; state: PedalState }[] = [];
@@ -597,7 +608,7 @@ export class PlaySession {
     if (this.synth?.rate !== engine.sampleRate)
       this.synth = new LiveSynth(engine.sampleRate);
     const score = this.host.score();
-    const pcm = this.synth.render({
+    const request = {
       score,
       trackId: this.trackId,
       pitch: note.pitch,
@@ -607,16 +618,48 @@ export class PlaySession {
       ...(score.time?.tempo
         ? { tick: loopTickAt(score, this.host.beatAt(note.atMs)) }
         : {}),
-    });
+    };
+    const synth = this.synth;
+    const pcm = synth.render(request);
     if (!pcm) return;
+    if (pcm.fitting) {
+      // A long fitted sample window is computing: silent, never off-pitch.
+      this.status = FITTING_STATUS;
+      this.stopFitWait ??= onFitReady(() => {
+        if (fitting()) return;
+        this.stopFitWait?.();
+        this.stopFitWait = undefined;
+        if (this.status === FITTING_STATUS)
+          this.status = "fit ready · play the key again";
+      });
+      return;
+    }
     const scheduled = engine.noteOn(id, pcm);
     this.lastLatencyMs = Math.max(0, scheduled - this.host.now());
+    // A guitar rig sounds its first window now; the rest renders after the
+    // key event and replaces the voice in place while it is still sounding.
+    this.windows.delete(id);
+    if (pcm.partial) this.windows.set(id, false);
+    // The full pass runs on a worker, in key order, so a strummed chord or a
+    // fast run never stalls key handling behind an oversampled render.
+    if (pcm.partial)
+      void this.fullRenderer.full(synth, request).then((full) => {
+        // Not after note-off: a swap would cancel the release fade.
+        if (
+          full &&
+          this.windows.get(id) === false &&
+          engine.voicePosition?.(id) !== undefined
+        )
+          engine.noteOn(id, full);
+        this.windows.delete(id);
+      });
   }
 
   private release(ids: readonly number[], atMs: number): void {
     const engine = this.host.engine();
     for (const id of ids) {
       engine?.noteOff(id);
+      if (this.windows.has(id)) this.windows.set(id, true);
       const live = this.liveChords.get(id);
       if (live) live.releaseAtMs = Math.min(live.releaseAtMs, atMs);
       const pending = this.pending.get(id);