Skip to content

Instrument module for mono and polyphonic instruments - #59

Merged
danigb merged 17 commits into
mainfrom
instrument
Sep 12, 2026
Merged

danigb merged 17 commits into
mainfrom
instrument

Conversation

@danigb

@danigb danigb commented Sep 12, 2026

Copy link
Copy Markdown
Owner

Made with Claude

danigb and others added 17 commits September 8, 2026 13:58
Nothing in the library assigns a note to a voice. `scripts/_voices.ts` is the
piece every later instrument ticket writes automation through, and it is the
one a native poly worklet would reuse verbatim, so it lands first: pure, with
no imports, no nodes and no clock, and tested in node before a single node
exists.

`createVoiceAllocator` follows stmlib's three ordered rules - reuse the voice
already sounding this note, else the voice released longest ago, else steal -
with four steal modes. The default, `Protect`, is JUCE's rule: the lowest and
the highest sounding notes survive a dense chord. An allocation reports what a
steal cost, because the pool has to fade the losing voice before it writes the
new note and cannot know what to fade unless it is told.

`createNoteStack` keeps the held keys in press order and in pitch order at
once, which is what the four mono priorities of Synth Secrets Part 18 read.
Its three example lines are transcribed as the test's reference, including the
direction-changing one where all four priorities differ and two of them play
only three of the four notes.

Also scaffolds `@synthlet/instrument` so the tests have somewhere to run, adds
the `_voices.ts` stanza to `copy_files.sh` and the drift check that keeps its
one copy honest, and records the derivation in THIRD-PARTY-LICENSES.md:
stmlib's algorithm under its MIT notice, JUCE's protect rule described from
documentation rather than source, and Part 18 cited rather than derived.

Claude-Session: https://claude.ai/code/session_01YYYpLQmn1c2KtsPCtk4pXf
Every factory and every registrar in the library was typed `AudioContext`, and
nothing in the library needs one: a sweep of `packages/*/src` for `resume`,
`suspend`, `baseLatency` and `outputLatency` finds nothing, and the spec puts
`audioWorklet` on `BaseAudioContext`. The type was a habit, and it made an
`OfflineAudioContext` a compile error - which is why play's research recorded
synthlet as "not a 'no' on offline, but unverified" and hand-rolled its
instrument instead.

`Connector`, `createWorkletConstructor` and `createRegistrar` in
`scripts/_worklet.ts` now name `BaseAudioContext`, `copy_files.sh` carries that
to all 25 copies, and every package factory, `waa.ts` helper, compound and
`register*Worklet` follows. `AudioContext` is a subtype, so no call site
changes. The three multi-worklet registrars - `registerAllWorklets`,
`registerMonoSynth`, `registerDrums` - are generic in the context rather than
returning the base type, so `site/app/audio-context.ts`'s
`Promise<AudioContext>` still holds; `offline.test.ts` asserts that at compile
time in a function it never calls.

The half that cannot be a type change is proof that an offline render happens
at all. `packages/synthlet/src/offline.test.ts` registers all 24 worklets on an
`OfflineAudioContext`, renders `PolyblepOscillator -> AdsrAmp` and a whole
`MonoSynth` - five worklets and two `Param` inlets, the biggest graph the
library has - and measures the envelope by RMS in 10 ms windows: silent before
the gate, full amplitude one window after it, two orders of magnitude down
after the release. It also renders the same graph twice and asserts the two
buffers are sample-identical, because a rendered buffer is only usable as a
reference if it is reproducible.

The harness is the spike's answer: `node-web-audio-api` runs synthlet's
worklets in node, including `createRegistrar`'s `blob:` URL registration, so
the render is a normal jest test in CI and the Playwright fallback is not
needed. It is ESM-only and jest's CommonJS runtime cannot import it from inside
a test, so `scripts/offline-audio-env.mjs` is a jest environment - loaded by
jest-runner in the real node realm - that puts the implementation in the
globals; a file opts in with an `@jest-environment` docblock. The topology mock
the rest of the suite uses is untouched.

Not included, because `@synthlet/instrument` is still being written: the
instrument's own offline render and the play adapter's `OfflineAudioContext`
type check. Both are one test each on top of this.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016Kc2SbQKPqXsSxnh6YULDZ
`Instrument(ctx, definition, options)` is the module this folder exists for: a
voice definition in, n voices out, behind smplr's surface. There was no way to
play a chord on a synthlet synth before it - `MonoSynth` has one `gate` and one
`frequency`, and a second note either does nothing or retriggers the first.

