Repository navigation
Instrument module for mono and polyphonic instruments - #59
Merged
Merged
Conversation
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.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Made with Claude