Eight-second takes: what the Generate button actually does

Eight seconds is a render budget, not a marketing number. We picked it because it survives a coffee-shop wifi round trip and still leaves room for a 24-bit WAV to write to disk.

When you click Generate on the composer, a small contract runs. You see a LinearProgress bar and the line Synthesizing — usually 8 seconds. That sentence is doing a lot of work. Below is what is actually happening on the wire and on the model floor — first in v1, where the backend is mocked, then in the production pipeline that ships next.

The v1 path: an in-memory job map

The v1 build has no real model behind the composer. The GraphQL gateway (lib/graphql/schema.ts) exposes a generate(input) mutation that inserts a row into a Map<jobId, JobRow> keyed by a freshly-minted jobId. The row carries status: "QUEUED", the prompt, the persona id, and tokens.generation.mockDurationMs — currently 8000.

A setTimeout flips the row to RUNNING after a 200 ms warm-up so the UI gets a real RUNNING tick rather than a synthetic skip-to-done. After the rest of the eight seconds, the row flips to DONE. The composer polls a job(id) query every 600 ms and watches the status field.

Two design rules carry over from this mock:

1. The browser never auto-plays the result. The composer pushes the finished song into LibraryProvider and primes the sticky player. Pressing play is the listener's call. Browser autoplay policy aside, we want renders to feel like printed takes, not loops.
2. generate is the only path that creates a job. Hovering, scrubbing, and seeking on the player do not open new jobs. Restraint here saves us a class of bugs the day a real GPU pool is on the other end.

The production path: same shape, different middle

The shipping pipeline keeps the GraphQL contract. generate(input) still returns a jobId. job(id) still polls. What changes is what runs between RUNNING and DONE:

1. Tokenise the prompt. The free-text prompt is normalised, persona tags are merged in front, and the result is tokenised with a custom sentence-piece variant tuned for music vocabulary. We deliberately drop the top-k for genre tokens to keep style stable across re-runs of the same prompt.
2. Pull the persona prefix. Every persona ships with a stored reference embedding (we use WavLM features pooled over a 12-second reference clip). At generation time we concatenate the persona prefix to the prompt embedding so the model sees the voice before it sees the words.
3. Latent diffusion over the mel-spectrogram. A latent-diffusion stack denoises a 96-channel mel representation conditioned on the joined embedding. Twenty-four diffusion steps. Classifier-free guidance scale set per persona — choirs need a higher scale than spoken-word personas.
4. Vocoder. A neural vocoder lifts the mel back to waveform at 44.1 kHz, 24-bit internal. We export 24-bit WAV at the same rate. No sample-rate conversion at the edge — every conversion costs transient definition.
5. Loudness check. Render is measured at integrated LUFS. If the render falls outside −18 to −12 LUFS, the gateway tags the job with a warn status flag. The composer surfaces it next to the title. We do not auto-master.

The job flips DONE when the WAV is written to object storage and a signed URL is returned. The composer pushes the row into the library and primes the player. Same shape as the mock.

What gates the status flip

A render does not flip to DONE on the diffusion finishing. It flips when three things are true:

• The WAV file is fully written and content-length-checked.
• The artwork is generated and uploaded.
• The audit row (prompt, persona id, seed, model version, LUFS) is written to the audit log.

That last one matters. The audit row is what makes a render licensable under the Studio tier. Without it, the take is a draft.

Why eight seconds, again

A v0 of the composer used a six-second mock. It tested badly: users clicked Generate twice, then a third time, before the first job finished. Eight seconds, with a visible LinearProgress and a specific number in the copy, stopped that. The number is honest in both directions — it is the upper bound for the mock and a realistic median for the production stack on warm GPUs.

If your render is taking longer than ten seconds, something has cooled off in the pool. The composer surfaces a single retry option. We do not add a spinner. We do not add a second progress bar. The room stays quiet while the take finishes.

Open the composer