A definition, not a bare factory: `{ params, create, register }`, because
without `params` there is no preset schema and no fan-out to hand `create`, and
without `register` there is no `ready`. Per-instrument parameters are one
`ConstantSourceNode` each connected to every voice, so every knob is an
`AudioParam` and a preset will be one write per parameter. A native constant
source rather than `@synthlet/param`'s `Param`, which is a worklet this package
cannot register without carrying a copy of its processor; the casualty is
scaling, and values are in the parameter's own units.

A note is automation on a param that already exists, so `start` connects
nothing: it picks a voice and writes pitch, then level, then the gate, all at
one time. That is also what makes `stop({ time })` exact - `cancelScheduledValues`
followed by `setValueAtTime(0, time)` cuts a note that is merely scheduled as
well as one that is sounding, which is play's `stopAll` contract.

Construction is synchronous and the instrument is a node, so a host connects it
and builds its effects before `ready` resolves; notes started before then are
queued and flushed, and dropped if their time has passed. A steal fades the
losing voice on the gain the allocator owns, ending at the new note's time.

Extends `packages/synthlet/src/test-utils.ts` with an automation log and a
mutable `currentTime`: the log is the audible behaviour, so it is what the
tests assert on. The existing `setValueAtTime(x, 0)` behaviour is unchanged.

Claude-Session: https://claude.ai/code/session_01YYYpLQmn1c2KtsPCtk4pXf
`voices: 1` was a pool of one, and a pool of one is not a monosynth. Play two
keys and the second stole the first - always, whatever the pitch or the order -
and releasing the second left silence rather than returning to the first,
because a pool has no memory of what else is held.

`src/mono.ts` routes `voices: 1` through the note stack instead of the
allocator. It is pure: `monoStart`/`monoStop`/`monoStopAll` answer "what should
be written, and when" as write descriptors, with no Web Audio and no sample
rate in sight, so Synth Secrets Part 18's three example lines are asserted as
data before any of it reaches a node - including that on the line which changes
direction all four priorities differ and two of them play only three of the
four notes. `legato` is the article's other axis, single versus multi
triggering, which on the gate contract is one decision: dip the gate for a
sample between two notes, or leave it high.

`glide` is portamento in seconds and works at any voice count, because an
exponential ramp in Hz is a linear ramp in pitch and needs no DSP. It is per
voice, from that voice's own last note, which is what a hardware poly with a
portamento knob does; a stolen voice glides from the note it was stolen from.
Constant-time rather than constant-rate, which is what the ramp gives free.

`synth.hold` is the sustain pedal, on both paths: a key release is remembered
while it is down and applied when it lifts, pressing the key again cancels the
deferral, and the all-notes `stop()` ignores it entirely. Ticket 05's latch is
the same set.

rune06's portamento-tail preference among idle voices is deliberately not
adopted, and the comment at the allocator says why: `_voices.ts` never asks
what time it is, so it cannot know whether a ramp has ended, and teaching it
would cost the property that makes the file copyable into a worklet.

Claude-Session: https://claude.ai/code/session_01YYYpLQmn1c2KtsPCtk4pXf
There was no way to name a sound. `grep -ri preset packages/*/src` found two
comments in `analog-delay`; a `MonoSynth` sounded one way, and changing it meant
knowing that the filter envelope's gain is 3000, with nothing to call the result,
save it, or load it back.

`src/presets.ts` is the format and the validation, and it is pure: `resolvePreset`
turns a preset into `[key, value]` writes plus the reserved options, with no
context, no nodes and no clock, and the instrument turns those into one
`setValueAtTime` per fan-out inlet. Which is the whole mechanism - after 02 every
per-instrument parameter already is an `AudioParam`, so a preset is one write per
key and a *scheduled* preset change is free: `setPreset("Pad 3", { time: bar9 })`
is "load the pad at bar 9".

Keys, not an array. rune06's `PresetParams` is a flat struct in `ParamId` order,
which is what hardware does; in JavaScript the object is the stable-ID mechanism -
a key survives reordering, a missing key means "default", and it is already JSON,
which is what smplr's `SmplrPreset` is too.

A preset is complete rather than a diff: every declared parameter is written on
every load, the ones it does not name with their declared defaults, so loading
"Brass 1" after "Pad 3" does not inherit the pad's cutoff. A sound that depends on
history is what a name is supposed to remove. `getPreset()` returns a complete
object for the same reason, and `setPreset(getPreset())` is a no-op.

An unknown key throws, naming the key and listing the known ones: a definition's
`params` keys are its schema, and renaming one breaks its presets - that is the
versioning story, said out loud rather than hidden behind a migration layer. A
value outside a parameter's range is a different thing and is clamped silently: a
saved 1.2 on a 0-1 parameter is a stale file, not a mistake.

`glide`, `legato` and `priority` are reserved keys a preset may carry - a lead
sound *is* its glide - and they set 03's instrument options rather than a
parameter. A definition that declares one of those names is rejected at
construction, before anything is built.

Also: `VoiceDefinition.presets` typed against the definition's own parameter
names, so a typo in a factory bank is a build error rather than a runtime throw;
`options.preset` applied at `ready` after the pool is built and before the queue
is flushed, and a `setPreset` before `ready` queued in call order with the notes;
and `fromDescriptor(X, "attack", { default: 0.01 })`, which fills a `ParamSpec`
from a module's own descriptors so a definition retypes no ranges - it takes
anything with `descriptors`, so the no-dependency rule holds.

Claude-Session: https://claude.ai/code/session_01YYYpLQmn1c2KtsPCtk4pXf
A module with no page does not exist for anyone who did not build it. After 01-04
and 07 the instrument has a usage block accreted one paragraph per ticket and
nothing a reader can open: no docs page, no live example, and a `synths.mdx` that
describes `MonoSynth` and the drums and does not know polyphony exists.

`site/content/docs/(instruments)/instrument.mdx` is the page. An instrument is not
a source, a modifier, a modulator, an effect or a sequencer, and it is the vision's
whole first tier, so it gets a group of its own - `(instruments)`, first in the
Modules list, with room for one page per ready-made synth after this one. The page
says the three things that were decisions and will otherwise be re-litigated by the
first issue: what the surface is and where it differs from smplr (a summary, with
the row-by-row table linked to the package README rather than repeated), what the
two kinds of parameter are and why `glide` and `hold` are neither, and what eight
voices cost - 56 worklet nodes, ~180 us per block, 6.8 % of one core, from the
automation-rate benchmark, which is also the sentence that explains the roadmap's
native synth.

`site/examples/components/Keyboard.tsx` and `PresetPicker.tsx` are written for the
next synth's page as much as for this one: the keyboard holds no audio and no synth
- it is the input device, turning pointer events and the tracker `z`/`q` rows into
`onNoteOn`/`onNoteOff` with MIDI numbers - and the picker takes names and a
callback rather than an instrument, so the page decides whether a preset change is
scheduled. Both track their own held/selected state, because a key held by the
computer keyboard and a key held by a pointer have to look the same.

`InstrumentExample.tsx` is `Instrument(ac, monoVoice, { voices: 8 })` with the
keyboard, the picker, and sliders on `cutoff`, `resonance` and `attack` - the same
`Slider` the one-voice examples use, which is the point: an instrument's knobs are
`AudioParam`s. `useSynth` could not drive it, so the example has its own hook: the
voice count rebuilds the instrument (the pool is fixed, so a different size is a
different instrument) and the state is published only after `ready`, because
`params` is empty until the pool exists. Strict mode's double mount disposes the
first instrument before the second is built, as everywhere else.

`synths.mdx` gains the paragraph that names what those synths are - a voice - and
points here.

Phase one of the ticket: the arpeggiator controls wait for 05, and the README, the
package metadata, the umbrella exports and the changesets wait for 06.

Claude-Session: https://claude.ai/code/session_01YYYpLQmn1c2KtsPCtk4pXf

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CJySHYHBAgUWZe5XDGQpW4
A module with no definition to run is a module nobody has used. After 02 and 04
`Instrument` had been proved against a stub whose `create` returns a gain with
two params on it, and a stub cannot say whether an inlet passed as a sub-input
survives the compound's own `...inputs.x` spread, whether `fromDescriptor`
covers a real parameter list, or whether a definition's defaults are the sound
the compound already made.

`synths/mono-voice.ts` is the first real definition. Sixteen parameters, every
one from the compound's own surface and every default the value a bare
`MonoSynth(ctx)` already builds - so `Init` is `{}` by construction and
`MonoExample` is unchanged. Ranges come from each module's `descriptors` through
`fromDescriptor`, narrowed where a descriptor's range is not a knob's: `Svf.Q`
runs to 40, which is a sine generator with a filter attached, so the definition
stops at 12; the LFO reaches 200 Hz and vibrato stops at 20. `bend` is pitch
bend and it is `osc.detune` - a declared parameter, not a feature. `waveform` is
a k-rate bank index and carries `unit: "index"`, which is what a UI reads to
draw a selector rather than a slider.

It lives in the umbrella, not in `@synthlet/instrument`: it depends on five
packages and the instrument depends on none. The umbrella gains
`@synthlet/instrument` as a dependency and one export line; the rest of its
exports are 08's.

`MonoSynth` stays a compound and stays patchable - `MonoSynth(ctx, { gate:
euclid, frequency: arp })` is what `ArpExample` builds and it is untouched. What
it gains is a `filterEnv` sub-input, so the envelope's `gain: 3000` and
`offset: 2000` are defaults rather than unreachable constants, and `frequency`
in `exposes`, which is `osc.frequency` seen from outside and the per-note
parameter every voice has to publish. Both are backwards-compatible; the spread
comes last, so a bare build is the same graph it was.

A bank of three - `Init`, `Bass`, `Pad` - named blandly on purpose, because a
bank worth a name is the Juno folder's. `Bass` carries `glide: 0.04` as a
reserved key, which is 04's claim that a lead sound *is* its glide, exercised.

`instrument-offline.test.ts` is the render 07 left for when a real definition
existed: `Instrument(ctx, monoVoice, { voices: 2 })`, two overlapping notes
scheduled before `ready`, released after it, rendered under `node-web-audio-api`
and asserted silent, then rising, then louder when the second voice joins, then
released, then identical sample for sample on a second render.

That determinism assertion found a harness bug rather than a library one:
`getChannelData` hands back a view of the render thread's own buffer and the
next context reuses that memory, so a `Float32Array` held across a second
`startRendering` reads garbage. `offline.test.ts`'s own two-render comparison
has the same latent flake and is copied here too - one `Float32Array.from` each.

Cost, for 08's README: eight voices is 3.4 ms to construct on
`node-web-audio-api` with the worklets already registered, against 0.48 ms for
one bare compound. The sixteen fan-out `ConstantSourceNode`s are not the number
that matters; eight copies of five worklets is.

Claude-Session: https://claude.ai/code/session_01YYYpLQmn1c2KtsPCtk4pXf

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KhpK4zrzVqNZGD6PVo7G9L
`scripts/_worklet.ts` was reformatted after the package was scaffolded and its
copy was never remade, so `worklet-copies.test.ts` and `format:check` both had a
one-line disagreement to report. `scripts/copy_files.sh`'s output, verbatim.

Claude-Session: https://claude.ai/code/session_01YYYpLQmn1c2KtsPCtk4pXf

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CJySHYHBAgUWZe5XDGQpW4
The README had accreted one paragraph per ticket. It is rewritten in the order a
reader needs it, and it now says the three things that were decisions and would
otherwise be re-litigated by the first issue.

**What the surface is, and where it differs from smplr.** The parity table, row
by row, copied from the research rather than summarised, so the two libraries can
be read side by side. Two rows say "differs" and they are the same difference:
smplr wraps its output in a channel object with its own methods and this returns
a node, so `volume` is an `AudioParam` on the output gain rather than a 0-127
setter, and there is no `addEffect` - an effect is `connect()`. Under the table,
the velocity curve `(v / 127)²` from the DLS spec, and the note-name rule.

Two cells are what shipped rather than what the research proposed, and the
difference is the folder README's own: `volume` is a native gain's linear
`AudioParam` with `options.volume` in dB at construction, not a `Param.db` inlet,
because that is a worklet and the output has to exist before `ready` for
`connect()` to work; and the offline row is in the present tense, because 07
landed and the library is typed `BaseAudioContext` throughout.

**What eight voices cost.** Seven worklet nodes per `MonoSynth` voice, so 56,
plus a `ConstantSourceNode` per declared parameter - sixteen, for `monoVoice` -
and a gain per voice. The automation-rate benchmark measured that pool at ~180 us
per render block, 6.8 % of one core at 48 kHz, before any DSP runs. It is the
honest cost of a design where every voice is a patchable graph, and it is the
sentence that explains the roadmap's native synth: same definition, same `params`,
same presets, only `create` changes.

**What a voice definition is.** A paragraph per field, the per-note versus
per-instrument distinction, the third kind that belongs to the module rather than
the voice - `glide`, `hold`, `priority`, `legato` - `fromDescriptor` with the
override that keeps `Svf.Q` off 40, and the keys-are-the-schema rule.

The arpeggiator over the held notes did not land on this branch, so the README
names it as not shipped and points at the deferred list rather than describing a
surface that does not exist. Same in the demo, in one line.

`packages/synthlet/src/index.ts` re-exports the package, with `StealMode` and
`NotePriority` named explicitly for the reason that block already documents:
tsup's dts bundler drops enums from an `export *`, and the built
`dist/index.d.ts` confirms it - the `export *` line survives, the enums would
not have. `registerAllWorklets` is untouched; the instrument registers nothing.

`index.test.ts` checks the re-export by identity, not by name: the umbrella's
`StealMode` must *be* the package's, and every name the package exports must
reach the umbrella as the same object. A name exported by two packages, or a
narrowed re-export that drops one, breaks nothing that `tsc` or any other test
can see - the name is simply gone, or is the wrong thing.

The demo is reconciled against the real `monoVoice`: the glide slider re-reads
after a preset load, because `Bass` carries `glide: 0.04` under a reserved key,
and the attack slider stops at 2 s rather than the parameter's 10, since a
control whose default sits at 0.1 % of its travel is not a control.

Verified: `npm test` (78 suites, 2461 tests), `check:rates`, `tsc` at the root
and in `packages/synthlet`, `prettier --check .`, and the site's own `tsc` and
`next build`, which renders `/docs/instrument`. `site/.source/index.js` is the
generated file list and is regenerated by that build.

Claude-Session: https://claude.ai/code/session_01YYYpLQmn1c2KtsPCtk4pXf

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CJySHYHBAgUWZe5XDGQpW4
`index.ts` re-exported everything each module defined - the mono state machine,
the fan-out builder, the preset resolver and its reserved-key list - and the
umbrella's `export *` carried all of it into `synthlet`. None of it is
documented and none of it is used outside the package's own tests, which import
the modules directly. What remains is what the README describes: `Instrument`
and its types, the two enums, the pure allocator and note stack, `toMidi`,
`toFrequency`, `fromDescriptor` and the preset types.

Claude-Session: https://claude.ai/code/session_01YYYpLQmn1c2KtsPCtk4pXf
Lift the two mode enums and the index math out of createArpeggiator into a
pure scripts/_traversal.ts, copied into @synthlet/arp and
@synthlet/instrument. The arp's public surface does not move - index.ts and
params.ts are untouched - and its suite passes unedited, including the
960-combination sweep and the two published KeyStep Pro sequences.

What is shared is the hang-guard: without advance()'s size === 1 branch,
UpDownExclusive on a one-note set is an unbounded loop on the audio thread,
and an arpeggiator over held notes meets a one-note set whenever a player has
one finger down.
Three pure files: the user-zone/DSP-zone boundary, the pattern as one frozen
value, and the state machine over (held, physicallyDown, deferred, traversal)
that answers what should sound and when. No nodes, no context, no clock - so a
whole arpeggio is assertable as data, which is the seam mono.ts already has.

Three departures from the ticket's proposed surface, each argued in the plan:
the pattern is one assignable value rather than a property bag; the mode is a
string union rather than a grown copy of @synthlet/arp's enum, which could not
carry Chord past its own AudioParam's maxValue; and latch leaves the config to
sit beside hold, since the ticket's own reasoning makes them one mechanism.
The value and the machine reach index.ts: the assignable property with D6's
two null transitions, the latch as hold's symmetric twin, the two methods, the
start/stop branches, and 'arp' joining RESERVED so a preset carries the pattern
as one JSON value. Every existing test in index.test.ts, mono.test.ts and
presets.test.ts passes with only its priority/steal spelling changed - arp mode
is additive, not a fork in the allocator.

Two things the plan did not foresee, both found by a test:

- A note queued before ready sounded through the plain poly path even with an
  arp configured. It now joins the chord the arp will read, which is the rule
  a press after ready already got.
- resize(0, n) left the traversal's index at -1, and a held set empties every
  time a player lets go. arpStep returns before reading an empty set, and
  _traversal.ts clamps the other end too so the primitive is total.

priority and steal move to the user-zone spelling in the same commit, since
they touch the same lines. _voices.ts and both its copies are untouched: it is
written to be copied into a worklet, so its enums stay numeric.
The umbrella needed no change, which is D8's payoff and now has a test that
says so: with the instrument's mode a string union there is exactly one ArpMode
in the library, so export * from both packages has no TS2308 to resolve. An
ambiguous name would be excluded from the namespace rather than picked - it
would be undefined rather than wrong - which is why the guard is worth more
than the member-identity comparison criterion 13 asked for.

README and docs pages get the arp section, the field table and the paragraph
on the two arpeggiators that arpeggiator.md says the docs owe. arp.mdx's
forward reference to 'the polyphonic voice module' becomes a link.

docs.test.ts grows a third entry, and it earned it immediately: it found that
instrument.mdx still said 'No arpeggiator over the held notes yet' and that the
page never named the priority strings. The field values here are string
unions, so a stale name in a published table is not a type error anywhere - it
is a documented mode that throws the moment a reader tries it.

ARP_MODE_NAMES and the other name lists are exported: the test needs a runtime
source of truth, and a UI building a mode picker needs the same list.
# Conflicts:
#	packages/ad/src/_worklet.ts
#	packages/adsr/src/_worklet.ts
#	packages/analog-delay/src/_worklet.ts
#	packages/arp/src/_worklet.ts
#	packages/chorus/src/_worklet.ts
#	packages/clip-amp/src/_worklet.ts
#	packages/clock/src/_worklet.ts
#	packages/dattorro-reverb/src/_worklet.ts
#	packages/digital-delay/src/_worklet.ts
#	packages/euclid/src/_worklet.ts
#	packages/granite/src/_worklet.ts
#	packages/impulse/src/_worklet.ts
#	packages/karplus-strong/src/_worklet.ts
#	packages/level-meter/src/_worklet.ts
#	packages/lfo/src/_worklet.ts
#	packages/lookahead-limiter/src/_worklet.ts
#	packages/lookahead-limiter/src/index.ts
#	packages/noise/src/_worklet.ts
#	packages/param/src/_worklet.ts
#	packages/polyblep-oscillator/src/_worklet.ts
#	packages/reverb-delay/src/_worklet.ts
#	packages/state-variable-filter/src/_worklet.ts
#	packages/synthlet/src/_worklet.ts
#	packages/synthlet/src/worklet-copies.test.ts
#	packages/timestretch-audio-source/src/_worklet.ts
#	packages/virtual-analog-filter/src/_worklet.ts
#	packages/wavetable-oscillator/src/_worklet.ts
#	scripts/_worklet.ts
#	scripts/copy_files.sh
#	site/.source/index.js
site/.source/ was committed, and every entry in index.js carries the absolute
path of whoever generated it - main's copy read .worktrees/level-meter/... So
two worktrees produce two different files and every merge between them
conflicts on all of them at once, which is what it just did. The entry order
and the path count move with the fumadocs version too, so the committed copy
is wrong for anyone who did not generate it.

Nothing needs it committed: site/ is not an npm workspace, so CI never
installs or builds it, and a clean checkout regenerates the whole directory -
postinstall's fumadocs-mdx writes the types, next build writes index.js.
Verified by deleting site/.source entirely and running next build: it came
back and all 32 doc routes rendered, the new instrument and
metering-and-loudness pages included.

Unlike packages/*/src/processor.ts, which CI checks for staleness on purpose:
those are imported by published code and have to ship in the tarball.
@danigb
danigb merged commit 5f1d4e6 into main Sep 12, 2026
6 checks passed
@danigb
danigb deleted the instrument branch September 12, 2026 15:57
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant