Skip to content

Security: JS-PACKAGE/OPM.js

SECURITY.md

SECURITY.md — OPM.js Security Policy & Review Mechanism

OPM.js is a client-side, four-operator FM synthesis library. It processes voice definitions, DX7 SysEx and PCM buffers, and runs real-time DSP in an AudioWorklet. It has no application server or authentication system and has zero runtime dependencies. The host application remains responsible for website security, untrusted downloads, resource budgets and safe audio presentation.

For installation, browser deployment, and API examples, start with the README or the English / Traditional Chinese usage guide.

Contents: Supported versions · Reporting a vulnerability · Safe embedding · Threat model · Security review mechanism · Non-goals

Supported versions

Version Supported
1.x Supported security line; use the latest available patch
< 1.0 Not supported

The current checkout requires Node.js 22 or newer for Node usage and development. Browser applications require ES modules, AudioWorklet and a secure context (HTTPS or localhost). The Node requirement does not provide a browser sandbox or replace browser updates.

Use a complete distribution from a known checkout or package, not individual modules from unrelated builds. Check CHANGELOG for observed verification; an advertised feature or configured CI job is not proof that every runtime or platform has passed.

Reporting a vulnerability

Report exploitable problems privately to the repository maintainer. Use the GitHub private vulnerability reporting form when it is enabled. If a private reporting route is unavailable, request a private contact method without publishing exploit details, sensitive files or a proof of concept.

Include enough information to reproduce the issue safely:

  • The affected OPM.js version or commit, and whether the behavior uses src/, committed dist/, or an installed package.
  • Node/browser version, operating system, sample rate and relevant deployment or routing configuration.
  • A minimal input and sequence of API calls or worklet messages, including expected and observed behavior.
  • The apparent impact: code execution, validation bypass, excessive CPU/memory use, processor failure, unexpected audio, or data exposure.
  • Relevant errors, diagnostics and whether the issue reproduces with a freshly built, matching distribution.
  • Any proposed fix or mitigation, and whether the report may be credited publicly.

Do not include credentials, private voice banks, personal recordings or unrelated user data. Use a synthetic input when possible. Minimize denial-of-service examples; do not test against other people's websites or production audio sessions.

The acknowledgement target is 72 hours, on a best-effort basis, not a guaranteed response or remediation deadline. Coordinate public disclosure with the maintainer so affected users can receive an actionable fix or mitigation. Ordinary usage questions may use public issues; exploitable details should remain private.

Safe embedding

Website deployment and browser permissions

  • Serve the complete, matching dist/ tree over HTTPS or localhost, preserving worklet and imported-module paths. A configurable worklet URL must stay same-origin, use HTTPS/loopback HTTP, contain no credentials/fragment, and retain CSP/MIME enforcement. Do not load through file://, and retain LICENSE.
  • The root index.html, examples/ pages, favicon.ico and this policy are public website assets. Publish the build-generated doc/ HTML, stylesheet and search assets together with the matching documentation sources.
  • The Python development server is for local checks, not a hardened public host. A production server should not expose .git/, .dev/, node_modules/, development tooling, credentials or directory listings.
  • Serve JavaScript with a JavaScript MIME type. Use X-Content-Type-Options: nosniff; do not return an application's HTML fallback for a missing worklet/module URL.
  • Apply a host-specific Content Security Policy that allows only reviewed module origins, restricts framing and base URLs, and disables unnecessary object embedding. Check the script and worklet/worker directives applicable to each supported browser.
  • The checkout examples use external module scripts and a local stylesheet. They need no unsafe-eval. Do not weaken CSP, TLS or browser permission/autoplay controls to suppress a deployment error.
  • WAV Blob URLs are data downloads, not executable modules. Do not broaden script origins simply because downloads use blob: URLs.
  • Only enable browser features that the host needs. Synthesis does not require microphone, camera or location access. Test playback, worklet loading and download behavior after changing hosting headers.

Voice banks and JavaScript objects

Use loadVoice(), normalizeVoice(), validateVoice() or parseVoiceBank() at the appropriate documented boundary; do not send unchecked definitions straight into the DSP or raw worklet protocol.

Input Boundary
Single-voice API Required fields and exactly four complete operators; finite numeric values and documented ranges; unknown fields and accessors reject
Voice-bank JSON string At most 262,144 UTF-8 bytes (256 KiB), then JSON parsing and bank validation
Voice-bank array 1–128 complete versioned voices, unique validated names, and frozen normalized copies
Legacy versions 1–7 Original shapes only: v1 excludes key scaling, v1/2 exclude velocity sensitivity, v1–3 exclude waveform, v1–4 exclude expressive fields, v1–5 exclude per-operator LFO targets, v1–6 exclude operator waveform/noiseRate, v1–7 exclude adsr.sr, voice pan and the noise LFO; all normalize to v8. noiseRate is 20–20000 Hz, adsr.sr 0.01–100 s, pan −1..1
.opm text patches importOPM/describeOPM: at most 262,144 bytes, 128 patches and 512 bytes per line; NUL bytes, unknown/duplicate/missing sections, non-decimal or out-of-range fields reject with a line number; results pass the normal v8 validation path
MIDI program/drum maps programVoices/drumVoices: plain data objects or native Maps, at most 128 entries, canonical integer keys 0–127 and valid voice names; accessors and extra Map properties reject. RPN 0 state is per channel and bounded to 0–48 semitones
PreparedVoice Immutable detached core snapshot, including nested pitch envelopes; only private identity membership grants trust, never a structural brand/copy
Tuning / score / controls A4 20–20000 Hz, 128 bounded cents offsets; strict dense four-element level/ratio/Hz/ADSR and LFO-target tuples; short scores retain 128-note/256-slot/60-second bounds; long scores have separate event/time/chunk limits and immutable own-data snapshots
Atomic OPM bank replacement Validate all entries before swapping ≤128 lookups; plain empty array clears, while JSON/standalone empty bank parsing rejects; exports use detached canonical names and ≤256 KiB UTF-8
Transport / performance ≤1024 tempo points, quarter-note positions ≤86400; bounded scheduling density and scoped ID ownership; 1–16 parts, ≤128 physical keys/tracked gates with detached snapshots

Single-voice APIs reject out-of-range fields. Bank validation clamps finite numeric fields to documented bounds, but still rejects malformed types, non-finite numbers and invalid version/algorithm/feedback values. Clamping is not a substitute for validation.

Keep allowlisted, own-data copying at trust boundaries. Do not merge untrusted objects into prototypes, invoke getters to inspect them, or treat a valid voice name as authorization to construct a URL or filesystem path. Engine bank parsing does not load paths or fetch voice URLs.

Independent note gain and expression are both bounded to 0..1 and multiply before stereo mix saturation. Layer fades do not bypass control validation, note ownership, worklet queue limits or rejection reporting.

Score projects and Standard MIDI files

Versioned score-project parsing accepts only the documented own-data schema, detached validated voices, bounded beat events and synthesis settings. Loading a project does not fetch assets, execute code or start playback. Compilation converts note gate endpoints through the complete tempo map; offline resource budgets still apply after conversion.

The separate version-1 Arrangement project uses the same own-data beat/voice/settings boundaries and one pure definition validator shared with live arrangements. Bounds include 8 MiB serialized input/output, 128 voices/256 KiB voice JSON, 16 layers, 32 sections and 65,536 total events. Parsing is inert; persisted musical definitions do not include live IDs, permissions, pending commands or DSP state. Host replay must explicitly load validated voices and start from a gesture.

The independent Standard MIDI file adapter validates native bytes, bounded chunks, PPQN timing and event framing. It does not provide a native MIDI driver, transmit SysEx or interpret uploaded bytes as executable content. Hosts must check file size before buffering, choose explicit channel-to-voice mappings, expose import warnings and reject unsupported export semantics instead of silently changing a score.

Opt-in expressive SMF conversion separately bounds generated per-note fanout to 65,536 events. Frozen loss summaries separate omitted content, approximations and recognized source-message counts. Channel expression after a closed gate reports possible patch-dependent release-tail loss; strict unsupported policy rejects it. Export rejects incompatible channel ownership, unsupported controls and after-gate semantics rather than guessing. Explicit pitch-range policy is not RPN support.

External downloads and file uploads

The engine does not provide a voice-download API. Host loaders must validate the source and enforce an input budget before buffering or parsing. Engine checks cannot recover memory already consumed by an oversized download.

  • Check HTTP status and permitted origins before accepting a response; do not derive destinations from an untrusted voice name.
  • Treat declared MIME type, file extension and Content-Length as hints, not evidence that the payload is valid or bounded. Chunked and decoded/compressed responses still need a real byte budget.
  • Bound streamed response bytes and cancel an oversized transfer before assembling the complete buffer. Set host-appropriate cancellation and time limits.
  • Check a local file's size before arrayBuffer() or text decoding, then validate its actual contents. A picker selection is not a trust guarantee.
  • Do not insert filenames, imported descriptions or error messages into HTML. The examples display them as text; retain that separation in host UIs.
  • Apply application-level limits to repeated uploads, repeated parsing and simultaneous synth instances. A per-call limit is not a whole-page resource quota.

DX7 SysEx conversion

importDX7() and describeDX7() accept one Uint8Array containing a standard 163-byte single-voice or 4104-byte 32-voice bank message. Length, framing, checksum and seven-bit payload checks reject malformed input. The playground checks the maximum file size before buffering.

This is approximate six-to-four-operator voice conversion, not a DX7 emulator or an arbitrary SysEx interpreter. Conversion does not execute the payload. Review the returned descriptions and warnings before auditioning a patch; keep descriptions outside the strict voice schema.

PCM, offline rendering and WAV export

encodeWav() encodes PCM; it does not decode/play uploaded audio. Own-data arguments are left, optional right, sampleRate and optional format (pcm16, pcm24, float32). Native Float32 samples must be finite in −1–1; stereo lengths match, with at most 4,000,000 frames per channel for this full-buffer convenience API.

Project render results onto those fields rather than forwarding diagnostics or other metadata. Reject encoding/rendering errors visibly instead of substituting a fake result.

Core rendering authenticates native Float32Array kind/length instead of overridable properties. Validate offset before deriving the default length; numeric coercion, proxies, forged channels and out-of-bounds ranges reject without advancing sound. Idle clearing uses the native fill method. Hosts still own the actual PCM storage and must not mutate it concurrently.

Offline rendering allocates output buffers and executes synchronously. The host should limit duration, sample rate, envelope tails, concurrent requests and export frequency to suit its device and UI. Valid input may still consume significant time and memory; no universal deadline or whole-page memory guarantee is made.

Long-score rendering and incremental createWavEncoder() use bounded reusable PCM/encoded chunks, not unlimited aggregate buffers. Consume borrowed PCM before advancing; declare an exact encoder frame count and finalize only after all frames. Encoder chunks are 1–65536 frames and RIFF32 files remain <4 GiB; convenience rendering/encodeWav retain their 4,000,000-frame bound. Hosts must bound cumulative duration/work, retained bytes, concurrent renders and export frequency.

renderSequenceInWorker() validates before Worker allocation, transfers at most one unacknowledged encoded chunk and awaits sink writes before advancing. Capture intrinsic byte counts before handing ownership to a sink; storage workers may transfer/detach the buffers. Progress/abort callbacks are untrusted host behavior. Native AbortSignal cancellation terminates/rejects immediately without waiting for hung writes/abort/close. The sink owns invalidation and rollback; cancellation cannot retract persisted bytes. Acquire file sinks from trusted gestures, retain lifetime cancellation across picker/writable awaits, and clean up acquisition failures before starting a Worker. Never replace a long-file sink with unbounded Blob accumulation.

Create download URLs only for successfully encoded bytes. Replace/revoke obsolete Blob URLs and release them when the owning page or component is disposed. Treat filenames and rendered audio as potentially private application data.

AudioWorklet, scheduling and context ownership

  • Await start() in a user interaction and monitor onEvent or independent subscribe() listeners. A note ID is not admission; handle rejections, terminal states and processor errors. waitForCommand() is bounded, timed/cancellable and resolves admission only, not future execution; reset/close/failure invalidate pending waits.
  • The worklet bounds pending events and tracked note IDs to 256 each. Schedule bounded batches rather than flooding the port with distant-future events.
  • The optional effects worklet (worklet/fx-processor.js) has a separate strict own-data update/reset/close protocol. Chorus/reverb numbers and voice counts validate again before entering DSP; no command queue is retained and at most 32 commands are admitted per audio-frame boundary. Error replies are bounded and close remains available under flooding. MessagePort buffering before dispatch and many host-created instances remain host resource concerns.
  • Effects module loading uses the same secure same-origin URL rules and native CSP/MIME enforcement as synthesis; deploy the full matching tree. Effects never resume, suspend or close a borrowed context. Processor/decode failures surface through onEvent; dispose disconnects/stops only the insert.
  • Effects preallocate bounded seconds-scaled Float64 delay state (under 866 KiB at 192 kHz), sanitize NaN/Infinity PCM to zero, clamp internal state and flush tiny values. Offline tail-extended copies obey the existing 4,000,000-frame budget. Wet headroom is not a limiter for over-unity input or a host mix of many buses.
  • Each synth limits logical voices to configured 1–32 (default eight), with up to eight bounded stealing fades. Immutable eco/standard/high profiles change fixed internal sampling/filter work, not these bounds. These limits do not constrain an attacker creating many instances.
  • DSP state and terminal notification buffers are preallocated. Ended/error callbacks run after stable frame traversal; callback-admitted replacements start next frame, and recursive rendering rejects rather than extending a frame's work.
  • Named/prepared worklet registrations use 128 content-keyed LRU slots. Replacement revalidates before committing; queued/active notes own immutable old snapshots. Raw objects still validate freshly.
  • Absolute start/stop/control times are safely framed with a 60-second future horizon; stop precedes onset and controls. Command rejection is correlated by commandId; accepted means admission, not guaranteed future execution. Global allNotesOff/panic bypass full scheduled queues. Bound sequences and lookahead rather than flooding messages.
  • Immediate stop(id, { cancelControls: true }) removes only that ID's queued automation/onset/off before natural release; it cannot be combined with at. Musical Transport retains release-tail controls during ordinary playback but cancels its own future automation on pause/seek/loop rebuilding. Seeking is a musical restart, not an exact DSP snapshot.
  • Performance cleanup is part/helper scoped, not global panic. Repeated equal-pitch keys retain separate identities; stealing/reset cannot resurrect stale held/pedal state.
  • Handle rejected diagnostics promises and failed node initialization. Do not hide failure behind mock audio nodes or a fallback engine.
  • A shared AudioContext is borrowed: OPM disconnects its node but never closes/suspends the host context. close() is restartable; terminal dispose() clears owned helpers/subscriptions without taking ownership of a borrowed context. Hosts own downstream routing and permissions.
  • Clear host gate bookkeeping on global reset; close/failure need not reply with every terminal note. Default cancel removes old gates/automation on suspension/interruption; preserve is opt-in. Both policies stop lookahead and require gesture-driven explicit restart.
  • The recovery harness bounds local events/attempts and captures explicit device metadata, observations and manual scenario status. It uploads nothing. Automated desktop checks cannot certify physical phones or listening continuity; support-matrix cells without physical evidence remain unverified.
  • Provide obvious play/stop controls and begin at a comfortable, low host gain, especially with headphones. Finite samples and synthesis headroom do not guarantee safe listening volume.

Source maps, privacy and redistribution

Every distribution JS has a matching source map with embedded TypeScript and a compiler-generated declaration. Publishing maps intentionally makes the implementation source readable; minification is not secrecy. Never place credentials or private configuration in source that will be built or deployed.

OPM.js does not provide an account, storage or telemetry service. Hosting providers and applications can still record request metadata or persist voices/audio. Document those host-specific behaviors separately and do not claim this library prevents data collection by the surrounding page.

Keep each deployment's JS, maps and declarations from the same build. Review exact development dependency versions, build plugins, CI actions, package contents and license compatibility before changing the supply chain.

Threat model

Surface Risk Required controls
External voice JSON or JavaScript objects High Type/shape/byte/count limits; finite bounds; own-data validation; no untrusted prototype merging
Host download/upload and DOM code High Pre-buffer limits, permitted sources, text-only presentation and host-page XSS defenses
Raw AudioWorklet messages High Strict message validation, bounded IDs/events and observable failure handling
DX7 binary input and WAV PCM arguments Medium Bounded lengths, framing/checksum or sample validation; no native decoder
Score-project JSON and Standard MIDI files High Byte/event/schema/framing limits, own-data options, detached validated voices and explicit unsupported-semantics handling
DSP and offline rendering Medium Finite output, bounded per-instance work, duration/sample-rate budgets and error diagnostics
Public scheduling API Medium Argument validation, admission handling, cancellation and bounded scheduling batches
Build and deployment supply chain Medium Exact development pins, reviewed CI actions, complete matching assets and zero runtime dependencies
Output audio and downloadable artifacts Medium User-controlled playback, conservative gain and host-managed privacy

An AudioWorklet separates real-time processing from the main thread, but is not a security boundary against a compromised host page. Malicious host JavaScript can create nodes, spam messages, fetch data or manipulate the UI independently of OPM.js. Input validation and per-instance limits reduce accidental or adversarial input damage; they do not sandbox XSS or guarantee availability under arbitrary page load.

Ordinary properties or accessors installed on Object.prototype or Array.prototype must not forge trusted snapshots, substitute data after validation, defeat ownership checks, redirect filesystem paths, or make a capacity check disagree with its copy loop. Validated copies therefore define their own data: array elements, optional object fields (object-literal spreads, which define rather than assign), descriptor literals (null prototype, because Object.defineProperty also reads inherited descriptor fields) and the state of the Synth, OPM and worklet-processor classes (real class fields, not declared ones assigned in the constructor). Reads of an omitted optional field are own-property reads (Object.hasOwn, a static method that no Object.prototype hook can intercept) at note admission, live note controls, engine options (null-prototype result), effects sections, MIDI export controls, Performance baselines, loaded-voice freezing, the sequence release-tail bound, the reserved layer gain check and Transport seek reconstruction, so an inherited value cannot reach those consumers without passing validation. Bookkeeping objects whose optional fields are assigned or read later (Transport and Arrangement gates, Arrangement commands, MIDI-import held notes, MIDI-adapter controller mappings) start with own undefined slots, so an inherited setter cannot swallow the write and an inherited getter cannot answer the read. Not covered, and listed in the review record below: a latent GainChange.activation read in Arrangement (no reachable path found), tempo-point curve/endBpm reads that stableTempoContext already guards, internal bookkeeping arrays (which use push), and several ownership candidates (Performance part updates, MIDI-adapter ownership, arrangement reserved gain, asset-inventory paths) that remain unresolved. None is waived merely because the hook runs in the same realm, and downstream numeric validation does not establish part ownership, reserved-control policy or path containment. Replacing native intrinsics remains outside this review's assumptions; OPM.js does not sandbox compromised host code.

This policy addresses the library and checkout examples. Authentication, authorization, cookies, cross-origin access, backend storage, upload endpoints and rate limiting belong to the application deploying them.

Security review mechanism

1. Review triggers (mandatory)

A security review is required before:

  • Any release tag (vX.Y for zero patch versions, vX.Y.Z otherwise)
  • Merging a PR that touches: src/worklet/, src/core/, or voice parsing (src/voices/, src/api/ loaders)
  • Adding any dependency, build plugin, or CI action
  • Supporting a new voice-bank source (file import, URL, user paste)

2. Review checklist

A. Untrusted data (voice banks, config)

  • Voice JSON/key scaling, score projects, SMF/DX7 binary input, and WAV arguments validate type, shape, length, numeric bounds, and own-data properties before use
  • Explicit allowlisted copying; no spreading/merging untrusted objects into prototypes; no accessor invocation
  • Numeric bounds cover ADSR/live reanchoring, ratio/fixed-Hz controls, rate scaling, pitch envelope, LFO waveform/delay/sync/phase/targets and independent depth/rate, feedback, velocity/pan, levels and ramps; tuning/score/Transport/performance/encoder limits remain bounded and legacy shapes exclude later fields
  • Prepared identity cannot be forged, trusted patches stay deeply immutable, and public map snapshots cannot change stored patches
  • Application file/URL loaders bound sources, content type, and payload before buffering; engine does not fetch URLs
  • DX7 rejects invalid length/framing/checksum/seven-bit payload; conversion descriptions remain outside strict voice schema

B. Worklet boundary

  • Every raw message is checked for strict own-data shape before reads, enqueueing, or rendering
  • No eval/Function execution or nonliteral dynamic imports in source/generated JS; configurable worklet/Worker URLs require secure same-origin assets and cannot weaken CSP/MIME validation
  • Duplicate IDs reject before enqueueing; tracked IDs/events remain bounded; ended/stolen/error notes remove obsolete off events
  • Held-note cancellation/release, bounded allNotesOff/panic, command admission/rejection, context/reset and processor failure propagate safely; teardown does not promise impossible per-note acknowledgements
  • Registration replacement, controls, tuning, score IDs/times and absolute scheduling validate own-data shape; queued snapshots, ordering and cleanup preserve bounds
  • Encoded Worker chunks require ordered acknowledgements, intrinsic byte accounting before sink ownership transfer, exact frame/file completion and termination on cancellation/failure; host sinks own rollback

C. DSP loop safety

  • Output is finite: any NaN/Infinity in the render loop snaps to silence and increments an error counter (Synth.errorCount or renderNote()'s diagnostics.errors)
  • Fixed work ceiling: configured 1–32 logical voices (default eight) and at most eight fades, deterministic priority-aware admission/stealing, authenticated native output lengths and numeric ranges before work
  • Slot reset/recycling preserves identity and numerical state under callback admissions; terminal callbacks cannot replenish a frame's traversal or recursively render it
  • Determinism and chunk-independent output preserved; live/offline LFO, timing, filtering, stereo, velocity, and saturation parity
  • Deadline statistics exclude warmup and expose p95/p99/worst/misses without universal performance promises; spectral acceptance is controlled, not arbitrary FM alias-free proof

D. Supply chain

  • Zero runtime dependencies still holds (npm ls --omit=dev is empty)
  • Dev dependencies and CI actions pinned to exact versions/commit SHAs
  • package.json files whitelist ships only intended dist/ assets, usage docs, and legal/project files
  • Standalone deployment retains the installed LICENSE alongside complete matching worklet/module assets; CSP/MIME/404 failures stay visible
  • Any npm publication requires separate maintainer authorization, protected approval, matching tag/version/commit/release and independent A/B/C/D/package evidence, plus a reviewed provenance-bearing publishing path; post-publication checks compare exact tarball bytes, validate source provenance and cryptographically verify signatures before registry-installed consumer acceptance. This checkout has no npm publishing workflow; local verification is not publication.

3. Verification gates

Run development commands from a source checkout after npm ci; installed npm packages do not contain the development tooling.

  • npm run build then npm test — source/distribution behavior, malformed-input, deterministic rendering, and spectral regression coverage
  • npm run typecheck — strict source, development tools/tests/demos, and NodeNext consumer against generated public declarations
  • npm run security -- --package-smoke — TypeScript compiler AST gate over source and Acorn gate over generated JS, exact development pins, zero runtime dependencies, isolated installed exports/type smoke
  • npm audit and npm audit --omit=dev — record actual tooling/runtime audit results; runtime dependency tree must be empty
  • npx --no-install playwright install --with-deps chromium then npm run browser-smoke -- chromium — real AudioWorklet smoke; Firefox/WebKit alternatives are configured separately
  • Headless Linux Firefox requires a running native audio server. CI starts PulseAudio and a null sink before real worklet smoke; it does not mock audio or relax browser permission/autoplay controls. Consult the usage guides for setup and stage diagnostics.
  • npm run benchmark — host-dependent 128-frame render deadlines, with optional explicit budget environment variables
  • npm run sound-quality / npm run voice-quality — numerical/register/velocity matrices and controlled spectral reports, not perceptual/hardware-fidelity proof
  • npm run browser-stress -- chromium — real bounded worklet contention/lifecycle/queue checks; timer/round-trip data are not CPU, GC or glitch counters
  • npm run vite-smoke — installed artifact, non-root production base, license, actual audio, CSP and negative MIME/404 scenarios; audit standalone tooling from examples/vite too
  • Follow publishing prerequisites before any authorized npm upload; source review cannot establish external environment protections, registry authentication or provenance

4. Review record

Each release notes in the CHANGELOG which checklist sections were exercised (A/B/C/D) and by whom. Checklist failures block release; waivers require a written reason in the CHANGELOG.

MIDI CPU measurement caveat: Earlier short-protocol MIDI timing percentages are not stable causal improvement evidence; byte-identical controls also vary substantially, including with a longer proportional warm-up. See the complete no-change controls. Original observations and failed gates remain recorded. This does not retract byte/metadata, determinism, type or genuine playback evidence, and does not grant independent security, release or publication approval.

Scoped B/C review for direct note notification records: integration-owner review, not an independent audit.

  • B — Only outbound note record construction changes. Both literals define own data, with reason absent unless supplied. Raw message allowlists, ID tracking, event ordering, clocks, error reporting and command/reset records retain their original paths. The worklet regression checks full records for acceptance, duplicate rejection and onset at the same dispatch frame.
  • C — No synthesis, frame splitting, queue capacity or callback-order changes.

Scoped A/C review for stereo effects sample sanitization: integration-owner review, not an independent audit.

  • A — Native buffer/range and effect-option admission is unchanged. The sanitizer's magnitude checks retain the original finite bounds; NaN and both infinities reach the zero fallback rather than the finite clipping branch.
  • C — All tiny magnitudes, including signed zeros, still sanitize to positive zero; the threshold and clipping endpoints are unchanged. No delay state, parameter smoothing, frame arithmetic, buffer ownership or worklet protocol changed. Differential PCM comparisons include shared views of the same backing buffer and update/reset transitions.

Scoped A/C review for Owned controlled-score release bounds: integration-owner review of src/core/sequence.ts and generated assets; not independent security review.

  • A — Both existing private score registries receive only fully validated, detached, deeply immutable canonical voices and finite notes. Exact wrapper identity selects the bounded indexed initial-voice reduction; event-array identity, shape, freezing, a Proxy or a caller wrapper alone cannot grant trust. One original identity read feeds both lookups while subsequent generic loop getter reads stay at their original sites. Only control-free snapshots may omit the onset map and a proved-unnecessary non-note pass; all control processing and conservative live-ADSR tails remain unchanged. The inherited-scaling guard stays fresh per note after coercions.
  • C — No new cache, persistent caller retention, public field/API, shared numeric helper, Synth state/layout, frame/window arithmetic, protocol, permission, I/O or dependency change. All original complete public/release/multi-note/window and 13,140 prototype/coercion programs remain equal, with zero inherited getter/setter invocations. Another 194 getter/iterator/coercion programs compare 192 rotating getter cases and two real private-root Proxies, complete queue descriptors/aliases/numeric bits and caller ownership: 50 values, 144 exact caller exceptions and zero forbidden metadata reads. All prior real PCM/backings and lifecycle results agree.
  • Evidence — Actual build, all 626 existing tests (zero failed/skipped), strict source/development/public/core-only types and all 55 byte-identical fresh compiler declarations pass. The freshly compiled official security gate verifies 42 source/55 distribution modules with TypeScript/Acorn, empty runtime dependency checks, exact development pins and matching version. Actual runtime bytes equal qualified Source/production-Min outputs; production maps embed the exact TypeScript, development maps retain external sources and unrelated runtime/maps remain unchanged. Public fingerprint: 75afe60a0eba62055350d3b74cd336e5b1a472c83f297865693bfcdff1de85f7; additional rotating identity fingerprint: b5654526b9ca3a6503062e318f5a04e505d6c8c39e9397b316dc5bc29e2b7412.
  • Browser — Owned Chromium 156.0.8078.4 compares 128 public core programs/1,408 chunks and ten genuine native module-Worker jobs, including acknowledgements/backpressure and abort during a write. Existing-page exports are finite nonzero float32 stereo WAVs with zero page/request/HTTP/DSP errors and no AudioContext. Their separate main-thread/Worker engine settings are not claimed to match; physical-device/listening acceptance remains unverified.
  • Measurement scope — All thirty new no-change rows and thirty candidate rows pass their fixed process-total CPU/current-thread CPU/wall-time gates, retaining 120 fresh processes/1,920 intervals/960 complete final public witnesses per comparison. All control pairs stay inside 5%. The four controlled 64/128 target rows were primary before calibration; all twenty-six previously published rows, including note-only 64/128, remain unchanged-path regression controls. See every signed controlled/unchanged-path delta. No private Synth-state, physical allocation/GC/heap, general DSP-rendering, native-browser CPU, independent audit, package/release or publication approval is implied; host-replaced JS intrinsics remain outside any sandbox promise.

Scoped A/C review for Prototype-aware sequence release scales: integration-owner review of src/core/sequence.ts and generated assets; not independent security review.

  • A — Only the existing exact private control-free snapshot identity selects the shortcut. Existing own-data normalization constructs ordinary Object.prototype operators and freezes their complete owned data before registration. The per-note guard follows current frame/time coercions, so a direct caller can insert/remove inherited keys between coercions or notes. Absence of an inherited key makes a missing direct field read safely undefined; any present key retains original own probes, including inherited data undefined and getters/setters. Shape/freezing alone grants no trust, validation is not skipped, and controlled/unregistered roots retain the original generic iterator reduction.
  • C — No cache, persistent caller retention, public field/API, shared numeric helper, Synth state/layout or frame/window arithmetic changes. Actual Source/minified runtimes preserve all prior complete public/release/multi-note/window consumers, plus 13,140 complete prototype/coercion programs, every observed original rate/origin coercion site, exact caller exceptions, full frame descriptors/aliases/numeric bits and input ownership, with zero inherited getter/setter invocations. All prior real PCM views/backings, diagnostics and borrowed-buffer lifecycle results remain equal.
  • Evidence — Actual build, all 626 existing behavioral tests (zero failed/skipped), strict source/development/public/core-only types and all 55 byte-identical fresh declarations pass. Actual emitted bytes equal qualified private Source/production-Min outputs; the committed map embeds the exact TypeScript and unrelated runtime/maps are unchanged. Public fingerprint: 75afe60a0eba62055350d3b74cd336e5b1a472c83f297865693bfcdff1de85f7; additional complete prototype/coercion fingerprint: ff219594eadb26deba9a871a23aada883bb6af6506a9c173b1f89a7f3fc3668e.
  • Browser — Owned Chromium 156.0.8078.4 compares 128 public core programs/1,408 chunks and ten genuine native module-Worker jobs against the frozen pre-change distribution, including sink acknowledgements/backpressure and abort during a write. Actual existing-page exports produce finite nonzero float32 stereo WAVs with zero page/request/HTTP/DSP errors and no AudioContext. Their separate main-thread/Worker engine settings are not claimed to match.
  • Measurement scope — All twenty-six fresh no-change rows and twenty-six candidate rows pass their unchanged process-total CPU/current-thread CPU/wall-time gates, retaining 104 fresh processes/1,664 intervals/832 complete final public witnesses per comparison, all balanced blocks and the Source prepared-one thread/wall control outlier. The new inherited-key rows use a genuine throwing inherited getter outside timing. See every signed ordinary/fallback workload delta. No private Synth-state, physical allocation/GC/heap, general DSP-rendering, native-browser CPU, physical-device/listening, independent audit, release or publication approval is implied. No worklet/Worker protocol, permission, I/O or dependency change is introduced; host-replaced JS intrinsics remain outside any sandbox promise.

Scoped A/C review for Fixed-width sequence release iteration: integration-owner review of src/core/sequence.ts and generated assets; not independent security review.

  • A — Only the existing exact private control-free snapshot identity selects indexed iteration. Normal own-data preparation proves exactly four own dense operator data indices, copies approved values and freezes ADSR/operator/ops/root before registration. Shape/freezing alone cannot grant identity. Controlled, foreign, cloned, wrapped, caller-frozen and unregistered frame-planner roots retain the original generic iterator reduction where applicable. Own rate-scaling probes and their note-dependent calculations remain; no validation or public trust check is skipped.
  • C — The four immutable own indices are visited in their original array order with the same release arithmetic. Queue ordering, conservative tails, score/frame/slot limits, diagnostics, borrowed-buffer lifecycle and DSP state/layout are unchanged. Actual Source/minified runtimes preserve 1,491 complete consumer cases, 9,072 release frame plans, 1,944 capacity snapshots, 120 full-sequence/40 single-note renders and 8 generic getter/iterator programs; additional coverage preserves 1,440 multi-note frame plans, 192 capacities, 42 full renders and 42 complete chunk streams, plus 7,560 direct window cases and 120 independent half-open oracle programs. Full descriptors, aliases, scalars, caller observations and complete stereo views/backings agree. Shared Synth/numeric-helper runtime/maps are unchanged.
  • Evidence — Actual build, all 626 existing behavioral tests (zero failed/skipped), strict source/development/public/core-only types and all 55 byte-identical fresh compiler declarations pass. Actual runtime bytes equal the qualified private Source/production-Min outputs, and the committed map embeds the exact TypeScript. Fingerprints: public 75afe60a0eba62055350d3b74cd336e5b1a472c83f297865693bfcdff1de85f7; release d90b67ee97fefbed226c5734615c6b8e5b5c40c4790652fd572e1b82170ebca5; multi-note b6383054c5b19e1a51c0049359fe8b6de02f302779cd7d8383c4cfc8d6cb41e2; generic window 4ac6c0c77e8291f661e53f203ec7ec2863f4b40d9458ff6884cadd7a4951a76e.
  • Browser — Owned Chromium 156.0.8078.4 compares 128 public core programs/1,408 chunks and ten genuine native module-Worker jobs against the frozen pre-change distribution, including sink acknowledgements/backpressure and abort during a write. Actual existing-page exports produce finite nonzero float32 stereo WAVs with zero page/request/HTTP/DSP errors and no AudioContext. Their separate main-thread/Worker engine settings are not claimed to match.
  • Measurement scope — All twenty-four fresh no-change rows and twenty-four candidate rows pass the unchanged process-total CPU/current-thread CPU/wall-time gates, retaining 96 fresh processes/1,536 intervals/768 complete final public witnesses per comparison and all balanced blocks; no control pair falls outside 5%. See every signed workload delta. No private Synth-state, physical allocation/GC/heap, general DSP-rendering, native-browser CPU, physical-device/listening, independent audit, release or publication approval is implied. No cache, public API, worklet/Worker protocol, permission, I/O or dependency change is introduced; host-replaced JS intrinsics remain outside any sandbox promise.

Scoped A/C review for Owned sequence release bounds: integration-owner review of src/core/sequence.ts and generated assets; not independent security review.

  • A — Only the existing exact private control-free snapshot identity grants the new release shortcut. Normal preparation still validates finite notes and r in 0..10 seconds, copies approved own data and freezes ADSR/operator/ops/root before registration. Missing or zero own rate scaling has a unit multiplier; no input validation or public trust check is skipped. Controlled, foreign, cloned, wrapped, caller-frozen and unregistered roots retain the original generic reduction where applicable; shape/freezing alone cannot grant identity. Own rate-scaling probes remain, with zero inherited getter invocations.
  • C — Queue ordering, conservative tails, score/frame/slot limits, diagnostics, borrowed-buffer lifecycle and DSP state/layout remain unchanged. Both actual Source/minified runtimes preserve 1,491 complete consumer cases and their lifecycle/detachment programs, plus 9,072 complete frame plans, 1,944 additional capacity snapshots, 120 full-sequence/40 single-note renders with sustain/live ADSR, and 8 generic getter/iterator programs. All public keys/descriptors, aliases, signed-zero values, stereo views and entire backings agree. Shared Synth/numeric-helper runtime and maps remain byte-identical to baseline.
  • Evidence — Actual build, all 626 existing behavioral tests (zero failed/skipped), strict source/development/public/core-only types and all 55 byte-identical fresh compiler declarations pass. Emitted runtime bytes equal the qualified private Source/production-Min outputs; the committed map embeds the exact TypeScript. Complete consumer fingerprint: 75afe60a0eba62055350d3b74cd336e5b1a472c83f297865693bfcdff1de85f7; additional release fingerprint: d90b67ee97fefbed226c5734615c6b8e5b5c40c4790652fd572e1b82170ebca5.
  • Browser — Owned Chromium 156.0.8078.4 compares 128 public core programs/1,408 chunks and ten genuine native module-Worker jobs against the frozen pre-change distribution, including sink acknowledgements/backpressure and abort during a write. Actual existing-page exports produce finite nonzero float32 stereo WAVs with zero page/request/HTTP/DSP errors and no AudioContext. Their separate main-thread/Worker engine settings are not claimed to match.
  • Measurement scope — All twenty fresh no-change rows and twenty candidate rows pass their predeclared process-total CPU/current-thread CPU/wall-time gates, retaining 80 fresh processes/1,280 intervals/640 complete final public witnesses per comparison, all balanced blocks and all control outliers. See all workload deltas. No private Synth-state, physical allocation/GC/heap, general DSP-rendering, native-browser CPU, physical-device/listening, independent audit, release or publication approval is implied. No worklet/Worker protocol, permission, I/O or dependency change is introduced.

Scoped A/C review for Sequence option spread sources: integration-owner review of src/core/sequence.ts and generated assets; not independent security review.

  • A — Only six private empty spread-source literals become undefined. The single fresh own-data engine literal, null-prototype caller-option capture, complete readSynthOptions call and tuning validation retain their order. Missing and own-undefined settings remain omitted; every defined value still validates. No getter/coercion, inherited setter, trust bypass, cache, caller-data retention, public API, protocol, permission, I/O or dependency change is introduced.
  • C — Score/frame/queue budgets, prepared-score eligibility, numerical DSP, voice state and borrowed-buffer lifecycle are unchanged. Both actual Source/minified runtimes preserve 1,491 complete consumer cases, all 64 missing/own-undefined masks across six input forms and 64 mixed-defined masks, plus 27 lifecycle/two raw-mutation programs. Complete capacities/descriptors/frozen limits, exact refusals/hooks, full stereo views/backings, offsets/diagnostics and six native detached-buffer programs agree; tested poison accessors remain uninvoked.
  • Evidence — Actual build, all 626 existing behavioral tests (zero failed/skipped), strict source/development/public/core-only types and all 55 byte-identical freshly generated public declarations pass. Real emitted runtime bytes equal the qualified private Source/production-Min outputs; the committed source map embeds the exact TypeScript. Both complete consumer fingerprints remain 75afe60a0eba62055350d3b74cd336e5b1a472c83f297865693bfcdff1de85f7.
  • Browser — Owned Chromium 156.0.8078.4 compares 128 public core programs/1,408 chunks and ten genuine native module-Worker jobs against the frozen pre-change distribution, including sink acknowledgements/backpressure and abort during a write. Actual existing-page main-thread and Worker exports produce finite nonzero 48-kHz float32 stereo WAVs with zero page/request/HTTP/DSP errors and no created AudioContext. Their separate engine settings are not claimed to match.
  • Measurement scope — All sixteen new no-change rows and sixteen candidate rows pass their predeclared process-total CPU/current-thread CPU/wall-time gates, with 64 fresh processes/1,024 intervals/512 complete final public consumer witnesses per comparison; all eight balanced blocks and all four fresh pairs remain. See the complete workload deltas. No private Synth-state, physical allocation/GC/heap, general DSP-rendering, native-browser CPU, physical-device/listening, independent audit, release or publication approval is implied.

Scoped A/C review for MIDI cursor JIT stability: integration-owner review of src/core/midi-file.ts and generated assets; not independent security review.

  • A — Only the private cursor representation and its shared read calls change. Raw own-data/options/type/byte-view/input-length/shared-buffer checks, track/event/beat/voice budgets and wire validation retain their order. Every header/track cursor is created at the previous validated constructor point. Remaining-byte bounds, big-endian reads, valid tag/data-pair fast paths and bytewise mismatch/status-bit/truncation precedence, four-byte VLQs and exact errors remain. No raw getter, coercion, validation bypass, public API, protocol, permission, I/O or dependency change.
  • A — Cursor literals define own view, end and offset data fields without inherited setters. Views/cursors remain import-local; no caller buffer, cursor graph or note payload is cached, pooled or pinned, and no per-byte allocation/copy is introduced. The retained-reader diagnostic probe is not part of runtime code.
  • C — No DSP/render arithmetic, state, containment, callback, scheduling, ownership/FIFO/poly-pressure/sustain/EOF order or budget changes. Compiler-emitted Source and actual minified proofs retain all 18,823 expression vectors/74 files/roundtrips, 449 ownership cases and 301,152 binary cases with complete accepted results or exact refusal classes/messages, zero inherited cursor-field hooks and unchanged input/result isolation.
  • Evidence — Actual compile/build, all 626 existing behavioral tests (zero failed/skipped), strict source/development/public/core-only types, 42-source/55-built static security checks and all 55 byte-identical public declarations pass. All six complete current Source/minified MIDI/ownership/binary proofs match the original fingerprints. Actual Source/minified runtime bytes match the instrumented compiler/minifier outputs, and the minified source map embeds the new TypeScript.
  • Browser — Owned Chromium 156.0.8078.4 preserves all 18,823 public expression vectors, 74 SMFs/roundtrips and eight exact refusals with MIDI fingerprint 0e8eb185da57bfa93bbfe9ef02b50b3a4e69a651d7efafd6d041344aac40e484, then genuine 48-kHz sink-none AudioWorklet/Transport playback with caller-wire detachment, small/zero/quiet/full expression and hard left/right PCM. Pause preserves the cursor; resume reconstructs state; stop drains voices/events/owned IDs/PCM to zero; OPM close preserves the borrowed running context. Page/request/HTTP/DSP/rejection errors stay zero.
  • Measurement scope — This is a scoped Node/V8 JIT-stability change, not a stable CPU speedup claim. All twelve candidate-only no-change rows, including five process-total CPU failures, remain in CHANGELOG. No metric substitution, selective rerun or full 26+26 expansion follows. Other JIT activity remains; no exact hidden-class identity, physical allocation/GC/heap savings, native-browser CPU, physical-device/listening/deadline, independent audit, release or publication approval is implied.

Scoped A/C review for Dense quiet expression products: integration-owner review of src/core/midi-file.ts and generated assets; not independent security review.

  • A — Only private validated expression-product selection changes. All raw config/event/control validation, own-descriptor/allowlist/type/finite/range/tuple checks, private identity trust, unknown/accessor/prototype refusals and exact error order remain. No raw getter, coercion, validation bypass, caller-data cache, API, declaration, format, protocol, I/O, permission or dependency change.
  • A — Every integer product in 0–127 is representable. Direct nearest-product selection preserves higher-product half-unit ties, the original zero-first 0.5 tie and signed zero. Targets above 127 retain the original descending search and stopping bounds. Canonical highest-divisor CC7/CC11 emission and separately normalized import factors remain unchanged; private own-data return slots, caller isolation and metadata are untouched.
  • C — No DSP render arithmetic, state, containment, ownership/FIFO/poly-pressure order, callback, scheduling protocol or event/byte/voice/queue budget changes. Source and actual minified modules retain all 18,823 expression vectors/74 files/roundtrips, 449 ownership cases and 3,264 DSP/207 containment cases exactly, including every integer product, half-unit IEEE neighbors, signed zero, full channel/key boundaries and exact refusals.
  • Evidence — All 626 existing behavioral tests, strict source/development/public/core-only types, 42-source/55-built static security checks and all 55 byte-identical public declarations pass. All 52 complete Source/minified CPU comparisons and adverse controls remain in CHANGELOG; both fixed quiet targets pass all four pairs in each build. Source, actual minified and owned Chromium retain MIDI fingerprint 0e8eb185da57bfa93bbfe9ef02b50b3a4e69a651d7efafd6d041344aac40e484. The rejected divisor-initializer variant and its original failed gate remain recorded without a selective rerun.
  • Browser/scope — Owned Chromium 156.0.8078.4 checks all 18,823 real public vectors, 74 files/roundtrips and eight expected invalid refusals, then genuine 48-kHz AudioWorklet playback of an exported/imported score with small/zero/full expression and hard stereo pan. Pause preserves the cursor; resume reconstructs state; stop drains voices/events/owned IDs/PCM to zero and OPM close preserves the borrowed running context. Page/request/HTTP/DSP/rejection errors stay zero. No universal acceleration, native-browser CPU, physical allocation/GC, physical-device, listening, deadline, independent audit, release or publication approval is implied.

Scoped A/C review for Literal tempo-point snapshots: integration-owner review of src/core/transport.ts and generated assets; not independent security review.

  • A — Only private own-data optional-field reads and validated output construction change. Raw plain-object/own-descriptor/allowlist/required/finite/range/curve/end-BPM/monotone checks retain their order and exact errors. Capturing private unknown values does not grant type or identity trust; the same checks still precede publication. A defined end BPM still requires a linear curve. No raw property getter, coercion, schema-field hoisting, caller-data/result cache, API, declaration, format, protocol, flag, I/O, permission or dependency change.
  • A — Three fixed literals create only the existing optional own fields and bypass inherited setters just like the original spreads. Ordinary prototypes, key order, enumerable/nonwritable/nonconfigurable frozen data, fresh points/outer arrays and detached ownership remain exact. Existing private map identity and source-prototype/terminal/optional-field context guards are unchanged; raw, caller-frozen and foreign snapshots still take their established validation paths.
  • C — Tempo slopes, integrals, inverse rounding, prefix arithmetic and all point/beat/event/voice/queue budgets remain. Source and actual minified modules match all 4,139 tempo cases, 142,604 conversions, 24 public paused OPM/Transport programs/120 edits, 3,264 DSP/207 containment cases, 449 MIDI ownership cases and 18,823 expression vectors/74 files exactly. No DSP render arithmetic, state traversal, ownership, callback or scheduling protocol changes.
  • Evidence — All 626 existing behavioral tests, strict source/development/public/core-only types, 42-source/55-built static security checks and all 55 byte-identical public declarations pass. Each tempo proof retains 12,504,055 Float64, 22,996,466 descriptor, 1,012,152 ownership and 16,380 input checks with zero coercions; fingerprint 708d60890ee79776b6945909befc4bd74b47d8622d13bde9dc370b3af8ab89a9. The output-only variant's missed Source gate remains recorded; the accepted variant passes the unchanged Source and actual-minified gates without selectively rerunning old rows.
  • Browser/scope — Owned Chromium 156.0.8078.4 compares all 64 expected public outcomes and observes genuine 48-kHz AudioWorklet Transport start/pause/raw 1024-point step/mixed/frozen/ramp replacement/resume/running reconstruction/stop, all optional own-field shapes, atomic getter refusal, finite stereo and borrowed-context preservation. Stop drains voices/events/owned IDs/PCM to zero; page/request/DSP errors and rejections stay zero. All 36 Source/minified CPU comparisons and adverse controls remain in CHANGELOG. No universal throughput, native-browser CPU, physical allocation/GC, physical-device, listening, deadline, release/publication or independent audit approval is implied.

Scoped A/C review for Single-field own control snapshots: integration-owner review of src/core/synth.ts and generated assets; not independent security review.

  • A — Single-field construction uses an own undefined placeholder keyed by the already captured native string/Symbol, not caller values or object spreading. Computed __proto__ is own data, never prototype assignment; inherited setters/coercion hooks cannot run. Invalid keys still reject before freeze/brand/publication. Existing own-descriptor, allowlist, scalar/tuple/ADSR/sustain-rate checks precede copying each caller value; related-field checks precede publication. The multi-field private null-prototype path and exact raw reflection/refusal order remain. No API, format, protocol, input flag, raw-input cache, I/O, permission or dependency is added.
  • A — Only genuine deeply frozen private output identities retain the existing reuse path. Raw/frozen inputs, clones, proxies and foreign-module outputs revalidate and detach; structured-cloned data validates at the receiving boundary. Published ordinary prototypes, key order, enumerable/nonwritable/nonconfigurable fields, nested frozen ownership and fresh note/rate-dependent DSP application remain exact. An invalid private placeholder is never published.
  • C — No render arithmetic, frame traversal, voice/fade/state budgets, queue bounds, terminal/callback behavior or containment changes. Source and actual minified proofs each preserve all 3,264 DSP/207 containment cases, 51,881,592 PCM bytes, 547,216,895 typed-state bytes, 11,690,406 scalar comparisons, 449 MIDI ownership cases and 18,823 expression vectors/74 files.
  • Evidence — All 626 existing behavioral tests, strict source/development/public/core-only types, 42-source/55-built static checks and all 55 byte-identical public declarations pass. Source, actual minified and owned-process Chromium 156.0.8078.4 match all 1,577 original control cases and 1,716 additional own-placeholder cases, including 1,680 prototype contexts, 3,432 input checks and zero getter/setter calls. The additional fingerprint is 0c3748e328df86c2b62fd5437ef70001b54f955b8b059791bc3f46aabce88a87; the original fingerprint remains unchanged.
  • Browser/scope — A trusted gesture drives genuine 48-kHz silent AudioContext/AudioWorklet stereo through all fifteen fields, nested mutation, accessor refusal, raw single-field/private-branded updates, exact opposite-channel hard-pan silence, release and borrowed-context preservation. Errors/rejections and page/request errors remain zero. All 68 Source/minified CPU comparisons, including the slower minified quiet1024 export and note-only roundtrip and Source expressive-import controls, remain in CHANGELOG. No universal throughput, native-browser CPU, retained-heap/GC, physical-device, listening or deadline claim, release/publication approval or independent audit is implied.

Scoped A/C review for Batched live control snapshots: integration-owner review of src/core/synth.ts and generated assets; not independent security review.

  • A — Only construction of already checked output fields changes. The captured own-key count selects the existing null-prototype property-descriptor route for one field, or a private result whose prototype is null during multi-field writes and restored to Object.prototype before freezing. Allowlisting, own data descriptors, all eleven scalar bounds, dense four-element tuples, full ADSR with optional sustain rate, related-field checks and exact refusal order remain. Unknown keys cannot become unchecked assignments. No input flag, raw-input trust/cache, API, format, protocol, I/O, permission or dependency is added.
  • A — Only deeply frozen private output identities retain the pre-existing fast path. Raw inputs, caller-frozen lookalikes, clones and Proxy wrappers revalidate and detach; structured-cloned controls revalidate in the receiving realm. Published ordinary prototypes, field order, enumerable/nonwritable/nonconfigurable data, nested immutable ownership and independently applied note/rate state remain unchanged.
  • C — No render-loop arithmetic, frame traversal, voice/fade budget, queue bound, terminal/callback behavior, error containment or pooled-state lifecycle changes. Source and actual minified proofs each preserve 3,264 DSP/207 containment cases, 51,881,592 PCM bytes, 547,216,895 typed-state bytes and 11,690,406 scalar comparisons. The 449-case MIDI ownership and 18,823-vector/74-file expression proofs also remain exact.
  • Evidence — All 626 existing behavioral tests, strict source/development/public/core-only types, 42-source/55-built static security checks and all 55 byte-identical public declarations pass. Source, actual minified and owned-process Chromium 156.0.8078.4 match all 1,577 direct control cases, 77,766 numeric/252,745 descriptor checks, raw Proxy reflection/mutation/revocation, caller mutation and private-only identity checks; fingerprint 168dcdcb8566bfcc39eca31189a7b57aab77fb7150c09b1f7695dcaf5f427f09. Twenty-two inherited field/descriptor contexts have zero getter/setter calls.
  • Browser/scope — A trusted gesture drives real 48-kHz silent AudioContext/AudioWorklet stereo output through fifteen raw fields, nested mutation, accessor refusal, single-field and private-branded updates, exact opposite-channel hard-pan silence, natural release and borrowed-context preservation; errors/rejections and page/request errors remain zero. All 68 Source/minified CPU comparisons and adverse MIDI controls are retained in CHANGELOG. No universal throughput, retained-heap/GC, physical-device, listening or deadline claim, release/publication approval or independent audit is implied.

Scoped A/C review for Indexed MIDI note ownership: integration-owner review of src/core/midi-file.ts and generated assets; not independent security review.

  • A — Only internally captured wire events use the new channel/key tables. Existing native-byte, status/running-status/seven-bit and own-data options validation precedes them: channels are 0–15 and notes 0–127. Sixteen own undefined channel slots protect lazy root writes; each fresh key array gets a null prototype before any key lookup/write. Raw bytes, options and result graphs gain no trust brand. No input flag, cache, queue pool, retained old payload, I/O, API, format, protocol, permission or dependency is added.
  • C — FIFO heads and newest-still-pressed pressure ownership remain; emptied slots become undefined, while sustained notes and channel fanout stay in their existing separate Sets. All event/fanout/gate/beat/PPQN limits remain. End-of-file traversal only writes existing independent gate durations, private owner deletions/counters and the release mask, never returned onset order or metadata. Per-import logical slots are bounded by sixteen channels and 128 keys each; this is not a physical allocation/retained-heap/GC measurement.
  • Evidence — All 626 behavioral tests, strict source/development/public/core-only types, 42-source/55-built AST security checks, zero runtime dependencies and all 55 byte-identical generated declarations pass. Source and actual minified proofs each retain all 449 public ownership cases, original 406 lifecycle cases, all-key sequential/simultaneous stress, exact 65536-wire/32767-pressed-key boundary/refusal, 234 canonical roundtrips and zero numeric prototype hooks (ba6df136c9041101b89652ac5f89481fc7002ed5a57cbe2b252811d708bab934); the existing 18,823-vector/74-file expression and roundtrip proof remains exact. The new permanent regression exercises inherited numeric holes and ignored unknown/released poly pressure without corrupting independent note ownership. No Map/pool implementation-identity test is pinned to the new representation.
  • Browser — Chromium 156.0.8078.4 validates 140 public import cases (136 successes/four exact refusals), 14,378 own descriptors and 8,196 Float64 values against the accepted baseline, including both formats/running-status/control policies, all sixteen channels, reverse/reinserted end-of-file gates and zero Object/Array key-127 getter/setter calls. Caller mutation cannot poison a fresh import. The actual three-note, pedal-held/re-on 6/8 import also drives a genuine 48-kHz AudioContext/AudioWorklet/analyser via a trusted gesture and native silent sink: held/resumed voices stay at three with finite nonzero PCM (observed peak 0.20465756952762604), zero DSP errors/rejections, then zero active/pending/owned gates after stop. Borrowed-context preservation is checked before test-owned close; no page/Transport errors or CSP/MIME/autoplay/permission relaxation. Physical devices/MIDI, human listening and native-browser CPU/deadline acceptance remain unverified.
  • Performance scope — All 52 Source/actual-minified comparisons, including Source expression-roundtrip +37.44%, overlapped-import +28.61% and minified one-note +5.97% costs, are retained in CHANGELOG. The corresponding minified roundtrip/overlap paths improve; no universal Source, rendering, memory/GC or real-time/deadline gain is claimed. This record is not release, publication or independent audit approval.

Scoped A/C review for Trusted tempo-map edits: integration-owner review of src/core/transport.ts and generated assets; not independent security review.

  • A — Only the existing private normalized-map WeakMap identity plus stableTempoContext() admits the owned-point branch. Caller-frozen, mutable, proxy and unsafe source-context inputs retain their old path. New canonical point/array identities remain fresh and frozen; null-prototype temporary array writes cannot reach inherited indexed setters. There is no caller-controlled trusted flag or retained mutable input.
  • C — Primitive beat/BPM bounds remain first; the edited ramp end and every new slope still validate. The unchanged shared finalizer preserves left-to-right prefixes, exact full spans, context invalidation and inverse successive-subtraction rounding. At most 1024 points, 86400 beats, 1–1000 BPM and 2N - 1 Float64 cache cells; oversized/refused public edits remain atomic. The new permanent regression rechecks slope overflow after a privately normalized map loses an inherited endBpm context.
  • Evidence — Source and actual minified distributions share the complete 4,139-case fingerprint 708d60890ee79776b6945909befc4bd74b47d8622d13bde9dc370b3af8ab89a9: 12,504,055 Float64 checks, 22,996,466 descriptor checks, 1,012,152 ownership checks, 16,380 input-preservation checks, 142,604 numeric conversions and zero coercions per distribution. Twelve real public OPM/Transport programs run against each original/candidate (24 runs/120 edits); hostile optional/terminal/index/array-parent contexts and refusal paths also match.
  • Gates — 64 targeted tests and the full 625-test suite pass; strict source/dev/public/core-only NodeNext typechecks and the 42-source/55-built security gate pass with zero runtime dependencies. All 55 generated declarations remain byte-identical. All 16 Source and 16 actual-minified CPU rows, including adverse unnormalized/numeric controls, are retained without completed-comparison reruns.
  • Browser/scope — Chromium 156.0.8078.4 real 48-kHz native AudioContext/AudioWorklet/analyser verifies paused exact-boundary, live and resumed edits, zero DSP errors, empty owned idle state and borrowed-context preservation. Actual unchanged /examples/sequence.html trusted clicks verify 180 BPM and a 2.25-beat seek/resume/stop/dispose. Native output is routed to a silent sink, not a fake context. No API, declaration, format, worklet protocol, Web Audio dependency in core, permission, dynamic code or supply-chain change; this is local host-control performance evidence, not physical-device/MIDI/listening/deadline or release acceptance.

Scoped A/C review for Packed mono PCM16 output:

  • A (integration-owner scope; not independent): Only the existing private mono PCM16 branch changes; remove the now-unused private Int16 capture after its last view is replaced. Captured NativeUint32Array is reused. Existing native Float32/own-data/shape/rate/size/finite checks, public declarations, tests, stereo16/PCM24 routes and defaults remain. No new validator, buffer, cache, state, API, format, Worker protocol, dependency or permission. The current README obsolete mono-Int16 claim is corrected; historical per-commit records remain historical.
  • C (numeric/ownership/state): Full PCM data begins at byte 44 and chunks at byte 0, both four-byte aligned. Original full 1–4,000,000/chunk 1–65536 bounds make paired-frame arithmetic safe. View only paired samples as one word per two mono frames; the optional final sample has two in-bounds byte writes outside the view. Mono16 data is always RIFF-even; no file/chunk alignment byte. Preserve ascending read/check/asymmetric-scale/round order and low-16-bit wire bytes. Private output is disjoint/unshared and unpublished until success; failures commit neither frames nor RNG. No input PCM retained or modified and no extra view. Other formats/dither/small/big-endian routes are unchanged; no physical big-endian acceptance is claimed.
  • Evidence: All 15 existing focused tests and 624 full tests, strict source/development/public/core-only types, 42-source/55-built security checks, empty runtime dependencies and six byte-identical declarations pass. Each distribution preserves 1,813 full-file/3,526 streaming cases, 908,139,586 WAV bytes, 54,642,433 independent sample checks, 151,688 tracked header/state checks, 152,406 ownership checks, 3,626 input-preservation checks and 13,090 refusals, with zero metadata getter reads. Maximum mono16 even/odd sizes, all packing/tail positions, aliases/shared/foreign realms, padding and failed-chunk/noise recovery are covered. All twenty-two CPU rows retain actual omitted defaults and costs: minified 131 frames are mixed including a 13.53% adverse pair; fallback full/stereo controls +0.79%/+0.28% in three pairs; Source Float32 +1.65% in all four. No universal speed, GC or audio-deadline claim.
  • Browser check: Chromium 156.0.8078.4 on darwin/arm64 also passes ten real browser-realm public mono cases using 12,476–12,479 nonzero frames: PCM16/PCM24/Float32, dither, even/odd pair tails and two genuinely format/dither-omitted defaults. Full and incremental bytes agree across 128/129/130/131/127-frame prefixes and the remaining tail, and match the accepted encoder on captured PCM. Mono PCM16 uses the optional two-byte sample tail but no RIFF padding, including odd lengths; PCM24 control padding remains correct. The actual omitted-default mono PCM16 Blob download has 25,002 bytes and the exact baseline hash. The unchanged stereo PCM16 example remains a separate control, producing 17,280 frames/69,164 bytes at 48 kHz with zero DSP errors. No page errors or horizontal overflow occur. No AudioContext, audio-file playback, new mono UI control or permission/CSP/MIME relaxation is introduced. This is browser codec behavior, not browser CPU, native audio deadlines, physical-device/MIDI, human-listening or big-endian hardware acceptance. This is a scoped integration-owner review, not an independent release or publication approval.

Scoped A/C review for Packed stereo PCM16 output:

  • A (integration-owner scope; not independent): Only the existing private PCM16 native writer changes; public declarations, tests and validation are unchanged. Captured NativeUint32Array replaces the stereo Int16 view; mono retains one Int16 view inside its existing branch. No new validator, buffer, cache, state, API, format, Worker protocol, dependency or permission. Format/dither-omitted public defaults retain full admission; no trusted-input bypass.
  • C (numeric/ownership/state): Full PCM data starts at byte 44 and chunks at byte 0, both four-byte aligned. Original full 1–4,000,000/chunk 1–65536 bounds precede the loop. One Uint32 word per stereo frame covers exactly four data bytes with no odd-frame/padding tail. Preserve every L/R read, finite/range check, asymmetric scale and rounding step; the low-16-bit mask and shift reproduce native Int16 wire bytes. Private output remains disjoint from inputs and unpublished until success; invalid samples commit neither frames nor RNG state. Mono, small chunks, big-endian fallback, PCM24, Float32 and dither retain their routes. No input retained or modified and no extra output view. Big-endian hardware was not tested; its unchanged fallback is not hardware acceptance.
  • Evidence: All 15 existing focused tests and 624 full tests, strict source/development/public/core-only types, 42-source/55-built security checks, empty runtime dependencies and six byte-identical declarations pass. Each distribution preserves 1,811 full-file/3,522 streaming cases, 828,139,156 WAV bytes, 46,642,434 independent sample checks, 150,572 tracked header/state checks, 150,782 ownership checks, 3,622 input-preservation checks and 13,090 refusals with zero metadata getter reads. All twenty-one CPU rows include two actual format/dither-omitted default consumers. Both minified defaults improve in all four pairs, but 128-frame targets are mixed and 127-frame fallback/Float32 controls regress 2.52%/1.24%/2.42% in three pairs. Source mono PCM16 +3.10% also remains recorded. No universal speed, GC or audio-deadline claim.
  • Browser check: Chromium 156.0.8078.4 on darwin/arm64 also passes the actual deployed PCM16 example: its real button uses format/dither-omitted encodeWav, renders 17,280 stereo frames at 48 kHz with zero DSP errors and downloads 69,164 bytes. Eight separate browser-realm public PCM16/PCM24/Float32/dither/alias/default cases use 12,477 nonzero unequal-channel frames, retain full/stream bytes across 128/129/127/12093-frame chunks and match the accepted encoder on captured PCM. Both explicit and format/dither-omitted defaults, including same-object aliases, agree. The actual default stereo PCM16 Blob download has 49,952 bytes and the exact baseline hash. There are no page errors or horizontal overflow. No AudioContext, audio-file playback, new UI control or permission/CSP/MIME relaxation is introduced. This verifies browser codec behavior, not browser CPU, native audio deadlines, physical-device/MIDI, human-listening or big-endian hardware acceptance. This is a scoped integration-owner review, not an independent release or publication approval.

Scoped A/C review for Packed mono PCM24 output:

  • A (integration-owner scope; not independent): Only the private little-endian, undithered mono PCM24 writer changes; one existing independent PCM test adds 130/131-frame cases. Original own-data, native Float32, shape, finite/range, rate and size checks remain. The captured NativeUint32Array replaces one existing output view with no new buffer, cache, state, validator, API, format, Worker protocol, dependency or permission. Accepted stereo32 packing is unchanged.
  • C (numeric/ownership/state): Full PCM data begins at byte 44, chunks at byte 0; both are four-byte aligned. Validated full lengths of 1–4,000,000 and chunk lengths of 1–65536 bound group arithmetic. Three LE32 words contain four original 24-bit integers; masks remove only 24/16/8-bit sign extension. All ascending read/check/scale/round steps remain. The view excludes zero to three byte-written tail samples and RIFF padding. Native chunk data stays exactly three bytes per frame, with no per-chunk padding; finalize emits the one global alignment byte only when required. Private unshared output is disjoint from all input PCM, remains unpublished until success, and is not retained by the encoder. Invalid samples commit neither frames nor RNG state. Dither, small chunks, big-endian fallback, PCM16 and Float32 retain their routes. Physical big-endian hardware is untested; no hardware acceptance is claimed.
  • Evidence: All 15 focused tests and 624 full tests, strict source/development/public/core-only types, 42-source/55-built security checks, empty runtime dependencies and six byte-identical declarations pass. Source and minified each preserve 1,811 full-file/3,522 streaming cases, 828,139,156 complete WAV bytes, 46,642,434 independent sample checks, 150,572 tracked header/state checks, 150,782 ownership checks, 3,622 input-preservation checks and 13,090 refusals with zero metadata getter reads. All four tails, near-4,000,000-frame mono limits, aliases/shared/foreign realms, padding and failed-chunk/noise recovery are covered. All nineteen CPU rows and costs remain recorded: PCM16 mono +4.04% Source/+2.37% minified in three pairs, and the 131-frame minified target is mixed. No universal speed, GC or audio-deadline claim.
  • Browser check: Chromium 156.0.8078.4 on darwin/arm64 also passes real browser-realm deployed modules, offline synthesis and Blob downloads. The unchanged stereo PCM16 example still produces 17,280 frames at 48 kHz with zero DSP errors. Separate public mono encoding exercises 12,476/12,477/12,478/12,479-frame PCM24 files, all four modulo-four tails, and zero/one/zero/one final padding bytes. Eight PCM16/PCM24/Float32/dither cases retain exact full/stream and accepted-baseline bytes on captured nonzero PCM across 128/129/130/131/127-frame prefixes and the remaining tail. Chunks contain no RIFF padding; finalize emits it once. The real mono PCM24 download has 37,482 bytes and the exact baseline hash. There are no page errors or horizontal overflow. The example still exposes stereo PCM16 only, not a new mono24 UI feature. No AudioContext, audio-file playback or permission/CSP/MIME relaxation is introduced. Browser codec behavior is verified, not browser CPU, native audio deadlines, physical-device/MIDI, human-listening or big-endian hardware acceptance. This is a scoped integration-owner review, not an independent release or publication approval.

Scoped A/C review for Packed stereo PCM24 output:

  • A (integration-owner scope; not independent): Only the private little-endian, undithered stereo PCM24 writer changes. Existing own-data, native-channel, matching-length, finite/range, rate and size validation is unchanged. Both full output and chunks own fresh, unshared buffers. The already-captured NativeUint32Array replaces one existing output view; no new validator, cache, persistent flag, buffer, dependency, API, format, Worker protocol or permission.
  • C (numeric/ownership/state): Full integer WAV data begins at byte 44 and chunks at byte 0, both four-byte aligned. Validated full lengths of 1–4,000,000 and chunk lengths of 1–65536 keep paired-frame arithmetic and word counts bounded. Three words cover exactly two stereo24 frames; 24/16/8-bit masks remove only sign-extension bytes. Preserve original L0/R0/L1/R1 capture, finite checks, scaling and rounding. The remaining odd frame uses six in-bounds byte writes. Intermediate output is private and disjoint from all input PCM, so batched stores introduce no caller-visible alias/getter/callback boundary. Reject before output publication and frame/RNG commit. Dither and all other writers retain their original paths; no source PCM is modified or retained. Physical big-endian hardware was not tested; its unchanged fallback is not a hardware acceptance claim.
  • Evidence: All 15 focused WAV tests and 624 full tests, strict source/development/public/core-only types, 42-source/55-built security checks, empty runtime dependencies and six byte-identical declarations pass. Each distribution preserves 1,807 full-file/3,514 streaming cases, 585,452,356 complete WAV bytes, 30,642,440 independent sample checks, 130,338 tracked header/state checks, 147,534 ownership checks, 3,614 input-preservation checks and 7,090 refusals, with zero caller-metadata getter reads. Exact odd tails, all packing lanes, aliases/shared/foreign-realm buffers, maximum full sizes and failed-chunk recovery are covered. All eighteen complete-consumer CPU rows and adverse controls are retained: source mono chunking +2.16% in all four pairs; actual minified +2.29% with mixed pairs. No universal speed, GC or audio-deadline claim.
  • Browser check: Chromium 156.0.8078.4 on darwin/arm64 also passes actual browser-realm deployed modules, offline synthesis and real Blob downloads: the unchanged PCM16 example produces 17,280 stereo frames at 48 kHz with zero DSP errors, while a separate public-API invocation produces 12,477 odd-length frames with nonzero unequal channels. Six PCM16/PCM24/Float32, dither and exact-alias cases preserve full/stream bytes across 128/129/127/12093-frame chunks and match the accepted encoder on captured PCM. The downloaded stereo PCM24 file has 74,906 bytes and the exact baseline hash. No page errors or horizontal overflow occur. The example still exposes PCM16 only; no PCM24 UI feature is claimed. No AudioContext, audio-file playback or permission/CSP/MIME relaxation is introduced. This verifies browser codec behavior, not browser CPU, native audio deadlines, physical-device/MIDI, human-listening or big-endian hardware acceptance. This is a scoped integration-owner review, not an independent release or publication approval.

Scoped A/B/C review for Small worklet queue append:

  • A/B (integration-owner scope; not independent): Only the final private small-queue insertion changes. Fresh owned scheduled-event literals still come from strict own-data/numeric message validation. After the same reverse scan, index === length uses events.push; all other positions retain events.splice. Preserve EVENT_ORDER, stable arrival ties, 256-event/tracked-ID bounds, duplicate/late rejection, registration identity and queued snapshots. No new queue state, cursor, heap, cache, flag, buffer, permission, dependency, protocol, export or public declaration.

  • C (state/callbacks): Every original frame/type read and comparator remains in place. Large-queue append and binary search are untouched. Pop-before-dispatch, core terminal/stealing callbacks, obsolete automatic-stop removal, cancellation/refill and panic/allNotesOff/close are unchanged; DSP arithmetic and all PCM boundaries are untouched.

  • Evidence: All 624 tests, strict source/development/public/core-only types, 42-source/55-built security checks, empty runtime dependencies and five byte-identical declarations pass. Source and actual minified modules each preserve 9,216 ordered insertion cases, 1,275,989 private-event read-trace entries, 48 rendered lifecycle cases, 10,080 complete-state witnesses and 786,432 PCM bytes, plus exact 256/257 capacity behavior. All sixteen whole-consumer CPU rows per distribution and adverse results are retained: minified prepared one-note and prepared-burst controls regress 1.07% and 1.74% in all four pairs. No physical allocation/GC, native audio deadline or universal acceleration claim.

  • Native check: Chromium 156.0.8078.4 on darwin/arm64 also passes the genuine 48 kHz AudioWorklet/AudioContext lifecycle using the native silent sink (setSinkId({ type: "none" })) and a trusted gesture: finite held stereo, full-right pan, a public frequency ramp, release, scheduled cancellation, suspend/resume, borrowed/owned context close/restart and zero final active/pending/error/rejection diagnostics. Its isolated fixture still refuses ancillary non-dist requests; no autoplay/CSP/MIME/permission control is relaxed. This is not physical-device/MIDI, human-listening or native audio-deadline acceptance. This is a scoped integration-owner review, not an independent release or publication approval.

Scoped A/C review for Stationary pitch preparation:

  • A (integration-owner scope; not independent): Only the existing private render caller frequency-ramp dispatch changes. Reuse its local classifications; the original general preparation helper is unchanged. No new API, export, voice format, validator, protocol, worker/serialization, dependency, permission, persistent flag/cache/buffer or per-frame allocation. No release or distribution publication.
  • C (numeric/state): Inside the existing frequency-ramp dispatch, verified !gliding means pitchFrames === 0 and the local envelope is the voice pitchEnvelope. Finite pitchTarget therefore makes both original endpoints identical: retain division/fastExp2 and both frame[5]/frame[6] stores before frequency preparation. Never reuse old cells or the envelope-fold validity flag. The Number.isFinite guard keeps NaN endpoints on original nonfinite-ratio preparation; live glides/envelopes and every no-frequency call use the unchanged original helper. Every substep multiplication and operator store is untouched. Preserve the existing envelope-only pitchSettled validity meaning; no new invalidation scheme. Signed-zero, subnormal, finite-overflow and NaN/infinite targets retain exact PCM, both scratch cells, every geometric substep, callback/error and retired/free-pool state.
  • Evidence: All 624 tests and the focused 55 pass, strict source/development/public/core-only type checks and 42-source/55-built security checks pass, runtime dependencies are empty and five generated declarations are byte-identical. Source and actual minified compare 3,264 lifecycle/207 containment cases, retaining all prior 171 and adding 36 stationary-target cases. All 35 CPU rows and adverse controls are retained: the rejected helper-growing variant regressed envelope CPU by 6.23% in all minified pairs; the sole caller-local refinement restores the helper and improves that control by 9.13% in all pairs, but zero-static-level noise regresses 2.81% in all pairs. No universal gain or independent review is claimed. A genuine native AudioWorklet without a pitch envelope verifies the public frequency command at 937.5 Hz after 0.8 seconds, real audio-clock progression, held stereo/pan, release/cancel/suspend/close and zero final diagnostics. Experimental native none-sink processing is asserted, not mocked; physical/default-device timing and human listening remain unverified. Canonical docs are checked in a real browser against all 35 exact rows, README invariants, search and this scoped record, with visual screenshots.

Scoped A/C review for Shared operator frequency-ramp derivation:

  • A (integration-owner scope; not independent): Limited to private frequency preparation and one public audio-independence regression. Input ratio/frequency/scale buffers and output base/delta/curve buffers are separately factory-owned Float64 arrays, with preparation after control updates and before frame dispatch; no callback mutates inputs inside it. No new flag, buffer, per-frame allocation, cross-frame cache, export, voice format, validator, protocol, worker/serialization, dependency, permission or pure-core declaration surface.
  • C (numeric/state): Numeric equality of nonzero used inputs implies identical double bits; zero-valued used sharedScale/histories/ratios keep independent calculations. The zero fixed-Hz target is only a mode sentinel and its sign is overwritten before arithmetic. Existing frequencyDone0/ratioDone0 imply the middle/end clocks are also done, so only histories already unused by the original formula are skipped. Preserve multiply-before-divide interpolation, each arithmetic grouping and all twelve base/delta/curve stores in original operator order. Number.isFinite on the derived triplet guards sharing; NaN/infinite/overflow results continue original per-operator calculation and stores, preserving payloads and error/callback/retirement state. No new step, phase, gain or clock mutation.
  • Evidence: All 624 tests, strict source/development/public/core-only type checks, 42-source/55-built-module security checks, empty runtime dependency tree and five byte-identical generated declarations pass. The public muted-operator detune/Hz/ratio independence regression also passes against the frozen accepted baseline. Source and actual minified modules match complete PCM/numeric state across 3,264 lifecycle and 171 containment cases, retaining all previous 129 and adding 42 signed-zero, payload/overflow, unused-ratio and completed-history cases. All 35 paired CPU rows and adverse controls remain in the changelog; no universal speedup. A genuine native AudioWorklet runs the public common-frequency ramp and verifies actual analyser frequency, native clock, full lifecycle and zero final diagnostics, with no fake audio APIs. Native experimental-silent-sink processing is not physical-device/default-clock or human-listening acceptance.

Scoped A/C review for Shared clamped carrier pitch steps:

  • A (integration-owner scope; not independent): Changes are limited to the existing common-pitch sine helper after its original eligibility guards. Frame-local stepBase and pmFactor come from separately allocated, factory-owned Float64 state; preparation is complete before the helper and no callback/retarget mutates these coefficients within a frame. No new persistent state, allocation, import/export, buffer alias, public type, voice format, message/worker/serialization or permission surface. Existing public input bounds and ordinary JavaScript numeric-intrinsic trust assumptions are unchanged.
  • C (numeric/state): Keep the original ordered inner pre-PM and outer MAX_STEP caps, every operator store, and exactly one frame[5] = pitchFactor * frame[6] multiplication per substep. Only identical nonzero finite results share computation: distinct numeric zero signs and NaN/nonfinite results go through the original independent stepPitch stores before any candidate mutation. Skip fractional division only when frequency ramps are absent. A nonzero-gain nonfinite history returns after the existing pitch advancement, never replaying or restarting it. Preserve gain/sign multiplication grouping, phases, histories and callback/retirement order.
  • Evidence: All 623 tests, strict source/development/public/core-only type checks, 42-source/55-built-module security checks and the empty runtime dependency tree pass; five generated declarations are byte-identical. A public muted-operator PM/pitch/clamp/release regression passes unchanged against both versions. Source and actual minified cores match complete PCM/numeric state across 3,264 lifecycle and 129 containment cases, including all original 105 and 24 new signed-zero/negative/infinite/NaN/masked cases. All 33 paired CPU workloads and adverse controls are retained in the changelog; minified eco common glide is a disclosed 0.36% regression, not a universal speedup. Native experimental-silent-sink AudioWorklet proof uses built modules, a continuously moving pitch envelope and genuine browser audio APIs; all final diagnostics are zero. Physical-device playback/default-device clock and human listening remain unverified.

Scoped A/C review for Aligned common-pitch sine frames: integration-owner review (not independent), limited to one private dynamic frame and dispatch from the existing aligned algorithm-7 wrapper. Section A: raw own-data/numeric validation, prepared identity, voice format, worklet protocol, pure-core declarations, dependencies and input authority are unchanged. No new per-voice flag, buffer, export, I/O or runtime dependency.

Section C — The existing wrapper first checks zero feedback, common phases/current steps and every negative-zero phase before selecting synchronizedPitchSineFrame7. The helper checks equal baseIncrements, live incrementDeltas/incrementCurves only while ratio/Hz ramps are active, and equal targeted PM factors. These coefficients stay fixed during the frame. The unchanged stepPitch runs exactly once, first on every substep, preserving all four independent step stores and the pitch-factor multiply. Share only the polynomial with original p * (gain * sign), per-operator zero masking, ascending carrier sum, phase/value and operator-0 history stores. A nonzero op0 gain with nonfinite summed history returns false after the same current-substep pitch mutation and finite output prefix; it must not restart an already-mutated dynamic frame. Terminal state commits, bounded 2/4/8 substeps, callback/PRNG behavior and pool bounds remain unchanged. Ordinary JavaScript numeric intrinsics are assumed, as in the previous scoped review.

Verification: all 622 behavioral tests; strict source/development/public/core-only types; scoped integration-owner A/C review (not independent); 42-source/55-built security gate; empty runtime dependency tree; five byte-identical public declarations. Actual source/minified proofs match across 3264 raw/prepared lifecycle cases and 105 containment cases: 51,880,776 stereo PCM bytes, 545,211,065 typed-state bytes, 11,619,210 scalar comparisons and 112,233 checkpoints, including complete returned-slot state. Coverage adds overlapping common glides, fixed-Hz/ratio/quadratic ramps, pitch envelopes, uniform PM and initially equal origins with independently diverging future coefficients. The original static containment cases remain; dynamic cases also preserve the original recovery when stepPitch overwrites a corrupt prior step, signed zeros, zero-gain history masking and mid-frame history overflow. All 33 CPU rows and adverse controls are retained rather than claiming universal real-time, GC or perceptual improvement.

Actual Chromium 156.0.8078.4 on darwin/arm64 exercised the deployed v8 aligned algorithm-7 voice through a real 48 kHz AudioWorklet and a borrowed AudioContext using the documented native silent sink. A two-second pitch-envelope attack keeps the held-note test genuinely dynamic. All original trusted-gesture, same-origin, CSP/MIME, destination-null, routing, finite/headroom, stereo, full-right pan, release, preserve/cancel, suspend/resume and borrowed/owned-context cleanup assertions passed. The native clock advanced to 1.029333 seconds; final diagnostics had zero active voices, pending events, errors and rejected notes. The default-output owned contexts still stop at 0.005333 seconds, matching the earlier no-OPM native oscillator controls; the experimental silent-sink API is only a throwaway host-proof configuration, not an SDK requirement or fake signal. Physical-device playback and human listening remain unverified.

Scoped A/C review for Aligned independent sine carriers: integration-owner review (not independent), limited to a private sine frame and admission selection. Section A: own-data/numeric validation, prepared identity, voice format, raw worklet protocol, dependency tree and pure core declarations are unchanged. Existing frameKernel is the only selection slot; no new per-voice flag, buffer, input authority, export or I/O.

Section C — Shared invariant: only the original pure-sine algorithm-7 route, zero feedbackScale, four nonzero static levels, nonzero equal steps and uniform/shared PM targets select synchronizedSineFrame7. Runtime phases/steps, feedback, dynamic-pitch and negative-zero guards retain the original frame. Share only the polynomial, preserving p * (gain * sign), per-operator zero masking, independent envelopes, carrier sum order, all four phases/values stores and previous/older. Nonfinite history with nonzero operator-0 gain restarts the original frame at most once before active numerical-state writes; output-prefix recomputation has the same fixed 2/4/8-substep ceiling and introduces no duplicated pitch, callback or PRNG effects. All-zero gains skip polynomial work while advancing clocks.

Observed source/minified proofs match across 2880 lifecycle and 21 containment cases, 43,614,888 stereo bytes, 385,953,765 typed-state bytes, 8,381,058 scalar comparisons and 77,781 checkpoints, including returned slots, independent ADSRs, signed zeros, silent wake, masked NaN recovery, mid-frame overflow, feedback/frequency transitions, steals/fades and periodic/noise reuse. All 622 tests, strict types, 42-source/55-built security gate, empty runtime dependency tree and five byte-identical declarations pass. All 23 CPU rows are disclosed, including consistently slower live-frequency, nonzero-feedback and prepared-admission controls; no universal real-time, GC or perceptual guarantee is claimed. Native JavaScript intrinsics retain their ordinary semantics; this is not approval of arbitrary intrinsic replacement or independent release approval.

Actual Chromium 156.0.8078.4 on darwin/arm64 also exercised the deployed v8 algorithm-7 aligned-sine voice through a real 48 kHz AudioWorklet and a borrowed AudioContext using the documented native silent sink (setSinkId({ type: "none" })). All original trusted-gesture, same-origin, CSP/MIME, destination-null, connection routing, finite/headroom, held stereo, full-right pan, release, suspend/resume, preserve/cancel and borrowed/owned-context cleanup assertions were retained and passed; the clock advanced to 0.976 seconds and final diagnostics had zero active voices, pending events, errors and rejected notes. The host's default-output clock stalled after 0.005333 seconds in five separate native oscillator controls loading no OPM modules, including documented unmuted launch and nonzero-gain variants; no underlying driver cause is claimed. The experimental silent-sink API is only a throwaway host-proof configuration, not an SDK requirement or fake audio source. Default-device playback and human listening remain unverified.

Scoped A/C review for Synchronized noise operator clocks: integration-owner review (not independent), limited to a private noise frame kernel and admission selection. Section A: own-data/numeric validation, immutable prepared identity, voice format, raw worklet protocol, dependency tree and pure core declarations are unchanged; no I/O, allocations, buffers, flags or public APIs are introduced.

Section C — Shared invariant: admission initializes all four noiseStates to NOISE_SEED and resets noiseTurns. Only four equal immutable noiseSteps with nonzero static levels select synchronizedNoiseFrame. Generic, silent and specialized paths retain each fractional addition/tick subtraction and identical seeded progression; the new kernel writes every operator state and preserves carrier/noncarrier finite checks, phase/history, callbacks and bounded slots. Desynchronized runtime clocks or states use the existing general noise kernel, not a substitute output. Differing rates and zero static levels keep their original route.

Observed source/minified proofs match across 1728 raw/prepared lifecycle cases, 24,883,200 exact stereo bytes, 183,983,040 typed-state bytes, 4,069,440 scalar comparisons and 36,288 checkpoints, including returned free slots, generic/static/dynamic control changes, silent wake, steals/fades, rate switching and intentional clock/state desynchronization. All 622 tests, strict source/development/public/core-only types, the 42-source/55-built security gate, empty runtime dependency tree and five byte-identical declarations pass. All 16 CPU controls, including slower minified eco-sine and raw-noise admission rows, are disclosed; no universal latency, GC, glitch or perceptual guarantee is claimed.

Actual Chromium 156.0.8078.4 AudioWorklet acceptance uses a version-8 four-noise-operator voice with 8000 Hz hold rates, not a sine substitute. Trusted gesture, original same-origin/CSP/MIME restrictions, stereo/headroom, full-right pan, held/release lifecycles, suspend/resume and borrowed/owned context cleanup pass; final diagnostics have zero active voices, pending events, errors and rejected notes. Physical-device MIDI and human-listening acceptance remain unverified.

Scoped A/C review for Immutable graph-row admission snapshots: integration-owner review (not an independent review), limited to one local graph-row alias in core admission. Section A: no new I/O, dependencies, allocations, persistent metadata, exports, format changes or trust-boundary exceptions; strict raw-input validation, public contracts and pure core declaration dependencies remain unchanged.

Section C — Immutable outer data, volatile input holes: active.graph.inputs[op] is a frozen own-data row. The held spare has already left freeVoices and is absent from active/fading voices, so supported public reentrant operations cannot replace its graph. Reusing that row locally preserves both numeric reads into inputIndices, their receiver, nullish fallback and integer coercion order; getters, valueOf reentry and original exceptions are not skipped or cached across admissions. The accepted sequence/population revalidation, publication and spare-return catch remain unchanged.

Section C — Observed runtime proof: all 622 tests and strict source/development/public/core-only types pass, with 42 source/55 built security checks, zero runtime/optional dependencies and five byte-identical public declarations. Source/minified summaries match for 1248 volatile-hole/coercion cases, 648 reentrant serial-oracle cases, 1536 complete numeric/typed-state cases, metadata and 468 guarded refusals, 768 noise cases, 1536 LFO cases and 283 general/workload pairs. All 85 complete four-pair CPU controls per distribution, including slower raw/edit/render controls, are disclosed in the changelog; rendering math is unchanged and no universal speedup is claimed.

Native Chromium 156.0.8078.4 checks actual 48kHz AudioWorklet stereo/pan output, both note lifecycles and final zero diagnostics, plus eight raw/prepared core reentrancy cases with 128,000 exact serial-oracle PCM bytes and full descriptor/length restoration. The separately committed fixture repair 34cf2f6 restores the numeric prototype descriptor and original Array.prototype.length in finally, with all 14 priority cases passing a separate process-exit prototype invariant. Physical-device/MIDI and human-listening acceptance remain unverified.

Scoped A/C review for Reentrant core note admission: the integration owner reproduced inherited numeric graph-input getters admitting notes after duplicate-ID/victim preflight. The old commit could remove an invalid index outside rollback, lose two slots or publish a duplicate ID. Required own-data/numeric validation, private prepared identity, immutable routing graphs and every existing inherited input read remain unchanged; getters and legitimate reentrancy are not suppressed.

admissionSequence and admissionSize are local snapshots, not new persistent state. Existing sequence advances for every successful nested admission, so equal-sized cancellation/replacement cannot hide a changed population; count detects pure cancellation/retirement. Only on a changed population, the final ID check and current stolenIndex/priority selection run inside the existing initialization catch. A late refusal clears partial cached identity/timing and returns its spare without undoing nested notes. Normal preflight refusal and post-publication terminal callbacks, fade/spill bounds, typed storage and DSP formulas remain intact.

All 622 tests and five new audible/pool/ID regression groups pass. Final source/minified proofs each preserve 648 corrected serial-audio oracle cases/11,354,112 exact stereo bytes and 432 expected refusal/throw outcomes across raw/prepared inputs, three policies/qualities, 8000/48000 Hz, two algorithms and nine scenarios. They cover current victim/priority, explicit/automatic IDs, equal-sized replacement, rendering during initialization, original getter exceptions, callback order and slot conservation, restoring ordinary numeric prototypes in finally. Healthy behavior retains 1536 detune lifecycle pairs/31,039,488 PCM bytes and 46,817,280 typed-state bytes at 36,864 checkpoints, plus the unchanged LFO/noise/general lifecycles, all 76 complete-workload pairs, 1344 general refusals, 468 mask refusals including 60 accessors and two independent metadata-accessor refusals with zero getter reads.

Build, strict source/development/public/core-only types, five byte-identical public declarations, the 42-source/55-built security gate and empty runtime dependencies pass. Actual Chromium AudioWorklet smoke retains finite stereo/pan, complete note/context lifecycles and zero final DSP errors, rejections or pending events; isolated ancillary non-dist requests remain refused. All 76 source/minified CPU controls and adverse costs are published: this correctness repair is not a universal speedup, physical-allocation/GC or deadline claim. This is an integration-owner scoped A/C review, not an independent audit, release/publication authorization or physical-device/MIDI/listening acceptance.

Scoped A/C review for Dormant LFO target cells: the integration owner traced every amTargets/pmTargets consumer and both existing amTargeted/pmTargeted flags. AM cells are read only under enabled targeted AM; PM cells are read under pmTargeted, including disabled-depth frames. Omitted and all-unity masks already select shared factors. Admission now initializes each four-cell private array only when its existing flag is true, without changing flag computation or rendering.

Every targeted tuple is still copied before playback even when its initial depth or rate is zero. Live controls cannot replace immutable masks or activate a false target flag; a later non-unity patch recomputes both flags and writes all required cells before callback-visible admission. Private prepared membership, detached frozen dense own-data tuples, boolean conversion, finite 0..1 bounds, explicit malformed-field rejection and inherited-property guards remain unchanged. No new field, cache, buffer, allocation, renderer branch, DSP formula, pool/fade bound, protocol, public API/type or voice-format change is introduced.

Final source/minified proofs each preserve 1536 LFO lifecycle PCM pairs/23,230,464 exact bytes, 4608 callbacks and 768 clock-aligned fresh-engine oracle pairs across three qualities, 8000/48000 Hz, eight algorithms, nine operator shapes, five LFO shapes, note/global sync, eight mask cases, dormant-depth activation, live controls, natural/panic reuse, fades, callback replacement and exact FIR drain. Another 768 operator-noise lifecycle pairs/11,615,232 exact bytes, 198 general lifecycle pairs/12,017,424 exact bytes and 67 complete-workload pairs retain finite output and fixed slot identity. The 468 dedicated raw-mask refusals include 60 accessors that return otherwise valid data; getter reads stay zero and original-note stereo is unchanged. The 1344 general refusal pairs and two independent metadata-accessor refusals also remain exact.

Build, all 617 tests, strict source/development/public/core-only type checks, five byte-identical public declarations, the 42-source/55-built security gate and empty runtime dependencies pass. Existing independent LFO audio regressions cover live activation and recycled uniform weights. All 67 source/minified CPU controls, including adverse results, are retained; these do not establish physical allocation, retained-memory, GC, rendering-deadline or native-browser performance improvements. This is an integration-owner scoped A/C review, not an independent audit or release/publication authorization.

Scoped A/C review for Dormant operator-noise clocks: the integration owner traced every noiseStates/noiseTurns consumer, including silent frames and generic/live-control rendering. SINE_FRAMES and WAVE_FRAMES never consume these private arrays. The existing waveform predicates now select equivalent if/else branches, with the same two seed/turn fills inside the noise branch; every note containing any noise operator still initializes all four clocks before its first render. No extra predicate, cache, persistent field, allocation, renderer branch or DSP formula is introduced.

Immutable prepared waveforms cannot change through live controls. A later noise patch always enters that initialization branch, including recycled, stolen and callback-admitted notes; silent noise still advances its hold clock as before. LFO noise has separate state and its resets are untouched. Raw own-data/numeric validation, prepared identity, frequency/noise-step preparation, pool/fade bounds, terminal traversal, output checks and public API/types/formats remain unchanged.

All 617 tests pass, including one fresh-engine stereo regression for noise → periodic → noise reuse with subsequent live controls/release and an independent held-noise LFO. Final source/minified proofs each preserve 768 dedicated lifecycle PCM pairs/11,615,232 exact bytes, 2304 callbacks per variant and 384 fresh-engine oracle pairs across all algorithms/nine shapes, three qualities and 8000/48000 Hz. Another 198 general lifecycle PCM pairs/12,017,424 exact bytes, 38 complete-workload pairs, 1344 exact refusal pairs and two independent accessor refusals preserve zero getter reads, original-note playback, reentrant replacement and fixed slot conservation.

Strict TypeScript checks, five byte-identical public declarations, the 42-source/55-built security gate and zero runtime dependencies pass. Native Chromium AudioWorklet smoke passes at 48000 Hz with finite stereo/pan, complete note/context ownership and zero final DSP errors, rejections or pending events. Ancillary non-dist requests remain refused by its isolated allowlist. All adverse CPU controls are retained; local Node results do not establish universal rendering speed, physical allocation, retained-memory, GC-pause, native-browser performance or application deadlines. This is no production-control waiver, release/publication approval, physical-device/MIDI or human-listening acceptance.

Scoped A/C review for Prepared frame-gain validity: the integration owner traced every gain-buffer writer and consumer. noteOn() no longer clears private gains, but still resets gainsSteady to false and preserves all other validity/clock resets. prepareGains writes all four operators for every oversample position before live frames consume the buffer. The existing finished branch bypasses gain reads entirely; quietest admission uses the current envelope instead while gains are not steady. No new renderer branch, input reader, trust/cache boundary, buffer size, pool/fade bound or callback traversal is introduced.

All 616 tests pass, including a new public-consumer regression for audible recycled slots stopped before their first frame, with and without stolen fades, over three qualities, two rates and sine/saw/noise. Final source/minified proofs each preserve 768 terminal/fade/callback PCM pairs/4,724,736 exact bytes and 1152 callbacks per variant, plus 198 general lifecycle PCM pairs/12,017,424 exact bytes and 28 complete-workload pairs. Exact FIR drain, nine operator shapes/all algorithms, interrupted/live controls, natural retirement, panic and reentrant replacement preserve bounded slot identity. The 1344 exact refusal pairs and two independent accessor refusals retain zero getter reads and original-note playback; raw own-data/numeric validation and prepared identity are unchanged.

Strict TypeScript checks, five byte-identical public declarations, the 42-source/55-built security gate and empty runtime dependencies pass. Native Chromium AudioWorklet smoke passes at 48000 Hz with finite stereo/pan, complete lifecycle/context ownership and zero final DSP errors, rejections or pending events. Ancillary non-dist requests remain refused by the isolated allowlist fixture. All adverse CPU controls are retained; local Node results do not establish universal rendering speed, physical allocation, retained-memory, GC-pause, native-browser performance or application deadlines. No public API/type/format/dependency/formula change, weakened production control, release/publication approval, physical-device/MIDI or human-listening acceptance is claimed.

Scoped A/C review for Inactive interpolation state: the integration owner traced every operator/scalar/ratio/frequency ramp reader and activation. noteOn() leaves dormant operatorFrom, operatorTargets, ratioFrom, frequencyFrom, scalarFrom and scalarStarts cells untouched. Operator/control bits and all frame counts still reset. Operator and scalar writers assign their interpolation inputs before activating clocks; zero-duration ratio/frequency evaluation returns freshly initialized targets, and new ratio/frequency controls sample that current value before writing origins.

Only scalarTargets[4] is initialized alongside independent gain: quietest admission calls the gain ramp reader even without an active engine ramp. The zero-frame rule ignores dormant origin/start arithmetic but still requires that current target. Other scalar targets are only consumed after their own validated controls overwrite them; all ratio/frequency targets remain initialized. The gain-array reset, pool/layout bounds, fade traversal, prepared identity, raw own-data/numeric parsing and callback admission/terminal handling are unchanged.

All 615 tests pass. Two new public-consumer regressions compare fresh playback and subsequent partial controls after interrupted mixed ramps, and verify quietest stolen-ID/ownership after recycling a dirty independent-gain ramp, across all three qualities and 16000/48000 Hz. Final source/minified proofs each retain 198 lifecycle PCM pairs/12,017,424 exact bytes, 22 complete-workload pairs, 1344 exact refusal pairs, two independent accessor refusals with zero getter reads, reentrant replacement and fixed slot identity. Nine shapes, all algorithms, fixed-Hz/ratio switching, ADSR/release and panic/natural reuse remain covered.

Strict TypeScript checks, byte-identical generated public declarations, the 42-source/55-built security gate and zero runtime dependencies pass. Native Chromium 156.0.8078.4 AudioWorklet smoke passes at 48000 Hz with finite stereo/pan, complete lifecycle/context ownership and zero final DSP errors, rejections or pending events. Ancillary non-dist requests remain refused by its isolated allowlist fixture; no production control is relaxed. Local complete CPU controls do not establish physical allocation, retained-memory, GC-pause, native-browser speed or application deadlines. No format/API/dependency/formula change, release/publication approval, physical-device/MIDI or human-listening acceptance is claimed.

Scoped A/C review for Dormant voice-slot resets: the integration owner traced every read and activation of the existing four-operator edit/release state. noteOn() no longer fills envelopeStart, envelopeFromDb, releaseStarts, releaseDb or releaseStep with dormant defaults. envelopeEdited still clears and releaseTime still resets to −1; live ADSR edits and release initialize their origins/steps before activation. Same-patch coefficient-cache checks still consume the previous edit flags before clearing them. Dormant numeric cells are not promised to be zeroed; they do not affect an admitted note before overwrite.

No input reader, prepared identity, slot layout, allocation/pool policy, fade limit, callback traversal, output boundary or DSP formula changes. Strict own-data and numeric validation still precedes admission. All 613 tests pass, including existing edited/recycled sustain and reentrant error/steal/panic regressions. Source and minified comparisons each retain 198 lifecycle PCM pairs/9,255,264 exact bytes, sixteen complete-workload pairs, 1344 exact refusal pairs, two independent accessor refusals with zero getter reads and fixed slot conservation. Coverage includes all algorithms and operator shapes, live ADSR/release reuse, patch switches, natural retirement and reentrant replacement. Five generated public declarations remain byte-identical.

Strict TypeScript checks, the 42-source/55-built security gate and empty runtime dependencies pass. Real Chromium 156.0.8078.4 AudioWorklet smoke passes at 48000 Hz with finite stereo/pan signal, complete note lifecycle, context ownership/suspend/resume/restart and zero final DSP errors, rejections or pending events. Its isolated HTTP fixture rejects ancillary non-dist requests with 403; the native audio/lifecycle gate exits successfully. Local CPU measurements include all raw/render/edited-release controls and do not establish allocation, retained-memory, GC-pause, application deadline or universal render improvement. Physical-device/MIDI and human-listening acceptance remain unverified; this is not release/publication approval.

Scoped A/C review for Canonical voice JSON fragments: the integration owner traced the existing single weak per-voice memo and its immutable private-bank keys. Its value representation changes from canonical FrozenVoice graphs to canonical JSON strings, with no alias or second cache. Every miss still runs complete validateVoice, the unchanged owned/null-prototype copier and JSON.stringify. No raw caller text is inserted into the bank: only those complete internally formatted canonical values enter a fresh dense Array.from result.

Final assembly adds brackets only to existing own first/last slots of that private array, then joins the complete output; empty and single-entry registries retain exact array JSON. Caller arrays, owned voice graphs and weak-memo strings are not mutated, and inherited indexed setters cannot intercept existing own data slots. Export-history-based memo population, all invalidation/reentrant callers, raw admission, private prepared identity and sound-registration keys are unchanged. Count/disposal checks still precede cache lookup, and the aggregate ASCII byte budget precedes successful whole-bank text caching. Valid per-voice data can remain memoized while its key is reachable after an aggregate refusal, but oversized whole-bank text is never cached.

A standalone pre-edit assembly probe preserves 1292 canonical array pairs/1091337 ASCII bytes across all eight versions/algorithms, five raw/prepared/frozen/parsed/wrapped forms, both load/replace producers and seven numeric edges; four inherited Object/Array JSON-hook cases have zero reads. Final source/minified comparisons preserve all 504 hostile-field cold/warm wire pairs, canonical/mutation/descriptor/capacity/cache/isolation/raw traces and eighteen shared-identity pairs. The existing six indexed-accessor regressions also pass in source. Sixty-four workload phases compare complete bank outputs or dispatch IDs plus bounded diagnostics; actual native JSON.parse consumers remain inside the performance matrix. Separate twelve hook-independent program cases and 72 cross-build API/production-processor PCM pairs establish sound parity with the explicit software WebAudio fixture, not native AudioContext or audio-thread scheduling.

All 613 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependencies pass; facade/schema/normalizer/core declarations remain byte-identical. No public API/type/format/dependency, DSP formula or worklet protocol is changed. Collected-heap estimates, including the measured removal of downstream string-work samples from the final variant's top frames, are not physical object/allocated/retained-byte or GC-pause proof. Per-voice data still follows weak immutable keys; no retained-memory saving is claimed. No independent release/publication, native live AudioWorklet, physical-device/MIDI or listening acceptance is claimed.

Actual Chromium 156.0.8078.4 also preserves 504 hostile-field cold/warm pairs with zero getter/setter hits, eighteen shared-identity pairs, 3072 voice pairs/2275584 canonical bytes, complete raw/capacity/cache/mutation traces and 1024 prepared admission pairs. Twelve hook-independent cases and 72 additional PCM pairs execute the production API/processor on the explicit software fixture with zero page errors. Native live audio, browser rendering deadlines and physical-device/listening acceptance remain unverified.

Scoped A/C review for Literal-null JSON object destinations: the integration owner traced the owned JSON copier and the existing literal-array convention. Only its object destination changes to a fresh literal followed immediately by native Object.setPrototypeOf(result, null). No caller reference or callback can reach that fresh empty object before its prototype is cleared; every dynamic key write and recursive copy still follows the null-prototype operation. The untrusted raw snapshot record continues to use its original Object.create(null) construction.

Existing own-key ordering/data descriptors, null prototypes and inherited setter/toJSON isolation remain intact. Raw descriptor/prototype/type/finite/version/range validation, refusal/callback order, private prepared identity, canonical memo, registration identity and disposed/count/byte guards are unchanged. No new state, cache, retained graph layer, trust producer, public API/type/format/dependency, DSP formula or worklet protocol is introduced.

Source and minified comparisons each preserve 504 complete cold/warm wire pairs under 42 inherited named fields in getter/setter/data forms, with zero getter/setter hits. Existing canonical/mutation/descriptor/capacity/cache/isolation/raw-trace and eighteen shared-identity comparisons pass. A separate standalone construction diagnostic preserves 256 complete graphs and all own descriptors over 3072 object nodes; native V8 fast-property flags are diagnostic only, not consumer speed, product-intermediate inspection or physical allocation proof. Sixty-four alternating workload phases compare complete bank outputs or dispatch IDs plus bounded diagnostics; separate twelve hook-independent program cases and 72 cross-build API/production-processor PCM pairs establish sound parity with the explicit software WebAudio fixture, not native AudioContext or audio-thread scheduling.

All 613 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependencies pass; facade/schema/normalizer/core declarations remain byte-identical. Native collected-heap samples estimate whole-tree allocation pressure, not physical object types, physical allocated/retained bytes or GC counts. No independent release/publication, native live AudioWorklet, physical-device/MIDI or listening acceptance is claimed.

Chromium 156.0.8078.4 modules pass all 504 hostile-field wire pairs, eighteen shared-identity pairs, twelve hook-independent program cases, 72 cross-build API/production-processor PCM pairs and existing pure bank/prepared/captured-data/capacity/cache/isolation/raw-reflection comparisons, with zero page errors. The processor platform is explicitly the software fixture; no native AudioContext or audio thread is started.

Scoped A/C review for Owned JSON data reads: the integration owner traced both non-recursive bankJsonData callers and their nested producers. Canonical export entries are existing fully validated FrozenVoice outputs or their private immutable memo values; registration patches come from strict frozenPatch admission or private registry lookup. Normalizer, schema, key-scale and pitch-envelope producers construct fresh own-data literals, then preparation/parsing freezes their graphs. The export wrapper is a fresh private dense array. Direct reads are restricted to existing Object.keys of these owned objects, replacing per-field descriptor creation without consulting inherited or caller-owned properties.

All raw descriptor/prototype/type/finite/version/range validation, callback and refusal ordering, private prepared identity checks and caller-independent ownership remain before this helper. Array copying, null-prototype destinations, canonical key order, registration identity, inherited JSON-hook isolation, registry/cache invalidation and disposed/count/byte guards are unchanged. No new trust marker, producer, cache, retained graph layer, public API/type/format/dependency, DSP formula or worklet protocol is introduced.

Source and minified comparisons each preserve 504 complete cold/warm wire pairs under 42 inherited named fields in getter/setter/data forms, with zero getter/setter hits and all hooks restored. Constructor, prepared, renamed and parsed producers are exercised. Existing canonical/mutation/descriptor/capacity/cache/isolation/raw-trace and eighteen shared-identity comparisons also pass. Sixty-four alternating workload phases compare complete bank outputs or dispatch IDs plus bounded cancellation diagnostics; dispatch IDs are not musical PCM. Separate twelve hook-independent program cases and 72 cross-build API/production-processor PCM pairs establish sound parity with the explicit software WebAudio fixture, not native AudioContext or audio-thread scheduling.

All 613 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependencies pass; facade/schema/normalizer/core declarations remain byte-identical. Native collected-heap samples estimate whole-tree allocation pressure, not physical object types, physical allocated/retained bytes or GC counts. No independent release/publication, native live AudioWorklet, physical-device/MIDI or listening acceptance is claimed.

Chromium 156.0.8078.4 modules pass all 504 hostile-field wire pairs, eighteen shared-identity pairs, twelve hook-independent program cases, 72 cross-build API/production-processor PCM pairs and existing pure bank/prepared/captured-data/capacity/cache/isolation/raw-reflection comparisons, with zero page errors. The processor platform is explicitly the software fixture; no native AudioContext or audio thread is started.

Scoped A/C review for Immutable patch export snapshots: the integration owner traced constructor, strict load/rename and parsed replacement producers. Only their deeply frozen private-bank patches key the new weak memo, whose values are existing fully validated canonical FrozenVoice outputs. Raw inputs, frozen lookalikes and wrappers still take the same admission validation; no new trust brand or producer is introduced. Defensive registry copies cannot change membership, and renamed roots have independent identities.

Committed loads and successful removals invalidate whole-bank text by retaining an existing cache entry as undefined. This marker records export history only, deferring new per-patch memo population for first-time registries; it does not authorize input. Replacement/clear still create new map identities, and disposal deletes the whole-map entry and rejects before lookup. Cold misses retain complete canonical validation, every cold output uses the unchanged null-prototype JSON copier, and disposed/count/byte guards and serialization-hook isolation remain intact. Oversized text is never cached; valid per-patch data can remain memoized while its immutable key is reachable. No retained-memory or GC-pause improvement is claimed.

Source and minified comparisons preserve canonical bytes, detached/frozen graphs, malformed-input refusals, complete raw descriptor traces, capacity/cache isolation and reentrant metadata semantics. Eighteen additional complete-wire pairs cover cross-host shared prepared identities, renames/removals/readds, parser copies, an inner export during validation and frozen forgery refusals. The permanent consumer regression checks exact canonical output and independent host membership. All 64 alternating complete workload-wire pairs, twelve hook-independent program cases and 72 cross-build API/production-processor PCM pairs also pass with the explicitly identified software WebAudio fixture, not native AudioContext or audio-thread scheduling.

All 613 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependencies pass; facade/schema/normalizer/core declarations remain byte-identical. No public API/type/format/dependency, DSP formula or worklet protocol is changed. Native collected-heap sampling estimates whole-tree allocation pressure, not physical object types, physical allocated/retained bytes or GC counts. No independent release/publication, native live AudioWorklet, physical-device/MIDI or listening acceptance is claimed.

Chromium 156.0.8078.4 modules pass all eighteen shared-identity wire pairs, twelve hook-independent program cases, 72 cross-build API/production-processor PCM pairs and existing pure bank/prepared/captured-data/capacity/cache/isolation/raw-reflection comparisons, with zero page errors. The processor platform is explicitly the software fixture; no native AudioContext or audio thread is started.

Scoped A/C review for Indexed numeric bounds: the integration owner traced the two private numeric helpers in voice normalization and bank validation. Each now captures the existing module-defined readonly two-number LIMITS tuple once and reads slots 0/1 directly, replacing destructuring or trailing-argument spread. The outer record is frozen; tuple construction and runtime mutability are unchanged, and deeply frozen tuples are not newly claimed. Values are read anew per call, with no cross-call bounds cache.

All existing type/finite/range guards, finite-only Math.min/Math.max clamping, integer/enum rules, descriptor captures, bounded raw traversal, private prepared producers, registry capacity and serialization-hook protections remain unchanged. No public API/type/format/dependency, DSP formula or worklet protocol is changed. Indexing this module-owned pair does not bypass checks on caller-owned voice arrays.

Source and minified comparisons each preserve 2184 numeric-edge pairs across all 26 bounds: exact error classes/messages, strict rejection versus bank clamping, negative zero, malformed types, non-finite values and hostile numeric/accessor inputs; getter and coercion counts remain zero. Existing complete voice/bank/descriptor/alias, prepared admission, captured-data, capacity/cache/isolation, metadata and 64 alternating workload-wire comparisons also match. All twelve hook-independent program cases and 72 cross-build API/production-processor PCM pairs pass using the explicitly identified software WebAudio fixture, not native AudioContext or audio-thread scheduling.

All 612 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependencies pass; facade/schema/normalizer/core declarations remain byte-identical. Native collected-heap samples estimate whole-tree reductions, not physical object types, allocation/retention bytes or GC counts. No independent release/publication, native live AudioWorklet, physical-device/MIDI or listening acceptance is claimed.

Chromium 156.0.8078.4 modules pass all 2184 numeric-edge pairs, twelve hook-independent program cases and 72 cross-build API/production-processor PCM pairs with the explicit software fixture. Existing pure bank/prepared/captured-data/capacity/cache/isolation and metadata comparisons also pass, with zero page errors. Native AudioContext and audio-thread scheduling are not exercised.

Scoped A/C review for Hook-independent patch registration: the integration owner traced both raw and named key producers and the existing per-host immutable-patch WeakMap. Both now converge on one cache miss that serializes the existing owned-data/null-prototype JSON copier. Inherited Object/Array toJSON functions/getters cannot choose program identity, collide registrations or interrupt admission. Raw inputs still normalize into fresh frozen ownership before every lookup; only existing genuine immutable identities reuse keys. No new cache, trust flag/producer, untrusted metadata query, public API/type/format/dependency, DSP math or worklet protocol/validation change is introduced.

The old source/minified builds each failed all twelve production API/processor software-context cases: six function-hook cases rendered the wrong PCM and six getter-hook cases threw before admission. Cases span Object/Array prototypes and named edits, raw voices and genuine prepared voices; hook-free references are audible. Each repaired build now passes all twelve with zero hook reads, no exceptions and bit-identical reference PCM over 6144 stereo frames. The permanent consumer regression exercises these same cases, not source text or message wiring.

Seventy-two additional source/minified cross-build API/processor PCM pairs preserve 36864 stereo frames across all algorithms, versions 1/5/8, named/raw/prepared inputs and immediate/future/repeated programs. Existing bank, prepared admission, captured-data, capacity/cache/isolation and full raw/prepared metadata comparisons remain unchanged. The tests use an explicit software WebAudio platform fixture with synchronous structured-clone ports and the actual production processor; they are not native AudioContext, audio-thread scheduling or physical-device/listening acceptance.

All 612 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependencies pass; facade/schema/normalizer/core declarations remain byte-identical. Whole-consumer timings record cold raw/clone/wrapper serialization costs as well as prepared-key reuse and unrelated bank/core controls. Correct sound registration is retained regardless of those costs; no universal speedup, browser audio deadline, independent release or publication approval is claimed.

Chromium 156.0.8078.4 modules pass all twelve repaired hook cases and 72 cross-build API/production-processor PCM pairs with the explicit software platform fixture. Existing pure bank/prepared/captured-data/capacity/cache/isolation and metadata comparisons also pass, with zero page errors. Native AudioContext and audio-thread scheduling are not exercised.

Scoped A/C review for Prepared facade admission: the integration owner traced constructor/default, load and direct-play callers of frozenPatch. Its import/call now reuses the existing preparedVoiceValue helper already used by Synth and sequence admission. The private WeakSet and its producers are unchanged: only fully validated, deeply frozen owned snapshots qualify, never an Object.isFrozen result, public flag, cloned shape or Proxy wrapper. Ordinary raw, frozen-clone, parsed-unbranded and wrapped inputs still take full existing prepareVoice normalization. Public prepareVoice/normalizeVoice contracts, post-validation capacity checks and post-commit bank-cache invalidation remain unchanged.

Matching-name genuine prepared inputs can share the existing immutable snapshot; renaming still defines/freezes a new root sharing only immutable descendants, without registering another trusted producer. Raw mutable caller state remains detached, failed frozen clones/wrappers cannot change the bank, and normalizing a prepared input still creates independent mutable envelopes/expressive data. The focused consumer regression checks both matching and renamed inputs, nested immutability/detachment, an invalid frozen clone and a wrapper whose metadata throws. No new cache, trust flag, producer identity, metadata query, public type/API/format/dependency, DSP arithmetic or worklet validation shortcut is introduced.

Native source/minified comparisons each preserve 1024 complete prepared/frozen-clone/wrapped/parsed admission pairs across every legacy version, algorithm, minimal/full shape and matching/renamed registry name, including 6048 unfiltered root metadata events, 512 caller-copy detachment checks and 16 additional bit-identical PCM pairs/15248 stereo frames. Existing bank/captured-data/capacity/cache/isolation and all 128 raw load/reflection pairs/30352 caller events also remain unchanged. This is scoped integration-owner A/C review, not independent release/publication approval or live AudioWorklet, physical-device/MIDI or listening acceptance.

All 611 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependency listing pass. Facade/schema/normalizer/core declarations are byte-identical. Fixed-count native sampling of 131072 alternating genuine prepared minimal loads with defensive map reads estimates 1683929768 to 73493344 bytes across the collected allocation tree (95.64% reduction); this includes common runtime/profiling work, not physical allocation, object-type, heap-retention or GC-count evidence. Private normalizer frames disappear from the candidate sampled tree while defensive map/iterator frames remain. Whole-consumer timings distinguish these prepared loads from raw/frozen, bank/export, mutable-normalizer and DSP controls.

Chromium 156.0.8078.4 native modules pass the same 1024 prepared admission pairs/6048 root events/512 detachment checks and 16 additional PCM pairs, plus all existing captured-data, bank, capacity, cache/isolation and raw-reflection comparisons. There are zero page errors and no AudioContext is started; this does not establish live AudioWorklet or listening acceptance.

Scoped A/C review for Immutable bank export cache: the integration owner traced the constructor, private prepared/renamed and parsed deeply frozen producers, all bank writers and defensive voices snapshots. Only owned native registry maps key a module-private weak cache, never raw caller input or a caller-supplied flag. A hit returns an already bounded ASCII primitive string after the disposed/capacity guards. Misses retain complete validation, null-prototype JSON copying and the UTF-8 limit, storing only successful output. This relies on supported bank methods and native intrinsics, not a sandbox against arbitrary host-JavaScript mutation of private state.

Successful in-place loads invalidate after raw validation callbacks, the current-map capacity guard and the final set, so a nested export cannot leave an intermediate cached bank. Successful removals invalidate; no-op/failed edits preserve valid current content, including caller-approved nested changes. Replacement and clear select new map identities, and dispose removes the current entry. Each owned map has at most one successful export string of at most 256 KiB; weak keys do not keep replaced maps alive. No new mutable exported graph, public type/API/format/dependency, raw descriptor query, trust identity for untrusted input or DSP arithmetic change is introduced.

Source and minified comparisons each preserve 38 complete history-wire pairs: four histories per build cover empty/1/8/128-voice banks, defensive map edits, overwrite/remove/no-op/replace/clear and repeated exports. Five reentrant cases per build cover nested mutation/replacement/clear/export, raw validation failure and post-validation capacity refusal. Getter/function inherited JSON hooks remain uncalled on warm and newly invalidated exports. Repeated oversized exports reject before caching; disposal rejects even after a successful cached export. All 128 complete load/reflection pairs/30352 raw caller events remain unchanged, unfiltered.

Four additional independent-host wire pairs prove that warming, mutating, removing or disposing one host cannot return or invalidate another host's bank. All sixteen timing workloads additionally compare four complete alternating output phases outside timing (64 wire pairs per source/minified comparison). Chromium 156.0.8078.4 native modules pass the complete history/isolation, captured-data, capacity, unfiltered reflection and bit-identical PCM comparisons with zero page errors and no AudioContext.

Each source/minified comparison also preserves 3072 voice pairs/2275584 canonical ASCII bytes, 12 bank/facade pairs/580 voices, 24 bit-identical PCM pairs/30060 stereo frames, 77 ordinary refusal pairs, descriptor/alias graphs, detached mutations, all 18 captured-data cases and post-validation capacity behavior. All 610 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependencies pass; facade/schema/normalizer/core declarations are byte-identical. This is integration-owner A/C review, not independent release/publication approval, physical-device/MIDI or listening acceptance. Matched whole-consumer results in CHANGELOG distinguish unchanged-bank cache hits from cold/invalidation/load and unrelated DSP controls; no physical allocation/GC count or deadline guarantee is claimed.

Scoped A/C review for Post-validation bank capacity: the integration owner traced constructor, private prepared/renamed and parsed owned-frozen producers, defensive registry snapshots and every bank writer. Raw normalization metadata can synchronously reenter load/remove/replace. The original early capacity guard remains; after frozenPatch, loading captures the current native registry, checks name presence/capacity again and commits to that same map. This closes the validation-to-commit gap without another raw descriptor query or a new trust identity, cache, API/type/format/dependency or DSP arithmetic change.

All three old source/minified public reproductions admitted a 129th voice: filling the existing bank, replacing its map and exchanging a previously present outer name during validation. They now reject with 128 voices and no outer insertion, retaining caller-approved nested mutations. The consumer regression covers all three refusals plus legal remaining-slot and full-bank existing-name replacement. Native source/minified/browser proofs additionally accept a commit into a newly cleared registry, preserve early full-bank rejection without raw metadata reads, and retain raw numeric-error priority. All 128 complete load/reflection pairs and 30352 caller input events match exactly, without filtering.

Source, minified and Chromium 156.0.8078.4 modules each preserve 3072 voice pairs/2275584 canonical ASCII bytes, 12 bank/facade pairs/580 voices, 24 bit-identical PCM pairs/30060 stereo frames, 77 ordinary refusal pairs, descriptor/alias graphs, detached mutations and all 18 prior captured-data/bounds/atomicity cases. The normalizer, schema, worklet and DSP source remain unchanged. Twelve whole-consumer timing controls against a2384cc include raw/frozen/prepared, renamed and full-bank loads with defensive map reads; all costs and unrelated controls are retained in CHANGELOG, with no acceleration claim for this correctness fix.

All 609 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependency listing pass. Public facade/schema/normalizer/core declarations are byte-identical. Chromium reports zero page errors without starting an AudioContext. This is scoped integration-owner A/C review, not independent release/publication approval or live AudioWorklet, physical-device/MIDI or listening acceptance.

Scoped A/C review for Captured voice-bank data: the integration owner traced complete-voice and nested LFO/operator/ADSR/key-scale/pitch-envelope records, bank/operator/target arrays, facade replacement/export and renderNote admission. Shape checks and subsequent copying now share captured own-data descriptor values; null-prototype intermediate records prevent inherited setter interception. Array length is a captured bounded integer; native own-key arrays supply owned dense cells for checked values before child validation. Required/unknown-field, legacy, enum, finite-value/clamping and detached deep-freezing rules remain. No trust shortcut, cache, public API/type/format/dependency or DSP arithmetic changes. Proxy metadata callbacks can still execute caller code; this is not a sandbox.

The previous source and minified builds both consumed late root accessors, accepted an invalid substituted name, coerced a substituted version and traversed a supposedly one-entry bank into 129 entries. The facade's existing outer-array capture was already bounded; complete-voice validation was still affected. Seven original reproductions per build now retain the captured values with zero caller getters/coercions and one bank entry. Six permanent consumer regressions additionally cover late root/operator/bank slots, changing length/version and LFO target descriptors across strict and normalized consumers.

Source, minified and Chromium 156.0.8078.4 native modules each preserve 3072 voice pairs/2275584 canonical ASCII bytes, 12 bank/facade pairs/580 voices, 24 bit-identical PCM pairs/30060 stereo frames, 77 ordinary refusal pairs, descriptor/alias graphs and detached mutations. Each current build passes 18 late-mutation/bounds/facade-atomicity cases with zero getters/coercions. Strict observed raw property reads intentionally fall from 29776 to zero; normalizer observations fall from 1536 to 384 because LFO target arrays now use captured length/slots. These are intentional reflection changes, not an assertion of unchanged Proxy traces. Native own-data guards and all scalar/version checks remain.

All 608 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and empty runtime dependency listing pass. Public schema, normalizer, facade and core declarations are byte-identical. Native collected-allocation sampling estimates 23.8% more schema-attributed allocation for the complete mixed-bank workload; this includes collected temporaries and is not retained/peak heap, object-type/count or GC-frequency evidence. The full source/minified timing controls and correctness cost are recorded in CHANGELOG rather than presented as a universal speedup.

Chromium reports zero page errors without starting an AudioContext. This is scoped integration-owner A/C review, not independent release/publication approval or live AudioWorklet, physical-device/MIDI or listening acceptance.

Scoped A/C review for Private prepared operator slots: the integration owner traced the sole private prepared root registration, native array literal and dense own placeholders, four validated copied operators, descendant/array/root freezing and unforgeable WeakSet membership. Only those immutable native producer slots use direct indexed reads. They cannot become accessors, caller Proxies, missing cells or inherited lookups after registration. Every nonregistered raw, frozen, forged or Proxy-wrapped root keeps the original native own-data slot descriptor path and raw array shape scan. Array type/length, every captured field/name/version and scalar/legacy rule, fresh detached construction, deep freezing and registration remain unchanged. No new trust, flag arguments, helper convention, dependency, public declaration, format, worklet or DSP rule is introduced. Ordinary indexed/prototype getters remain covered; rebinding language intrinsics or a hostile JavaScript host is not a sandbox guarantee.

Source and minified modules each prove 17 immutable producer-tuple pairs, 136 own frozen data-slot descriptors, 17 blocked-mutation and detached-copy pairs and 36 malformed raw/frozen/Proxy/frozen-Proxy consumer pairs with zero caller getters. Each also preserves 1080 valid voice pairs/1022400 canonical bytes, 16 bit-identical PCM pairs/19875 stereo frames, 57 existing refusals, all 72 exact raw root/nested/array reflection traces, 45 ordinary-prototype cases, six signed-zero graphs, two mutation workflows, 24 captured-field/name refusals and 45 strict version cases. No raw reflection event is filtered or projected. The 53 complete project workflows, 102 descriptor/alias graphs, 28 project refusals, 12 JSON-hook cases and 190 UTF-8 compatibility records match. Existing owned/frozen-slot, private identity, detached-copy and raw rejection tests cover the branch; no wiring-only test is added.

Chromium 156.0.8078.4 native modules preserve 36 project pairs/391470 bytes/2736 events, six JSON-hook cases, 360 voice pairs/300600 bytes, ten bit-identical PCM pairs/12525 stereo frames and all raw reflection, version, prototype, signed-zero, ownership and refusal controls with zero page errors. No AudioContext is started. This is scoped integration-owner A/C review, not independent release/publication approval or live AudioWorklet, physical-device/MIDI or listening acceptance.

All 602 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and the empty runtime-dependency listing pass. Public normalizer declarations are byte-identical. Both complete seventeen-profile timing matrices retain both orders against ab708e0, including the source one-note project slowdown, minified raw/forged negatives and varying identity controls. Only private-copy benefits are claimed; no universal raw/project/synthesis acceleration, physical heap/GC counts or deadline guarantee is inferred.

Scoped A/C review for Private prepared operator arrays: the integration owner traced the sole preparedVoices registration back through all normalization, captured own-data/slot/scalar/version checks and producer freezing. normalizeVoice creates an owned dense native four-slot array; prepareVoice freezes its owned operators, ADSR/key-scale children, array and root before private registration. The new !known guard skips only Reflect.ownKeys on that immutable producer array. Array type/length, native own-data slot reads, all scalar checks and fresh copies remain. Structural shape, Object.isFrozen, public brands and Proxy wrappers do not grant trust; every nonregistered root keeps the original key enumeration. No new cache, collection, identity mechanism, flag convention, declaration, format, worklet boundary, dependency or DSP rule is introduced.

Both source and minified modules prove 17 immutable producer-tuple pairs, including raw Array-subclass input becoming an owned native array, 136 own frozen slot descriptors, 17 blocked-mutation and detached-copy pairs and 36 malformed raw/frozen/Proxy/frozen-Proxy consumer pairs with zero caller getters. Each build additionally preserves 1080 voice pairs/1022400 canonical bytes, 16 bit-identical PCM pairs/19875 stereo frames, 57 existing refusals, all 72 exact raw root/nested/array reflection traces, 45 ordinary-prototype cases, six signed-zero graphs, two mutation workflows, all 24 captured-field/name refusal controls and 45 strict version cases. No raw trace projection or filtered event is used. The 53 complete project workflows, 102 descriptor/alias graphs, 28 project refusals, 12 JSON-hook cases and 190 UTF-8 compatibility records remain unchanged. Existing raw-slot, private identity and detached-copy consumer tests cover the branch; no implementation-wiring test is added.

Chromium 156.0.8078.4 native modules preserve 36 project pairs/391470 bytes/2736 events, six JSON-hook cases, 360 voice pairs/300600 bytes and ten bit-identical PCM pairs/12525 stereo frames, plus the full raw reflection, version, prototype, signed-zero, ownership and refusal controls with zero page errors. No AudioContext is started. This is scoped integration-owner A/C review, not independent release/publication approval or live AudioWorklet, physical-device/MIDI or listening acceptance.

All 602 tests, strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and the empty runtime-dependency listing pass. Public normalizer declarations are byte-identical. Both complete seventeen-profile timing matrices retain both orders against hardened commit 18138a7. Private-copy gains do not erase source constructor or minified raw-map/facade/Proxy tradeoffs, all published in the CHANGELOG; no universal acceleration, heap/GC or deadline guarantee is claimed.

Scoped A/C review for Captured own-data voice fields: the integration owner traced normalizeVoice(), prepareVoice(), preparedVoiceValue(), the sole private prepared registration, nested copies and freezing. A caller JavaScript Proxy could replace a previously checked data field with an accessor whose native descriptor inherited an ordinary Object.prototype.value getter. A separate optional-name gate could accept a captured caller-owned object when a later descriptor reported absence, even registering the malformed result as a trusted prepared voice. The field reader now checks the data kind on the same native descriptor it uses; name presence, type and value likewise use one descriptor. No extra caller query, intermediate node snapshot, trust/cache mechanism, flag convention, public declaration, format, dependency, worklet boundary or DSP change is introduced. This is per-read validation, not a whole-graph atomic snapshot or a sandbox preventing caller Proxy traps from running JavaScript.

Source and minified modules each reject all 21 later-accessor cases and three hidden-invalid-name cases without inherited descriptor-value or caller-field getter reads. Each preserves 1080 valid voice pairs/1022400 canonical bytes, 16 PCM pairs/19875 stereo frames, 57 existing refusals, 12 root and 60 nested/array Proxy pairs, 45 ordinary-prototype cases, six signed-zero graphs and two detached-mutation workflows. All original reflection events and order remain except exactly one obsolete optional-name presence query per observed root. Existing strict version admission remains unchanged across 39 plain and six changing-descriptor cases. Each build also preserves 53 complete project workflows/16635660 bytes, 102 descriptor/alias graphs, 28 refusals, 12 JSON-hook cases and all 190 UTF-8 compatibility records; facade controls receive zero inherited hooks.

Chromium 156.0.8078.4 native modules independently reproduce all 24 old failures and verify all 24 new TypeError refusals with zero inherited descriptor-value reads, caller-field getter reads or page errors. They additionally preserve 36 project pairs/391470 bytes/2736 events, six legacy JSON-hook cases, 360 voice pairs/300600 bytes, ten PCM pairs/12525 stereo frames and the complete reflection, version, signed-zero, prototype and detached-copy controls. No AudioContext is started. This scoped integration-owner A/C review is not independent release/publication approval or evidence of live AudioWorklet continuity, physical-device/MIDI or listening acceptance.

All 602 tests pass, together with strict source/development/public/core-only TypeScript checks, the 42-source/55-built security gate and the empty runtime-dependency listing. The generated public normalizer declaration is byte-identical. Complete source/minified timings retain all seventeen workloads and both orders, including the added per-read validation cost; no broad acceleration, heap/GC or deadline claim is made.

Scoped A/C review for UTF-8 project byte budgets: the integration owner traced all four project parse/serialize exports, raw-text admission, normalized voice snapshots, both final bounded JSON passes, inherited Object/Array hook behavior and the facade's separate null-prototype bank copier. Only a private predicate is shared: UTF-16 length is a lower bound on native UTF-8 bytes and three times it is an upper bound; near-cap strings receive native TextEncoder measurement. Output checks inspect the actual serialized string rather than assuming normalized ASCII survives inherited hooks. No new prototype probe, character scan, trusted identity, cache, data accessor read, format, declaration, dependency or DSP rule is introduced. Original JSON passes and within-budget output/reflection order remain, including self-deleting hooks and an Array-prototype Proxy whose has/get reports disagree. Oversized Unicode results intentionally fail earlier with the existing budget RangeError; JSON syntax and original raw-text byte-error priority remain. JavaScript caller hooks/Proxy traps are not a sandboxed input and are not suppressed.

Source and minified proofs each preserve 47 project workflows/16608564 canonical bytes, 90 descriptor/alias graphs, 28 refusals, 12 legacy JSON-hook cases, two mutable workflows and zero caller data-getter reads. Each actual UTF-8 matrix preserves 84 exact-limit cases and 32 existing overflow refusals with 116 matching traces; 52 Unicode/adversarial oversized results intentionally reject, with observed hook traces ending at the earlier rejection. Twenty-two raw-input pairs preserve exact-limit ASCII admission and 18 refusals, including final U+2028/U+2029, astral characters and lone-surrogate bounds. Two bank-export controls match with zero inherited hooks; its existing null-prototype isolation is unchanged. Ordinary Object/Array properties are not waived as a same-realm exception; native-intrinsic replacement is not claimed. Two isolated consumer-visible regressions exercise all four project APIs and both hook families, and the existing raw-boundary test covers final Unicode line separators.

Chromium 156.0.8078.4 native modules additionally preserve 36 project pairs/391470 bytes/2736 events and six legacy hook cases, plus the same 190 actual UTF-8/adversarial records and zero page errors. No AudioContext is started. This scoped integration-owner A/C review is not independent release/publication approval, a whole-page resource quota or evidence of live AudioWorklet continuity, physical-device/MIDI or listening acceptance.

All 600 tests pass, together with TypeScript/public/core-only declaration checks, the 42-source/55-built security gate and the empty runtime-dependency listing. The generated public project declaration is byte-identical.

Scoped A/C review for exact-alias render admission: the integration owner traced captured native typed-array kind/length/fill intrinsics, the render entry's reentrancy and numeric/both-buffer bounds, idle clearing, all public and worklet/offline render callers, and the existing same-output WAV-view reuse convention. Only exact object identity reuses native metadata within this call. Distinct views always validate independently even when backing storage or offsets overlap. A Float32Array's element kind cannot change; captured native getters invoke no caller metadata accessors. Resizable buffers cannot synchronously shrink between these callback-free getters, while growable shared buffers cannot shrink and the original left-length snapshot already bounds both writes. No cross-call cache, structural/prototype brand, trust API, additional persistent state, format/declaration or DSP numerical change is introduced. Error priority, callback/reentrancy guards, source ownership and left/right write semantics remain; same output is not mono downmix.

Source and minified proofs each preserve 2969 lifecycles/109971 checkpoints/24368337 stereo frames, including 480 mapping cases, 9600 aliased blocks and 2345568 negative-zero samples, with exact PCM, every DSP scalar, own-data descriptors/alias graphs and typed DSP bytes. Opaque callables compare arity and alias identity, not minifier-dependent names or function source. Each build matches 50 native-boundary pairs with 22 refusals, six across-call resize/growth pairs and two additional retirement/reentrancy callback pairs; shadow metadata/fill/tag getters, subclasses, cross-realm arrays, detached/RAB/GSAB cases and distinct overlapping views retain exact state/buffers with zero caller getter reads or numeric coercions. Ordinary Object/Array properties are not waived as a same-realm exception. Concurrent GSAB timing and native-intrinsic replacement are not measured or claimed.

Chromium 156.0.8078.4 native ES modules additionally preserve 216 paired pure-DSP lifecycles, 3456 full-state checkpoints and 442368 stereo frames, including 1152 exact-alias blocks, four shadow-metadata pairs and three atomic malformed-input refusals. All eight algorithms, three mapped rate/quality settings, sine/mixed/noise shapes, same/distinct/overlapping views, voice pan, release and readmission agree. No AudioContext is started; this is not live audio, AudioWorklet continuity, physical-device/MIDI or listening acceptance. All 598 tests, TypeScript/public/core-only checks, the 42-source/55-built security gate and the empty runtime-dependency listing pass. This scoped integration-owner A/C review is not independent release/publication approval.

Scoped A/C review for atomic voice version snapshots: the integration owner traced strict normalization, every version gate, the own-data shape scan and descriptor helper contrast, private prepared registration/deep freezing, and facade/core/project consumers. The same native own-property descriptor snapshot now supplies version validation and use. A present accessor rejects before reading its inherited descriptor-value property; an invalid object cannot pass validation using a later Proxy-reported scalar. Missing version alone defaults to 8. Every original enum/range/tuple/optional-field guard, fresh-copy boundary, prepared identity and DSP state rule remains; no new trust, cache, format or dependency is introduced. Transparent Proxy admission intentionally removes only duplicate version queries after the structural scan; other reflection ordering is unchanged.

Source and minified proofs each preserve 1080 voice value/descriptor/alias pairs and 1022400 JSON bytes, 16 bit-exact pure-DSP pairs and 19875 stereo frames, 57 existing refusals, nine adjusted Proxy traces, 45 ordinary prototype cases and two mutable-copy workflows. Project consumers preserve 44 workflows/4048548 JSON bytes, 84 descriptor/alias graphs, 28 refusals, 12 inherited JSON-hook cases and two mutation workflows. Thirty-nine ordinary version cases agree across all three conversion APIs; six intentional stricter refusals eliminate 48 numeric coercions and six inherited descriptor-value getter reads from the extended fixtures, with zero own getter calls. Ordinary Object/Array properties are not waived as a same-realm exception. Two isolated permanent regressions protect both bugs, and the public normalizer declaration is byte-identical.

Chromium 156 native modules additionally preserve 360 voice pairs/300600 JSON bytes, ten pure-DSP pairs/12525 stereo frames, two mutation workflows, and 36 project pairs/391470 JSON bytes/2736 events with six JSON-hook cases, plus the same 39 ordinary version results and six stricter refusals without new coercions or inherited descriptor-value reads. This is one discriminator snapshot, not a claim of atomic reflection for every field, a separate bank-validator audit, or a general guarantee that caller Proxy traps/trap-result conversion cannot execute JavaScript. Unrelated indexed-bookkeeping ownership and native-intrinsic replacement remain outside this scoped proof. This integration-owner A/C review is not independent release/publication approval or evidence of live audio, physical-device/MIDI or listening acceptance.

All 598 tests pass, together with TypeScript/public/core-only declaration checks, the 42-source/55-built security gate and the empty runtime-dependency listing.

Scoped A/C review for canonical facade prepared snapshots: the integration owner traced every private frozenPatch caller (default construction, loadVoice and raw playNote), the existing prepareVoice producer and its sole post-validation/deep-freeze registration, descriptor-based input reads, registry replacement and downstream score/Synth/worker ownership. Only the existing producer can register a fresh detached immutable root. No override, or a matching own canonical name, preserves its producer identity; the own-name gate precedes any optional name read, so an inherited getter cannot suppress a registry override. Missing/different names use a fresh spread defining own data and freeze the transformed root without granting membership. Every raw call still validates and detaches; no merely frozen, cloned, forged or proxied input gains trust. replaceVoiceBank, public signatures, content-key registration, wire values, structured-clone revalidation, per-note live state and sound math remain unchanged. Canonical immutable score aliases intentionally share under the existing documented contract; this review does not falsely claim identical cross-note alias multiplicity. No new cache, brand, collection or unsafe registration API is introduced.

Source and minified proofs each preserve 720 bank/input-output-graph pairs and 1008240 JSON bytes, 1440 short/long score pairs and 3127200 JSON bytes with exact per-event descriptors and explicit shared-versus-detached ownership, 48 bit-exact pure-DSP pairs and 90336 stereo frames with zero error diagnostics, two default-bank flows, 28 matching atomic refusals, 24 named ordinary prototype cases, six JSON-hook cases and two mutation lifecycles. Caller getter reads and unexpected prototype callbacks remain zero; ordinary Object/Array properties are not waived as a same-realm exception. Chromium 156 preserves 288 bank pairs/383964 bytes, 576 score pairs/1173552 bytes and 24 pure-DSP pairs/45600 stereo frames, plus default, name-getter, JSON-hook and mutation flows, without starting live audio. All 596 tests, type/public/core-only declaration checks, the 42-source/55-built security gate and the empty runtime-dependency listing pass; the facade public declaration remains byte-identical. The narrow review does not establish unrelated indexed-bookkeeping ownership or native intrinsic replacement safety. This scoped integration-owner A/C review is not independent release/publication approval or physical-device/MIDI/human-listening acceptance.

Scoped A/C review for prepared voice shape reuse: the integration owner traced every normalizer caller, the original private preparedVoices WeakSet and its sole post-freeze registration, all own-data clone construction and nested freezing. Only an exact existing producer root and its own frozen children may skip repeated plain-object shape scans; no raw/frozen/copied/proxied input, structural marker or external child is newly trusted. Every field descriptor read and numeric/version/enum/tuple/optional-own check remains. Output construction is unchanged, preserving fresh editable normalization and separately frozen preparation, rather than returning or shallow-copying the input. Native reflection over these known detached own-data objects has no ordinary prototype callbacks under the declared native-intrinsic assumptions. No new cache, trust brand, surface, public declaration, format, dependency, numerical expression or DSP loop is introduced.

Source and minified proofs each preserve 1080 value/descriptor/input-output-alias pairs and 1022400 JSON bytes, 16 pure-DSP pairs and 19875 stereo frames with zero diagnostics, 57 matching refusals, six Proxy read-order pairs, 45 ordinary prototype cases and two mutable-copy lifecycles. Whole project proofs each preserve 42 canonical cases and 4048548 JSON bytes, 84 descriptor/alias graphs, 28 refusals, two mutable-input workflows and 12 JSON-hook cases. Chromium 156 native ES modules preserve 360 voice pairs and 300600 JSON bytes, ten pure-DSP pairs and 12525 stereo frames, two mutable-copy workflows, and 36 project pairs with 391470 JSON bytes, 2736 events and six JSON-hook cases. All 596 tests, type/security checks and the empty runtime-dependency listing pass. A permanent regression preserves mutable normalized copies of prepared envelopes and expressive objects. This scoped integration-owner A/C review is not independent release/publication approval or evidence of live audio, physical MIDI/devices or human listening.

Scoped A/C review for single-pass bounded project JSON: the integration owner traced all four project parse/serialize exports, their Node and demo consumers, voice/event/tempo/settings normalization, canonical ordering and serialized-size enforcement. Only complete snapshot construction is factored into private helpers. Every caller still performs its original validation, detachment, voice-bank/count/reference/horizon checks and final bounded JSON check; public parsers never return an unchecked snapshot. Serializers omit only the discarded full-project JSON pass when ordinary Object/Array prototypes contain no toJSON. Presence checks do not invoke getters; any inherited property retains both original bounded passes, including self-deleting hooks and hooks installed while validating input. The independent normalized voice-bank JSON bound remains. No identity cache, trust marker, new input surface, format, declaration, dependency or DSP/render change is introduced.

Source and minified comparisons each preserve 42 canonical raw/parsed/foreign-frozen cases and 4048548 JSON bytes, 84 own-data descriptor/alias graphs, 28 matching refusals, zero caller property getter reads, two mutable-input lifecycles and 12 native inherited-hook cases. Chromium 156 native ES modules preserve 36 browser pairs, 391470 JSON bytes and 2736 input events with exact output graphs, unchanged inputs and six ordinary-hook cases. All 595 tests, type/security checks and the empty runtime-dependency listing pass. This scoped integration-owner A/C review is not independent release/publication approval or evidence of live audio, physical-device/MIDI or listening acceptance.

Scoped A/D review for expected-path deployment matching: the integration owner traced copyAssets admission and its private existing-deployment matcher. Only the existing validated expected-path Set classifies native primitive readdir names; no Dirent field, new collection, cached source/host stat or additional traversal is trusted. Root and descended-directory checks remain fresh. Manifest metadata retains regular-file and byte-size admission before reading. Expected assets move their regular-file checks to the existing fresh per-file lstat immediately before exact-size comparison and SHA-256, rejecting an observed non-regular target before its hash read. Missing/extra data, count limits, exact manifest text, every hash, fresh staging/publication/cleanup and visible refusal without repair remain intact.

Source and minified proofs each preserve 225 deployed files and 1939873 bytes, exact manifest/result values and ordinary rwx modes. Fresh-copy filesystem API traces are identical and reused non-lstat traces preserve every hash read; the installed-tree reuse removes 166 duplicate lstat calls. Sixteen native filesystem cases per build cover static admission, empty-directory compatibility, oversized/unexpected data, links/directories/sockets, zero library writes and zero prototype-name getter/setter calls. A controlled same-size matching-content link introduced after enumeration is now rejected before reading its target, with an isolated permanent regression. All 595 tests, type/security checks, the empty runtime dependency list and the real executable's copy/reuse/error and 166-asset HTTP checks pass. This scoped integration-owner review is not independent release approval, an atomic filesystem snapshot under concurrent mutation, storage durability, audio/device acceptance or a waiver for other recorded prototype-ownership candidates.

Scoped A/D review for adjacent staged-asset directories: the integration owner traced every copyAssets caller, canonical destination/source overlap and symlink checks, bounded inventory and companion/LICENSE admission, staging creation, exclusive copies, staged hashes, both publication boundaries and cleanup. Only a successful private staging-parent result is reused for immediately adjacent assets; the local string is initialized from that invocation's fresh mkdtemp root and updated only after mkdir succeeds. No source or existing host filesystem check is newly cached, and no directory Set, extra traversal, shared state, concurrency, option, format or dependency is added. Every COPYFILE_EXCL operation, target SHA-256 read, manifest write, destination check, rename and failure cleanup retains its original ordering.

Source and shipped minified comparisons each preserve 225 deployed files and 1939511 bytes, manifest/result values and ordinary rwx permissions across three trees. Exact non-mkdir filesystem API traces retain every copied target and hash read. Three reuse cases and four injected directory/copy/content/publication failures preserve host data and remove staging. The real executable additionally verifies copy/reuse/help/usage/refusal exit classes, all 166 deployed HTTP assets, corrupt bytes and unsafe URLs. All 594 tests, type checking, the zero-runtime-dependency/dynamic-code gate and the empty production dependency listing pass. This scoped integration-owner A/D review is not independent release/publication approval or evidence of physical-storage durability, page CSP, native audio startup or device deadlines.

Scoped A/C review for control-free offline onset maps: the integration owner traced all score-cache registrations, both short/long validation paths and frame-queue consumers in offline rendering, streaming preflight and Worker rendering. Control presence is captured only in the existing validated control branch. Two private WeakMaps partition completed frozen output arrays, retaining exactly one weak score entry and no per-score wrapper or new event pass. Exact array/score identity, not copied public fields, qualifies the control-free route; raw inputs are never cached and controlled snapshots retain immutable reuse under the original bounds. Only onset lookup construction/insertion is omitted for control-free scores. The independent note-only check, explicit stops and pending-note cancellation, stable frame/tie order, automatic releases, release bounds, every validation/error path and all synthesis/encoding/message guards are preserved. Unregistered snapshots retain their original Map path. No API, format, dependency or protocol change is introduced.

Source and shipped minified comparisons each match 36 lifecycles, 1152 registered/forged/origin queue pairs, 54968 checkpoints, 185184 stereo frames and 53312 borrowed chunks, preserving exact PCM, own-data descriptors, alias graphs, caller inputs and 432 immutable snapshot identities with no scalar-value exclusions. Twenty-four malformed-input/error cases agree. Instrumentation confirms that only the note/stop targets omit onset Maps and entry writes. Chromium 156 additionally matches 12 direct browser cases and 24 real module Worker runs, including exact WAV bytes, transferred-chunk acknowledgement progress, cumulative diagnostics and pending-stop cancellation; 12 forged getter snapshots keep generic read order and injected controls. All 594 tests, type checking and the zero-runtime-dependency/dynamic-code security gate pass. This integration-owner A/C scope is not independent release approval or hardware/MIDI real-time/listening acceptance.

Scoped A/C review for silent-voice stereo accumulation: the integration owner traced both renderVoice callers, the +0 bus initialization and every subsequent addition, the existing gain qualification, silentFrame and its pitch/noise/feedback/scratch/finite-state stores, and post-frame control/priority/callback bookkeeping. Only the already-silent voice branch omits zero bus additions, and only when both pan coefficients are finite; signed-zero products cannot change the +0-seeded sum. Nonfinite coefficients retain the original multiplication/addition loop, preserving filter diagnostics instead of hiding bad DSP state. The original last-sample typed load and every state/error check still execute. Ordinary audible voices retain their original branch count and arithmetic order. No input admission, immutable prepared identity, native output/bounds authentication, field/cache, allocation, helper floating-point argument/result, FIR/DC/saturation, work ceiling, dependency or protocol/API change is introduced.

Source and minified comparisons each match 2969 lifecycles, 109971 checkpoints and 24368337 stereo frames, including 480 saturation/DC/pan/gain cases and 9600 aliased stereo blocks. All DSP data scalars/cache flags, native bytes and own-data descriptor/object-view alias graphs remain exact, with no data-value exclusions; opaque minifier identifiers use exported-prototype role and callable identity/arity. Additional paired loud/silent pan/gain faults cover 1980 cases (648 nonfinite injections), 19764 checkpoints and 926640 frames through recovery and recycling with exact PCM, diagnostics and original state. Chromium 156 native OfflineAudioContext/AudioWorklet matches all 90 PCM/event pairs (986880 frames each implementation), including silent-side wakeup, partial floors, both saturators and stealing/reuse. All 594 tests, type checking and 42-source/55-built security checks pass. Paired source/dist matrices include all 48 targets/controls. This scoped owner review is not independent A/B/C/D release or publication approval; real-time device/MIDI and listening acceptance remain unverified.

Scoped A/C review for settled edited sustain-rate floors: the integration owner traced the original scalar gain/timing stores, exact/non-exact segment classification and all admission, release, ADSR and canonical-reuse invalidation writers. The unchanged void storeGain fills the entire frame before qualification; raw native gains are inspected rather than re-evaluating dB or passing/returning new floating-point values. A positive sustain time makes the completed held segment non-increasing, so an exact scalar zero remains zero until an invalidating edit/release. Any nonzero gain, unfinished segment, unsupported release/target condition or nonfinite scalar result keeps the original fallback; a first-slot zero during attack cannot qualify. All operators must be constant before the existing vector cache settles, including partially audible mixtures with constant positive operators. No field, retained cache/state, buffer/view, allocation, caller property/coercion/callback, dependency, protocol or API path is introduced. Clock/feedback/history updates, fades, voice priority, reset/recycling and all admission/finite-output/error guards remain intact. Source and distribution each match 2489 PCM/DSP-state lifecycles, 67731 descriptor/alias/native-byte checkpoints and 18661137 stereo frames, excluding only the gainsSteady/silentGains boolean cache values while checking their types/descriptors and all other scalar state. Coverage includes admitted 0.01..100-second sustain rates, full and partial floor crossings, moving controls, nonzero transition boundaries, LFOs, offset/chunking, reactivation, release/stealing, panic/recycling and numerical faults. Chromium 156 executes 45 native offline worklet pairs (493440 stereo frames per implementation), with exact PCM and lifecycle/diagnostic events, audible reactivation/partial floors and no processing errors. All 594 tests, type checking and source/distribution security checks pass. Matched-package fresh-process timing is separate from correctness; no universal speedup, real-time deadline, physical-device/MIDI or listening acceptance, independent release approval or release-gate waiver is claimed.

Scoped A/C review for settled edited zero-sustain envelopes: the integration owner traced gainAt/envelopeDbAt, native gain/timing arrays and every admission, release and ADSR cache-invalidating writer, including canonical pool reuse and the carrier-energy stealing consumer. An unreleased edited operator with zero sustain time and completed attack/decay has constant gain. The exact floor caches literal zero as the original scalar reference does, without trusting a stale or poisoned sustainGain; above-floor edits retain their existing exponential. NaN/below-floor targets, moving sustain rates, unfinished transitions and releases retain their original fallback. The existing gainsSteady/silentGains booleans intentionally qualify that constant floor; no field, alias, retained cache/state, buffer/view, allocation, caller property/coercion/callback, dependency, protocol or API path is introduced. Clock advancement, feedback/history, fades, voice priority, seeds and pool resets, admission and all finite-output/error guards remain intact. Source and minified probes each match 1769 PCM/DSP-state lifecycles, 48206 own-data descriptor/alias/native-byte checkpoints and 11895297 stereo frames; equality excludes only the two named boolean cache values, retaining their types/descriptors and all other scalar state. Coverage includes live zero/tiny floor edits, positive and sustain-rate controls, nonzero attack/decay boundaries, LFOs, offset/chunking, reactivation, release/stealing, panic/recycling and poisoned cached-gain/noise-clock faults. The consumer regression covers 288 voice cases; Chromium 156 executes 15 native offline worklet pairs (164480 stereo frames per implementation) with exact PCM and lifecycle/diagnostic events, audible reactivation, silent-note stealing and no processing errors. All 594 tests, type checking and source/distribution security checks pass. Same-package equal-length-root fresh-process throughput is reported separately from correctness. This owner-scoped A/C review does not assert universal speedups, real-time deadlines, physical-device/MIDI or human-listening acceptance, independent release approval or any release-gate waiver.

Scoped A/C review for silent operator-noise clock fractions: the integration owner traced native four-element clock allocation, every step/fraction writer, quality/sample-rate and noise-rate admission, silent-frame qualification and the synchronous no-callback loop. The step cannot change during that loop; native Float64 stores do not change an already-binary64 fraction. Keeping the same per-substep addition/floor/LFSR/subtraction order and committing the final fraction preserves hold boundaries without multiplying or aggregating steps. Static-level-zero and periodic operators retain their original bypass; LFSR stores, phase/feedback advance, seeds, pool resets, error counters and all finite-output/admission guards are unchanged. The 8000..192000 Hz sample clocks, quality oversampling and 20..20000 Hz hold rates retain the original bounded tick work. No caller property/coercion/callback, exposed identity, retained cache/state, buffer/view, explicit render allocation, dependency or protocol/API path is added. Source and minified probes each match 764 PCM/instance-data lifecycles, 18400 descriptor/alias/native-byte checkpoints and 2467360 stereo frames, including actual pristine-zero-envelope dispatch, reactivation, offset/chunking, release/stealing, panic/recycling and numerical faults. Chromium 156 executes 15 native offline synth-worklet pairs (164480 stereo frames), with exact PCM and lifecycle/diagnostic events, nonzero reactivated output and zero processing errors. All 593 tests, type checking and source/distribution security checks pass. Matched-package, equal-length-root A/A-calibrated fresh-process timing is reported separately from correctness; no universal speedup, real-time deadline, physical-device/MIDI or human-listening acceptance, independent release approval or release-gate waiver is claimed.

Scoped A/C review for settled effect-ramp vectors: the integration owner traced strict own-data normalization, finite private control preparation, all 21 current/target writers and the synchronous no-callback processing lifetime. The bounded scan reads only private native arrays and runs only for nonempty calls that can execute intermediate steps. Equal finite nonzero values retain their bits under the original zero-delta step; positive-zero current values also remain positive zero for either signed-zero target. Any current negative zero or unequal control retains the complete original loop. The final target copy, counters, phase/order fade, feedback/history, admission and all finite/denormal/clipping guards remain unchanged. No caller property read, coercion, callback, shared storage, retained state/cache, allocation, buffer/view, dependency or protocol/API path is added. Source and distribution each match 336 lifecycle cases, 10752 complete state checkpoints and 3456264 stereo frames, preserving all original descriptors, scalar state and ring-buffer bytes; all 22 existing core effects/protocol tests pass. Native Chromium 156 matches nine browser-core cases, 225 full-state checkpoints and 118578 stereo frames; four real offline AudioWorklet renders additionally match all 65536 stereo frames against the frozen original core without protocol errors. All 593 tests, type checking and the dependency/dynamic-code gate pass. Realtime smoke remains unverified on this host: native oscillator probes without OPM also stall in Chromium/WebKit and time out in Firefox. No security policy, production fallback, host audio service or user audio process was changed to bypass that limitation. This is an owner-scoped A/C review, not independent release approval or realtime/physical-device/listening acceptance.

Scoped A/C review for monotone MIDI track concatenation: the integration owner traced nonnegative validated VLQs, full-precision cumulative ticks, all private wire constructors, end-of-track admission and the stable tick/track comparator. Within-track captured ticks are monotone; only adjacent nonempty captured ranges need comparison. The index/flag bookkeeping reads dense own records and own numeric ticks after track validation, not caller properties or the end-of-track clock. Empty/ignored-only ranges contribute no boundary; equal boundaries already retain ascending file-track and within-track order. Descending or overlapping ranges retain the original stable sort. No input admission, byte read, bound, parse-before-execute error priority, warning/loss ordering, note/control/FIFO/sustain ownership, timing arithmetic, buffer/view, retained state/cache, dependency or public API changes. Source and minified distribution each match 8190 result/error descriptor/alias graphs, all 7743 accepted compiled scores and 447 rejections, including ordered/tied/interleaved/same-first overlapping/reversed/empty-gap/late-conductor/empty/split-gate layouts, full metadata bytes, large ticks and native subviews. Backing bytes remain unchanged with zero caller source/option getter or inherited tick getter/setter calls. All 44 existing MIDI file/program regressions pass. This owner-scoped A/C evidence is not independent release approval or physical-device MIDI acceptance.

Scoped A/C review for fixed-literal MIDI expression snapshots: the integration owner traced every channel-expression state update, owner fanout, newest-pressed poly-pressure ownership and sustained-gate override. The private field selector is limited to the four existing expressive fields; numeric operations and ordering remain unchanged. Fresh fixed-key object literals create each owner's own-data properties directly, without a shared snapshot, intermediate control object, object-spread traversal or assignment through inherited setters. No caller-controlled key, reference, buffer/view, cache, retained state, parser admission, byte read, budget, warning path, dependency or protocol/API change is introduced. Source comparisons match 4452 result/error descriptor/alias graphs, all 4037 accepted compiled scores and 415 rejections across repeated-pitch fanout, pre-onset/held/sustained expression, sticky poly overrides, native subviews and malformed input, with unchanged bytes and zero caller source/option getter calls. All 44 existing MIDI file/program tests pass, including prototype-setter and ownership isolation coverage. The rejected computed-key variant is absent. This owner-scoped evidence is not independent release approval or physical-device MIDI acceptance.

Scoped A/C review for consumer-scoped MIDI beat conversion: the integration owner traced positive-PPQN admission, bounded VLQ accumulation, unshared native-view admission, private wire construction and every timing consumer. Wire ticks and PPQN are already-owned numeric values; moving the unchanged division into tempo, expression and note-on branches introduces no caller property access, callback, coercion or additional branch. Meter, program, RPN, sustain and note-off continue their original tick-based work. Parsing, byte reads, stable wire order, warnings, ownership, gate durations, validation and budgets remain unchanged, with no new state/cache, buffer/view, dependency or protocol/API path. Source comparisons match 3790 result/error descriptor/alias graphs, all 3375 accepted compiled scores and 415 rejections, including nonzero native views, shadowed metadata, large cumulative ticks and malformed data, with unchanged input bytes and zero caller source/option getter calls. All 44 existing MIDI file/program tests pass. This owner-scoped review is not independent release approval or physical-device MIDI acceptance.

Scoped A/C review for same-frame uniform PM target reuse: the integration owner traced native target/factor allocation, note-admission copying, scalar preparation, static-step consumers and scratch writes. Targets and factors are distinct private four-element Float64Arrays; equality classification reads no caller properties, callbacks or shared storage. Only four equal targets share the original factor expression during the current frame, retaining zero/one cases, arithmetic order and left-to-right stores. Signed zeros both take the same zero case; NaN equality fails and preserves the original nonuniform loop. The shared global factor and frame scratch remain unchanged. No cache, retained state, explicit allocation, dependency, input trust path, work ceiling, phase/envelope/noise/FIR advance or output/error guard is added or removed. Source comparisons preserve 1344 chunk-independent stereo lifecycle cases and 16128 complete active/fading voice checkpoints, including depth/rate ramps, glides, disabled/re-enabled PM, pool reuse, 504 filter-fault and 504 mix-fault cases. Another 960 numeric selector cases and 270 injected NaN/infinity target cases preserve complete voice/filter bits, callbacks and errors, including each individual slot and all four slots across all qualities. The 12 existing engine/reference tests pass, including independent per-operator LFO reference and uniform depth scaling through live controls/recycled notes. This is scoped owner evidence, not independent release approval or physical-device/listening acceptance.

Scoped A/C review for zero high-word held-noise LFO mixing: the integration owner traced both noise entry paths and the per-frame oscillator caller. The existing unsigned low-word conversion exactly equals its numeric input only for uint32 integer cycles, including signed zero; their original high-word product is zero. The new branch skips only that product and its division/floor, preserving full high-word mixing for negative, fractional, nonfinite and larger inputs. Reordering integer XOR operands preserves every bit; finalizer constants, seed, output scale, finite-phase admission, waveform selection, clocks and note/global synchronization remain unchanged. There is no new state/cache, generator advancement, allocation, retained data, callback, input trust path, voice budget or output/error-guard change. Source probes preserve 1138913 direct values and 254980 radian-phase/rejection cases, cover both classification paths and preserve two observable numeric conversions outside the typed uint32 path. Multiplication counts change from three to two only on that path. Another 1152 chunk-independent stereo lifecycle cases preserve active/fading voice numeric state, filter/DC/spill values, callbacks and errors across 13824 checkpoints, including 192 synthetic large-cycle seek cases, 432 filter-fault and 432 mix-fault cases. Existing held-level coverage is extended around positive/negative 2^31, 2^32 and 2^40 cycle boundaries. This is scoped owner evidence, not independent release approval or physical-device/listening acceptance.

Scoped A/C review for half-wave correction support short-circuiting: the integration owner traced the private shape dispatch and the static/generic oscillator callers. The finite-angle guard, positive-step predicate, quarter-turn width clamp and original in-window arithmetic order remain unchanged. For the admitted numeric path, nonnegative distance compared with positive width gives the same support decision as their binary64 quotient compared with one; only the discarded out-of-window division is skipped. No input admission, state, buffer/view, callback, retained cache, loop ceiling, voice recycling, phase/feedback advance, FIR operation or finite-output/error guard changes. Source comparisons passed 6016422 threshold checks, 1381640 scalar cases and 1152 complete stereo lifecycle cases with 13824 checkpoints, preserving active/fading voice numeric state, filter/DC/spill values, callbacks and errors, including 432 filter-fault and 432 mix-fault cases. The 16 existing operator/waveform tests also passed. This is scoped owner evidence, not independent release approval or physical-device/listening acceptance.

Scoped A/C review for size-adaptive full stereo float32 native-word reads: the integration owner traced the full-only selector, native channel authentication, source capture order, 4000000-frame ceiling and both source/output spans. Only admitted two-channel float32 files of at least 1024 frames use the new loop; smaller files retain the original scalar writer and other formats/mono/streaming retain their writers. Both intrinsic source lengths are rechecked before captured native Uint32 construction; shortened/detached inputs preserve scalar RangeErrors. Captured buffer/offset getters bypass caller metadata, constructors and species. Each private view covers exactly its admitted prefix at the native aligned source offset, including unused odd-byte suffixes and shared growth. Identical input arrays reuse one view but are still read separately in left-before-right order; no sample snapshot, retained/copied PCM or caller transfer is introduced. Each raw word is captured once and checked for undefined or an IEEE754 sign-cleared magnitude above 1, preserving finite Float32 -1..1, signed zeros and subnormals while rejecting all NaNs/infinities. Each left word is stored into private output before right capture; partial errors expose no output. Explicit LE Uint32 stores preserve the unaligned byte-58 float payload and zero-offset/full-buffer ABI. Native integer/float reinterpretation shares agent byte order; actual big-endian hardware remains unverified. Header/layout, PRNG, callbacks, trust identities, dependencies and work ceilings are unchanged. Source proofs preserve 360 WAV cases, 228 rejections, 360 transfers, 1002569 sampled bit classifications and 497553 raw patterns per channel. Per implementation, 2704 native-sized left/right invalid-pattern cases and 32 actual shared-growth, zero/missing-last shrink, detachment, repair and transfer cases preserve validation and admitted prefixes. Another 384 alias, offset, metadata-shadowing, odd-buffer-length, threshold and output-transfer cases produce the expected 144 fixed-prefix views and zero metadata getter calls. Decoded-bit regressions now cover mono, distinct stereo and identical stereo inputs around both float thresholds; first/middle/last invalid-sample and atomic retry coverage now includes 1025 frames. All 15 targeted WAV tests pass. This scoped owner review is not independent release A/B/C/D approval or physical-device/listening acceptance.

Scoped A/C review for full mono float32 native-word reads: the integration owner traced the full-buffer-only selector, native Float32 authentication, 4000000-frame admission bound and all source/output spans. The new path is limited to mono float32 calls of at least 128 frames; all other writers retain their routes. Captured typed-array buffer/offset getters and the captured native Uint32 constructor read genuine storage without caller property, constructor or species access. The fixed-length view covers exactly the admitted Float32 prefix at its native aligned source offset, including buffers with unused odd-byte suffixes; no caller storage is copied, retained or transferred. Intrinsic source length is rechecked before view creation; shortened/detached inputs retain scalar RangeError behavior, and an undefined later indexed word is also rejected. Each word is captured once: clearing the IEEE754 sign bit accepts exactly finite Float32 -1..1, including both zero signs and subnormals, while rejecting infinities and all NaN payloads. One DataView Uint32 store explicitly writes LE into private owned output without moving the byte-58 float payload or changing zero-offset/full-buffer ABI. Native float/integer view reinterpretation shares agent byte order; actual big-endian hardware remains unverified. No source snapshot under concurrent mutation is promised. Bounds, headers, formats, PRNG, callbacks, trust identities, dependencies and work ceilings are unchanged. Source proof preserves 360 WAV cases, 228 rejections and 360 transfers. Bit classification checks 1002569 sampled patterns against native Float32 magnitudes; full files preserve 497553 admitted raw patterns and reject 1352 invalid patterns per implementation. Sixteen actual shared-growth, zero/missing-last shrink, detachment, repair and output-transfer cases per implementation preserve prefixes/errors. Another 192 source-span, offset, metadata-shadowing and output-transfer cases include four storage types and odd buffer lengths, with 48 expected fixed-prefix views and zero metadata getter calls. The native authentication regression now checks decoded signed-zero/subnormal/rail bits and ignored metadata around the 128-frame threshold. Existing invalid-sample tests exercise first/middle/last native-sized float inputs. All 15 targeted WAV tests pass. This scoped owner review is not independent release A/B/C/D approval or physical-device/listening acceptance.

Scoped A/C review for paired native mono PCM24 stores: the integration owner traced both selectors, per-call frame bounds, data spans and RIFF padding. Only admitted undithered mono PCM24 on detected little-endian hosts can use the pair loop; sub-128-frame calls and other endianness retain the byte writer. The captured native Int16 constructor wraps only the owned even-sample output prefix at aligned byte offset 0/44 with three words per pair. Explicit element count permits an odd-length chunk buffer without including its final three data bytes or RIFF padding. The bitwise even-prefix calculation is bounded by the existing 65536-frame chunk or 4000000-frame full-call limits, not the potentially larger declared streaming total. Every sample, including an odd tail, is captured once and checked finite -1..1 before unchanged Float32 quantization. Adjacent-sample packing uses the already-proven three-word mapping; private grouped writes cannot expose partial output or commit frames/PRNG state on error. An odd tail retains the byte stores, and finalization alone emits RIFF padding. There is no caller-buffer/constructor/species access, retained PCM, new callback, trust identity, dependency, public format or work ceiling. Source comparisons preserve 360 WAV cases, 228 rejections, 360 transfers, the Float32 corpus and 14 boundary files. Native/forced-portable ownership, prefix-span, offset and detachment checks each cover 24 cases; forced dispatch is not actual big-endian hardware validation. Thirty-six actual mono full/incremental shared-growth, zero/missing-last shrink, repair/retry and transfer cases preserve admitted prefixes and RangeErrors; ten direct prefix checks leave tail/padding bytes untouched. Existing decoded-byte and first/middle/last invalid-sample tests cover native batches, including invalid odd tails. The padding regression now checks a nonzero final sample in full and incremental files across short/native/long odd lengths. All 15 targeted WAV tests pass. This scoped owner review is not independent release A/B/C/D approval or physical-device/listening acceptance.

Scoped A/C review for packed native stereo PCM24 stores: the integration owner traced both selectors and the output-storage contract. Only admitted undithered PCM24 with two native Float32 channels, detected little-endian storage and at least 128 frames uses the packed loop; mono, small calls, other endianness and dither keep their existing writers. The existing captured Int16Array constructor wraps fresh owned output at aligned byte offset 0/44 with exactly three words per captured frame, never caller storage or caller constructor/buffer/species metadata. Packing maps Llo16, Lhi8/Rlo8 and Rhi16 to the same six little-endian bytes; the explicit left-high-byte mask prevents negative sign bits from contaminating the right byte. Every scalar is captured once and checked as finite -1..1 before the unchanged Float32 quantization. Left is still read/validated/quantized before right; its private high byte is grouped with the right low byte after right validation. Owned output is not exposed before success, so this grouping cannot leak partial output, skip validation or advance transaction/PRNG state on failure. Header/data sizes, offsets, padding, bounded frame counts, public formats and transfer ownership are unchanged; no retained PCM, callback, trust identity, dependency or work limit is added. A native packing proof covers all 16777216 signed 24-bit values per channel in paired cases, not the entire pair cross product. Source comparisons preserve the 360-case WAV matrix, 228 rejections, 360 transfers, Float32 corpus and 14 boundary files. Sixteen shared-growth/resizable-shrink/retry/transfer cases preserve admitted prefixes and errors; native and forced-portable ownership/offset/span/detachment checks each cover 24 cases. Forced dispatch is not actual big-endian hardware validation. Existing decoded-byte tests cover both channels and multiple chunk sizes; first/middle/last invalid samples now exercise short and native-sized batches, full and incremental encoding, every format and atomic retry. All 15 targeted WAV tests pass. This scoped owner review is not independent release A/B/C/D approval or physical-device/listening acceptance.

Scoped A/C review for size-adaptive native PCM16 output stores: the integration owner traced both writer selectors, native channel authentication, admitted frame bounds and output allocation. Only undithered PCM16 on detected little-endian hosts can select the native writer; sub-128-frame calls return to the original byte loop before constructing a view, and other endianness uses that byte loop directly. The captured native Int16Array constructor wraps only fresh owned output, at aligned data offset 0/44 with exactly admitted frames times channels; it never wraps caller storage or reads caller buffer/constructor/species metadata. Each native Float32 sample is still captured once and validated as finite -1..1 before the unchanged integer rounding and store, left before right. Int16 conversion therefore cannot silently replace invalid samples. One short-lived view per selected larger call adds no retained buffer, callback, trust identity, work ceiling, dependency or public format. Header/fact/data sizes, PCM24/float32/dither paths, PRNG state, source ownership and commit-after-validation accounting remain unchanged. Source comparisons preserve 360 WAV cases, 228 rejection checks and 360 transfers; independent corpus and 14 boundary files cover both formats/channels and native/byte cutovers. Sixteen actual shared-growth/resizable-shrink/retry/transfer cases preserve admitted prefixes and RangeErrors. Genuine native-view instrumentation verifies owned-buffer identity, offset, span and detachment in 24 cases; a separate 24-case forced portable-dispatch run constructs no native output views. Forced dispatch is not actual big-endian hardware validation. The decoded half-LSB/rail consumer regression spans multiple chunk sizes and both channels; all 15 targeted WAV tests pass. This scoped owner review is not independent release A/B/C/D approval or physical-device/listening acceptance.

Scoped A/C review for exact undithered Float32 PCM rounding: the integration owner traced native channel authentication and both fixed-writer selection sites. Only admitted undithered PCM16/PCM24 native Float32 inputs reach the six changed expressions; each scalar is still captured once and checked for finite -1..1 before multiplication. Float32 products with these integer scales have at most 47 significant bits, leaving precision for floor(scaled + 0.5) to preserve rounded integer bytes; private integer stores already discard signed zero. This equivalence is not applied to arbitrary doubles or dithered samples: generic/stereo TPDF rounding, PRNG draws, clamping and transaction state are unchanged. There is no new callback, input metadata read, buffer/view allocation, retained state, format, dependency or work budget. Headers, byte order, source ownership, resize/growth behavior, full-buffer and bounded-chunk limits, transfer and commit-after-validation accounting remain unchanged. Source comparisons preserve 360 complete WAV cases, 228 rejection checks and 360 transfers with zero metadata getter calls. An independent 1,486,966 numerical checks over 743,207 distinct Float32 inputs include every PCM16 half-integer threshold and neighbours, a PCM24 threshold grid, random words, subnormals, signed zeros and rails; both PCM formats and channel counts match complete/bounded-stream bytes. A decoded-byte consumer regression covers positive/negative half-LSB neighbours and either-channel rails, and all 15 targeted WAV tests pass. This scoped owner review is not independent release A/B/C/D approval or physical-device/listening acceptance.

Scoped A/C review for fixed WAV header tag words: the integration owner traced both header callers and every tag offset. Both callers allocate fresh zero-offset owned Uint8Arrays after unchanged layout validation. The five fixed four-byte ASCII IDs now use big-endian DataView words over the existing private view; all numeric RIFF fields remain little-endian and their offsets/values are unchanged. PCM/IEEE_FLOAT format sizes, zero cbSize, fact length/sample count, data length, RIFF padding and 44/58-byte headers are preserved, including unaligned float fact/data tags. The local per-character text helper is removed without adding a cache, buffer/view, per-encoder field, dependency, public API/format or work budget. Native channel/sample validation, dither/PRNG state, encode accounting, header-once/finalization guards and transfer ownership are untouched. Source comparisons matched 360 complete WAV cases, 228 rejection checks and 360 transferred chunks with zero metadata getter calls. An independent 36-case header matrix per implementation checks exact IDs, endian-sensitive metadata, zero/one/65537 frames, both channels, sample-rate endpoints, transfer and empty-file finalization; observed tag charCodeAt calls fell from 16 per PCM header and 20 per float header to zero. Timing uses uninstrumented native builtins; these counts do not establish heap-byte or GC effects. All 14 targeted WAV tests passed. This scoped owner review is not independent release approval.

Scoped A/C review for full-buffer stereo dither writer reuse: the integration owner traced native channel authentication, layout and both writer-selection sites. The full-buffer exporter now selects the existing stereo writer only after the unchanged parser/layout admits dither with exactly two native Float32 channels; float32 with dither still rejects before selection. The helper accepts the supplied byte offset and frame count, has no streaming-only chunk-size assumption and retains the original left-validation/quantization/store-before-right order, two xorshift draws per sample, rail clamping and seed. Full files still start each call from DITHER_SEED and expose no partial output on error. Header/data sizes, padding, the 1..4000000-frame bound, mono/non-dither/float paths and streaming transaction accounting are unchanged. No loop, field, buffer/view allocation, trust shortcut, callback, public format/API, dependency or I/O is added. Source comparisons matched 360 WAV cases, 228 rejection checks and 360 transfers with zero metadata getter calls, plus four long dither files of 65537/262145 frames against bounded incremental encoding. Both PCM formats also preserved admitted prefixes on either-channel shared growth and rejected either-channel resizable-buffer shrink at output allocation; valid retries/transfers matched their references. All 14 targeted WAV tests passed. This scoped owner review is not independent release approval.

Scoped A/C review for aligned stereo float32 WAV stores: the integration owner traced the once-per-encoder writer selection, native channel authentication and both Worker callers. Only admitted stereo float32 chunks on little-endian hosts select the new loop; the fresh chunk starts at aligned offset zero and its Float32 view spans exactly twice the bounded frame count. Each native left/right sample is read once into a scalar, validated with the unchanged finite -1..1 check and stored before reading the next sample. There is no validation/copy race, caller metadata/species/iterator access, new callback or native input view construction. Growing shared sources retain captured-frame bounds; a source shrunk at output allocation still produces the same sample RangeError without committing frames. Mono copying and its shared-growth handling, unaligned full-file/big-endian DataView conversion, dither, RIFF limits, header/finalization and protocol/sink acknowledgements are unchanged. The output view is local and never retained, so chunk transfers do not affect future writes; no new field, buffer cache, public format/API, external I/O or dependency is introduced. Source/distribution checks match 360 WAV cases, 228 rejections and 360 transfers with zero metadata getter calls, plus both-channel shared-growth/resizable-shrink retry/transfer cases. All 27 targeted WAV/real-Worker tests passed, including genuine Worker encoding and sink ownership/backpressure/cancellation. This scoped owner review is not independent release approval.

Scoped A/C review for native mono float32 WAV chunks: the integration owner traced layout, native channel authentication, bounded frame admission, writer selection and every runtime caller. Only mono float32 streaming chunks on a detected little-endian host use the new writer; their fresh owned output starts at aligned offset zero. Stereo, big-endian and unaligned full-file data retain the existing DataView writer. Captured native length/constructor/set intrinsics avoid caller metadata, species and iterator access. Copying precedes validation, which reads only the private destination; finite -1..1 checks therefore cover exactly the samples returned even if shared input changes afterward. No frame accounting commits before complete validation. A length mismatch or native-copy failure caused by a grown length-tracking shared view delegates to the unchanged admitted-prefix loop; other copy errors propagate, and sample-validation errors are never retried. No encoder retains a PCM/output buffer or view, so transferring returned chunks cannot detach future output. A one-time endian probe retains only its boolean result; no dependency, external I/O, public format/API, parser budget or per-encoder field is added. Source/distribution byte checks cover 360 WAV cases, 228 rejections and 360 output transfers with zero metadata getter calls, including signed zero/subnormals, shared/resizable native subviews, shrink/growth at allocation and deterministically instrumented actual-native-copy races. The existing rejection/transaction regression now includes both mono and stereo for every format/dither combination. This scoped owner review is not independent release approval.

Scoped A/C review for settled stereo input classification: the integration owner traced the three monotonic flags, validated 2/4/8 oversample factors and every consumer of silence/difference information. Only a first pair with both inputs nonzero and unequal skips later classification reads: silent flags cannot become true again, and the differing flag cannot become false. All other cases still inspect the remaining inputs, including a zero/equal first pair followed by later changes. These reads classify existing owned native Float64 mix buffers; they are not input validation. All oversamples still pass through the same FIR, history/mirror transitions, DC blocking, saturation and finite-output/error guards, including nonfinite later inputs. No host callback, new trust shortcut, mutable cache, per-frame object/buffer construction or work-ceiling increase is introduced. Existing note/voice/control validation, authenticated native output bounds, voice/fade traversal, callback admission timing and reset behavior are unchanged. Real-core comparisons matched stereo PCM, complete FIR/DC arrays, spill state and event/frame checkpoints over 192 lifecycles and 2,304 checkpoints, with 72 nonfinite-FIR and 72 nonfinite-mix cases. Instrumented real buffers confirmed fewer classification reads without altering PCM; measurements used uninstrumented buffers. All 41 targeted core/engine/spectral tests passed. No public declaration, dependency or worklet protocol is changed. This scoped owner review is not independent release approval or physical-device/listening acceptance.

Scoped A/C review for short-circuit exact-zero FIR history queries: the integration owner traced both settling modes and every caller. Only a live-source exact-zero eligibility query uses the new internal predicate, on the existing owned Float64 history; it ignores precisely the same header as decimatorPeak and returns false for every nonzero value, including subnormals, NaN and Infinity. Signed zeros remain equivalent. Early exit changes no state and introduces no callback, per-query object/buffer construction, trust brand, external input or retained cache. The no-source path still computes the original numeric peak and preserves exact-zero/sub-floor clearing, including its nonfinite comparison behavior; the positive fixed floor makes the removed peak-not-zero conjunct redundant. All FIR executions, output/error guards, reset/idle masks, voice/fade/traversal limits, callback timing, native output authentication and worklet boundaries are unchanged. Source comparisons matched stereo PCM, complete FIR arrays and event/frame checkpoints over 192 lifecycles and 2,304 checkpoints, including 72 nonfinite-FIR faults; 5,181 additional numerical cases matched the old exact-zero rule without mutation. All 41 targeted core/engine/spectral tests passed, including existing pulse-tail/crossfeed coverage. No public entry-point API, dependency or retained field/collection/buffer is added. This scoped owner review is not independent release approval or physical-device/listening acceptance.

Scoped A/C review for independent stereo FIR idle tracking: the integration owner traced constructor initialization, panic/error reset, mirrored-history copying, per-frame invalidation and both whole-render idle shortcuts. One real own numeric class field replaces the own boolean; inherited accessors cannot supply or intercept its cache state. A channel may reuse eligibility only with zero current input and its own previously settled history; nonzero input clears its bit even when the instantaneous filtered output is zero. Mirrored logical histories derive both bits from the left channel, and both bits are required before restoring mirrored/whole-render idle behavior. The existing exact-zero/sub-floor settling rules and every FIR execution remain unchanged, so this optimization skips only redundant maximum-history scans, not validation, filtering or finite-output/error guards. Voice/fade/traversal ceilings, callback admission timing, output-buffer authentication, trusted voice identity and worklet message boundaries are unchanged. Real-core comparisons matched stereo PCM, complete filter arrays and event/frame checkpoints across 192 lifecycles and 2,304 checkpoints, including 72 nonfinite-FIR faults, chunking, subnormal gains, gain/pan ramps, release, panic and callback replacements. All 41 targeted core/engine/spectral tests passed; the added three-profile pulse regression checks audible tails and no crossfeed after either idle channel is reactivated. No dependency, URL, parser, public declaration or new retained collection/buffer is introduced. This scoped owner review is not independent release approval or physical-device/listening acceptance.

Scoped A/C review for lazy command receipt waiters: the integration owner traced every receipt creation, eviction, settlement and wait registration/cleanup access. Each receipt still owns a writable data field, explicitly initialized to undefined, so the lazy reads/assignment cannot fall through to inherited accessors. Unwaited commands and waits on already-settled receipts do not construct a Set; the first unresolved wait creates and captures a fresh private Set after the unchanged own-data wait-option validation, intrinsic AbortSignal checks, receipt/outcome lookup and 64-wait capacity check. Later waits reuse it, including after its last pending waiter aborts. No path replaces or shares that Set. Settlement still records its first outcome before snapshot-based multicast, and finish retains the active guard, timer clearing, intrinsic listener removal, own-wait deletion, count decrement and resolution/rejection order. Eviction treats absence exactly like an empty Set without evicting live waiters; the 128-receipt bound, safe IDs and reset/failure boundaries are unchanged. No retained field, shared mutable fallback, buffer or cache is added. Worklet protocols, voice validation and DSP guards are untouched. This is an owner-scoped local review, not release or physical-device approval.

Scoped A/C review for omitted Performance note options: the integration owner verified that only missing or explicitly undefined input bypasses snapshotting. The direct defaults are the existing in-range literal velocity 1 and boolean force false, not caller-derived data. Every provided object, including an empty object or an explicit undefined field, still passes the unchanged plain/null-prototype own-data parser and scalar validation. Part/admission checks, option-snapshot/pitch/velocity error ordering, key-ID checks before note-off options, and force validation before key lookup/mutation are preserved. Missing defaults perform no inherited velocity/force reads; provided data still rejects accessors and unknown fields without invoking getters. Key/physical-gate capacities, safe IDs, admission epoch checks, public callback order, cleanup and DSP guards are unchanged. No shared mutable default, retained field, collection, buffer or cache is introduced. This is an owner-scoped local review, not release or physical-device approval.

Scoped A/C review for default MIDI controller-map absence: the integration owner traced creation, baseline capture, lookup and reset iteration. Absence is used only for an undefined, already-snapshotted option. Every provided array, including an explicit empty array, still reaches the unchanged bounded own-data parser, reserved-controller/duplicate-target checks, control-range validation and fresh private frozen mapping records before ports open. Nonempty-map reset baselines are captured at the same point; missing/empty maps still avoid the public baseline observer. Receive still evaluates controller arguments before the private lookup, so skipping a native empty-map lookup or iterator does not skip packet reads or public callbacks. Mapped/default precedence, RPN selection/fallthrough, public method lookup, reset calls and error routing are unchanged. No retained field, collection, buffer, shared empty map or cross-message cache is added. Input/key/ownership bounds and DSP guards are untouched. This is an owner-scoped local review, not release or physical-device approval.

Scoped A/C review for omitted MIDI voice-map snapshots: the integration owner traced all three normalization sites and every lookup/report-size use. Callers skip the unchanged normalizer only for an absent, already-snapshotted option; its Map-returning helper API is preserved. Every provided native Map or plain object, including an explicit empty map, retains prototype/own-data/key/name/entry-budget validation and a fresh private copy. All consumers handle absence without a shared mutable empty map, and mapped-program report counters still allocate whenever a provided mapping can match. Program/drum/channel/default voice precedence and caller-mutation isolation are unchanged. Live program packets retain their byte read before ignored-message/error handling even without a map. Native SMF authentication, logical byte/event bounds, MIDI channel/key limits, captured callbacks and DSP finite-output/frame guards are untouched; no retained field, collection, buffer or cross-call cache is added. This is an owner-scoped local review, not release or physical-device approval.

Scoped A/C review for preferred-input MIDI pedal checks: the integration owner verified that only a seven-bit validated pedal-down request prefers its current input in the existing ownership Map. The fast result requires a fresh Map lookup and channel membership check after resolving the public sustain method; it does not trust the earlier local Set or down flag across a potentially reentrant method getter. Missing/removed membership falls back to the original union scan. Pedal-up, reset and detachment retain that scan, and empty Sets and input/channel insertion order are unchanged. Public sustain calls retain their receiver, argument-evaluation order and error routing; no callback, retained state, collection, buffer or resource budget is added. Input/channel validation and real DSP finite-output/frame guards are untouched. This is a scoped local review, not independent release or physical-device acceptance.

Scoped A/C review for live MIDI cleanup prefixes: the integration owner traced all three private callers (CC120/123, input detachment and global release) and verified that existing primitive port IDs/channel numbers produce the same NUL-delimited slot prefixes, with undefined reserved for the existing global traversal. No caller predicate, additional retained state or collection is introduced. Force-only ownership pruning, held-slot deletion/count changes before callbacks, live Map iteration and owned-key deletion only after a successful forced release remain unchanged. Failed-release retries, disposed cleanup and captured error callbacks retain their original order. Message validation, input/key/ownership bounds, controller snapshots, DSP finite-output guards and frame ceilings are untouched. Comparisons through matching real Performance/OPM/processor stacks matched 220 lifecycles, 1,540 public checkpoints and 880 stereo PCM blocks, including finite nested release/dispose/admission/error paths and foreign-key/pedal isolation. This is a scoped local review, not release approval or physical-device acceptance.

Scoped A/C review for bounded MIDI data pairs: the integration owner verified that only explicit-status two-data-byte channel messages use the new private packed read. Program/channel pressure retain their one-byte path, and running status retains its already-consumed first byte. The fast path requires two bytes inside the logical track end, loads one big-endian Uint16 and accepts it only when both status bits are clear. It advances exactly two bytes only on success; every short or invalid pair falls back to the original ordered checked data reads without an earlier cursor change, preserving status-bit/truncation errors and their precedence. The packed result is unpacked into the original byte positions, not interpreted as a MIDI 14-bit value. Native Uint8Array authentication, logical backing offsets, shared-memory rejection, own-data policy validation and all file/track/event/beat/output budgets remain unchanged. No field, collection, buffer, caller alias or cross-import cache is added. Later event handling, ownership, expression state and immutable result/report construction are unchanged. This is an owner-scoped review, not independent release approval.

Scoped A/C review for bounded MIDI chunk-tag comparison: the integration owner verified that only the existing four-byte MThd/MTrk labels reach the private reader. Native Uint8Array, byte-budget and nonshared-buffer checks still precede construction of the correctly offset logical DataView. The fast path requires four bytes inside the reader's end bound, compares the label's exact big-endian word and advances exactly four bytes only on a match. Every short or nonmatching tag leaves the cursor untouched before entering the original checked byte loop, preserving mismatch/truncation precedence and error messages. No caller getter, read outside the logical view, trust identity, collection or buffer is introduced. Header, track, event and expression budgets and all later parsing remain unchanged. Full result/freeze, rejection, subview and getter comparisons plus the partial-tag consumer regression cover these boundaries. This is an owner-scoped review, not independent release approval.

Scoped A/C review for cached note-frequency retuning: the integration owner verified that a slot's base note changes only during admission, which always rewrites its tuned-frequency Number before use. Normalized tuning changes explicitly recompute that Number for every active and fading slot, even with all operators in fixed-Hz mode, so later ratio restoration sees the new tuning. Operator edits and completed frequency ramps reuse only that existing private validated value; pitch/glide, ramp anchors, release timing and per-operator detune keep their original calculations. All internal callers supply the required frequency. Public own-data validation, immutable tuning snapshots, finite-output guards and voice/fade bounds are unchanged; no field, buffer, lookup table, mutable alias or cross-note cache is added. This is an owner-scoped review, not independent release approval.

Scoped A/C review for shared operator rate multipliers: the integration owner verified that the shared multiplier only consumes the existing validated primitive note and own snapshotted rateKeyScale for the current operator. The unchanged scalar duration formula evaluates an unclamped one-second duration; Infinity is confined to that derivation, while every stored attack/decay/release duration still clamps to ten seconds and sustain rate to one hundred seconds. Undefined sustain retains its original hold path. Required duration fields are immutable own data, so sharing does not skip caller getters or changing values. Existing cache/context guards, interrupted dB capture, one-frame zero attack/decay bridge, release reanchoring, per-substep sustain rate and pooled restoration remain in place. No cross-operator value, shared cache, voice shape, collection, validation or resource boundary is added. Exact scalar/audio/state/lifecycle comparisons, cap cases and mixed-operator prescaled-reference audio cover these invariants. This is not independent release approval.

Scoped A/C review for skipped empty MIDI loss-report work: the integration owner verified that options, native nonshared input, voice maps and all parser budgets still validate before reporting. The private snapshotted program Map's size and validated preserve policy decide counter allocation; every counter write remains guarded by expression/RPN preservation or an actually mapped program, so the counter always exists when needed. Omitted counters can only produce the same fresh frozen empty public array. Empty frozen warning snapshots cannot invoke classification callbacks; nonempty snapshots retain their original fresh classification record, property lookups, ordering and counts, including inherited-warning getter context. No caller getter, cross-import shared result, parser shortcut or trust boundary is introduced. Complete output/descriptor and rejection comparisons plus constructor/iterator/filter instrumentation cover the intended removal of private work, not general native-prototype-hook immunity. This is not independent release approval.

Scoped A/C review for stable batch voice retirement: the integration owner verified that constructor validation still restricts maxVoices to 1..32, so each original retired index shifted left with its error bit fits the existing Uint8 terminal buffer without truncation. Traversal records every original slot once, preserves error increments and pushes retired slots into the pool in the original order. Multi-terminal compaction reads dense own array entries, skips the recorded ascending indices, copies each later survivor at most once and pops the removed tail before fades or external terminal callbacks run. Single-terminal removal retains the original helper. Callback IDs remain separately captured; masked error bits preserve reasons even if a callback immediately reuses the final retired slot. No validation, admission, fade, notification-capacity or reentrancy boundary changes; no shared storage, voice field or collection is added. Mixed terminal, callback-reuse, exact stereo/state and lifecycle comparisons cover these invariants. This is not independent release approval.

Scoped A/C review for reused edited sustain gains: the integration owner verified that live ADSR mutation computes the same bounded fastExp2 expression previously evaluated by frame preparation and stores its Number result without precision loss in an existing private Float64Array. Only the original edited/held/nonzero-sustain predicate reads that cached result. Pristine admission still computes the canonical power gain, including same-patch pooled reuse after edits, before clearing edit flags; tail copies carry the cache and flags together. Sustain floors, moving envelopes, release timing, input validation and nonfinite rendering guards remain unchanged. No voice shape, buffer, callback, resource limit or trust boundary is added. Exact PCM, formula-validated derived-cache snapshots, lifecycle comparisons and existing interrupted-edit/recycled-patch tests cover these invariants. This is not independent release approval.

Scoped A/C review for lazy expressive MIDI export channels: the integration owner verified that all public event, gate, mapping, control-range and PPQN validation remains before expressive traversal. Each of the three sixteen-slot tables has own undefined data properties. A channel's first onset creates its fresh owner Map, modulation-default Set and complete primitive-valued neutral record before state setters or poly-pressure ownership run; tables retain them across silent gaps and remain private to one export. Valid note-offs follow admitted positive-tick gates. A same-tick control ordered before the channel's first onset explicitly retains the original ownership RangeError instead of accessing missing state. Fanout, conflicts, repeated-pitch FIFO/pressure checks, event order and byte/event/track budgets are unchanged. Literal initialization removes only the old private Array.from inherited-index reads; it adds no caller getter, shared state, cache, coercion or trust boundary and does not claim general prototype-hook immunity. Complete bytes/errors, scoped inherited-context probes and consumer regressions cover these invariants. This is not independent release approval.

Scoped A/C review for streaming stereo dither loops: the integration owner verified that only a validated stereo layout with active integer dither selects the new private writer, once per streaming encoder. Each encode still authenticates native matching channels and frame bounds before allocating the bounded private payload. The fixed left/right traversal preserves one read/check per sample, original sign-dependent scaling, two xorshift draws per sample, rounding/clipping and explicit little-endian stores; it finishes the left sample before reading right, including shared/aliased inputs. Two-/three-byte sample widths produce four-/six-byte frame strides, with final stores inside the already validated block alignment. RNG state remains local until successful return; invalid left/right samples expose no partial bytes and commit neither state nor frame counts. Header/finalization, full-export and mono paths, rate/RIFF limits and nested-metadata ordering remain unchanged. No buffer, per-sample allocation, public API or trust boundary is added. Complete file/stream/error/retry comparisons and existing independent dither tests cover the change. This is not independent release approval.

Scoped A/C review for active-dither quantization constants: the integration owner verified that scales are selected only from the private validated integer format after the float early return. The selected positive scale is exactly the original upper clipping bound; negating the exact positive power-of-two negative scale gives exactly the original lower bound. Hoisting these primitive constants introduces no sample coercion, allocation, cache or mutable alias. Every native sample is still read and finite/unit-range checked once before the original multiply, two RNG draws, noise addition, Math.round and ordered min/max clipping. Byte order, sample bounds, header/padding, frame/RIFF/rate limits and nested-metadata/invalid-chunk transactional commits remain unchanged. Complete file/stream/error/retry comparisons and existing independent dither tests cover the change. This is not independent release approval.

Scoped A/C review for fixed undithered PCM24 writing: the integration owner verified that writer selection still uses only the fully validated private layout, once per full export or encoder. PCM24 without dither uses fixed mono/stereo loops with three-/six-byte strides; each last store stays inside the allocated payload, and RIFF padding remains outside it. Native admission, frame/rate/RIFF bounds, sample-read and left/right validation order, asymmetric scaling, Math.round and explicit little-endian stores are unchanged. All undithered integer layouts now select fixed writers, so the generic integer path always has active TPDF: the nonzero seed and bijective xorshift transitions justify removing its obsolete zero-state branch while retaining every draw, arithmetic order and transactional state commit. Invalid chunks still expose no partial bytes and commit neither frame counts nor RNG state, including nested-metadata cases. No new buffer, per-sample allocation, shared mutable state, trust boundary or public API is introduced. Complete file/stream/error/retry comparisons and existing independent interleaving, padding and dither tests cover the cutover. This is not independent release approval.

Scoped A/C review for fixed undithered PCM16 writing: the integration owner verified that writer selection uses only the private fully validated layout, once per full export or streaming encoder. Only PCM16 with dither disabled selects fixed mono/stereo loops; other formats and active dither retain the original generic writer. Native channel authentication, matching shapes, own-data checks and all frame/RIFF/rate budgets still precede payload traversal. Fixed loops read and validate each sample once in original left/right order, preserve sign-dependent scaling and Math.round, and write the same explicit little-endian bytes. Strides of two/four bytes match the authenticated channel shape and validated block alignment; the final store remains inside the newly allocated bounded payload. The fixed writer returns the existing disabled-noise state zero; streaming still commits both state and frame accounting only after complete success. No caller output, raw metadata, new buffer, shared mutable state or validation cache is introduced. Complete byte comparisons include offset/shared/aliased channels, signed zero, subnormals, partitioning, dither controls and empty streams; invalid left/right samples retain exact errors, accounting and retry bytes. Existing consumer interleaving, nested-metadata and atomicity regressions remain unchanged. This is a scoped follow-up owner review, not independent release approval.

Scoped A/C review for fixed MIDI owner placeholders: the integration owner verified that a dense sixteen-element literal replaces only private Array.from array-like construction and its ignored-value callback. Every channel slot remains an own writable data property, so lazy Set reads/writes keep the same channel bounds and cannot reach inherited indexed setters. Construction now also avoids the incidental inherited index reads performed by Array.from on its private sparse array-like input; a throwing index-15 getter regression verifies a valid channel-15 import rather than suppressing an exception. This is an intentional ambient-hook hardening difference, not a claim that every prototype hook in arbitrary imports is ignored. Set allocation remains lazy, fresh per channel/import and bounded to sixteen; ownership, FIFO pairing, fanout, sustain, release handling, input validation and all file/generated-event budgets are untouched. Complete normal-result/rejection comparisons cover repeated pitches, poly pressure, mixed channels, sustain, EOF policy and malformed inputs. Benign inherited-index probes retain complete outputs while removing the obsolete initialization read, with native/options getters still unexecuted. This is a scoped follow-up owner review, not independent release approval.

Scoped A/C review for the private default tempo conversion map: the integration owner verified that only conversions with an omitted map can borrow the frozen fixed beat-zero/120-BPM point and array. Neither object is returned or registered as caller validation metadata; public default normalization still constructs fresh snapshots. Public numeric/map/BPM validation, error precedence, mutable-input revalidation, existing snapshot/cache policy and beat/point bounds are unchanged. The existing stableTempoContext guard checks optional prototype fields, the native array parent and the terminal index without invoking getters; any observable inherited context retains the original fresh-map path, including identity-dependent hooks. No caller-controlled data, mutable state or unbounded cache is shared, and no integration/inversion arithmetic changes. Exact numeric/rejection comparisons cover signed zero, subnormals, linear maps, snapshots, mutations and malicious inputs; inherited curve/endBpm/index/custom-parent probes retain results, getter counts and identities, with a consumer terminal-slot regression. This is a scoped follow-up owner review, not independent release approval.

Scoped A/C review for lazy MIDI expression snapshots: the integration owner verified that own-data policy and finite bend-range validation remain unconditional before native byte traversal. All sixteen optional channel slots are own data properties, preventing inherited index hooks on both lazy reads and writes. Channel-wide expression materializes a fresh complete primitive-valued record on first mutation, even with no held notes, and retains it for future onsets; poly pressure only changes its owned key. Unchanged onset construction copies primitive fields from either that record or one private frozen neutral default, never exposing or mutating the shared default. Mutable state remains bounded to sixteen records per import and cannot cross channels or imports. Signed zero, silent expression, partial RPN state, channel fanout, release-tail warnings and rejection order remain unchanged, as do native admission and all byte/track/beat/event/generated-event bounds. Complete-result/rejection and byte-exact export comparisons include mixed changed/neutral channels, pre-/held-/post-release updates, repeated imports and mutation of returned controls. A consumer regression covers channel isolation, poly-pressure ownership and fresh-import defaults. This is a scoped follow-up owner review, not independent release approval.

Scoped A/C review for smaller SMF wire records: the integration owner verified that decoding appends each track's retained events in source order. Stable native sorting by bounded numeric tick and track therefore preserves the former ordinal tie-break, including gaps from skipped messages; the single-track ordered fast path remains unchanged. Removing the per-track counter does not remove the separate all-message eventCount increment, which still counts ignored messages and end-of-track records before parsing. Native byte admission, chunk/track/beat/event/generated-event limits, warnings and EOF handling are unchanged. Private records do not escape, and export OutputEvent priority/ordinal ordering is untouched. No new container, callback, cache, shared mutable state or coercion is introduced. Complete-result/rejection and byte-exact export comparisons cover same-tick shared-channel controllers/programs and conflicting tempos across tracks; existing consumer order and budget checks remain intact. Native-layout samples establish only host-specific record sizes, not whole-file heap/GC behavior. This is a scoped follow-up owner review, not independent release approval.

Scoped A/C review for numeric MIDI channel-map keys: the integration owner verified that string-key checks, canonical 0–15 syntax and own data descriptors still validate before numeric conversion. Valid import keys map bijectively to decoded integer channels; malformed/leading-zero/symbol keys cannot collide or reach conversion, and no caller-defined coercion runs. Export keys stay strings, including numeric and prototype-like voice names, in a private native Map rather than object properties. Fresh snapshot construction, mapping precedence, input/value/entry bounds, warnings and file/generated-event budgets are unchanged. No cache, shared mutable state or new container is introduced. Complete-result/rejection and byte-exact export comparisons plus named-voice roundtrips cover both dictionary modes. This is not independent release approval.

Scoped A/C review for lazy MIDI RPN snapshots: the integration owner verified that strict own-data policy and finite 0–48 initial bend-range validation still precede binary traversal. The skipped factory only constructs private primitive fields. All sixteen optional slots are own data properties, channel indices remain 0–15, and every RPN-related message materializes its channel state before unchanged selector/data-entry processing, including ignored and partial selections. A missing snapshot uses exactly the validated initial range; nullish fallback retains a selected zero range and signed zero. State remains fresh per import, bounded to sixteen records and unexposed; native byte admission, event/beat budgets, warnings, ownership and EOF handling are unchanged. Complete-result/rejection comparisons and fractional/zero-range/prototype-index regressions cover the boundary. This is not independent release approval.

Scoped A/C review for direct WAV header writing: the integration owner verified that the private writer receives only newly allocated, zero-initialized native Uint8Arrays. Full export allocates the validated complete RIFF length; streaming header emission allocates exactly the validated 44-/58-byte header. Every fixed field/text store stays inside that prefix, and reserved float extension bytes and PCM24 alignment padding retain their original zero initialization. Header sizes, fact/data counts, byte order, sample validation, encoding and dither are unchanged. Streaming marks its header emitted only after writing completes; no caller-owned output, raw metadata, unchecked copy, new state or resource-limit change is introduced. Complete file/stream bytes and existing empty/header/accounting regressions cover both callers. This is not independent release approval.

Scoped A/C review for fixed-channel float WAV writing: the integration owner verified that both entry points authenticate native Float32 channels and fix mono/stereo shape before the private writer. The mono/stereo loops preserve one native sample read, its finite/unit-range check and the little-endian DataView write in original left/right order, including shared inputs and signed zero. Full-buffer float data still starts at unaligned byte 58; no native-endian reinterpretation or unchecked bulk copy is introduced. Each last write stays inside the already bounded payload. Invalid chunks still return no bytes and commit neither frame accounting nor dither state. No getters, trust boundaries, resource limits, allocations or public APIs change. Complete file/chunk-byte, malformed-channel and atomic-retry comparisons cover the change. This is not independent release approval.

Scoped A/C review for late-noise route pruning: the integration owner checked the reverse traversal of the frozen, topologically ordered four-operator graph. Noise and static-zero nodes do not consume modulation. Selection requires both leading nonzero periodic operators to be disconnected, noise at operator 2 and the sole carrier at operator 3; the frame retains carrier modulation, real noise clocks, all phase advances and nonzero-static gain/phase checks. Operator-level ramps keep generic rendering. Live controls cannot change the static routing/waveform invariants, and admission reselects the kernel and resets pooled oscillator state. No persistent mask, pool field, buffer or callback is added. Complete PCM/retained-state/lifecycle and noncarrier fault comparisons include all noise layouts, static zeros, quietest stealing, live edits and different-route reuse; only intentionally inaudible periodic scratch is excluded. This is not independent release approval.

Scoped A/C review for noise-carrier modulation pruning: the integration owner verified that admission reads only the frozen owned carrier graph, fixed waveform codes and static per-note levels. Every carrier must be noise or permanently silent; no live control changes those waveform/static-level invariants. Thus skipped periodic values/feedback have no route to audible output, including during generic operator-level ramps. Quietest admission uses carrier envelopes, not oscillator scratch, and admission resets phases/noise/value/feedback state before pooled reuse. The new kernel still advances every phase, clocks each real noise operator in order and checks nonzero-static operator gains and phases for finiteness; static-zero operators retain their previous skip semantics. Existing all-noise, periodic and mixed-audible-carrier paths remain intact. No pool fields, render buffers, closures, input permissions or limits change. Complete PCM/retained-state comparisons and noncarrier phase/gain fault cases cover controls, stealing and reuse. This is not independent release approval.

Scoped C review for reused comb filter locals: the integration owner verified that the low-pass history is a private, nonshared Float64Array. Its sanitized numeric value loses no precision or signed-zero information on storage, so the following feedback multiply can use the same local value instead of reading it back. The history write remains before feedback, all multiply/add order is unchanged, and no callback or public alias can intervene. Damped recurrence, undamped tap selection, sanitization, delay bounds and public validation remain unchanged, with no new state or allocations. Complete PCM/private-state comparisons cover aliasing, extreme/nonfinite input, parameter changes and reset. This is not independent release approval.

Scoped C review for undamped comb history: the integration owner checked that private comb cells originate only from zero initialization/reset or Delay.push sanitization, and are finite, bounded and either canonical zero or outside the denormal floor. At exactly zero damping, including negative zero, the original recurrence and cleanup therefore return the identical tap; the specialized loop still writes low history and performs feedback/mix arithmetic in the original order. Nonzero damping retains the original recurrence, and transitions select from the current sample's damping. No buffers, persistent caches, input trust or resource limits change. Complete PCM/private-state comparisons include tiny positive damping, extremes, nonfinite input, parameter interruption, aliasing and reset. This is not independent release approval.

Scoped C review for settled effects blocks: the integration owner verified that the new local flag is captured only after native buffer/range validation. With no pending parameter ramp, matching order and unit order gain, none of the skipped updates can change state. This synchronous traversal invokes no callbacks that can retarget private controls; moving blocks retain every original per-frame update even after reaching an endpoint. Chorus/reverb clocks, delay warming, finite/denormal sanitization, output mixing and all bounds remain unchanged, with no new persistent state or allocations. Complete PCM and private-state comparisons cover updates, order changes, boundary/nonfinite values, aliasing and reset. This is not independent release approval.

Scoped B/C review for prefix-preserving event compaction: the integration owner verified that both passes use the same cleanup predicate over the processor's dense owned event array. Message validation establishes own data before admission; no callbacks or untrusted accessors run during compaction, so the captured array and length remain stable. The first removed entry is omitted, later retained entries move only to earlier existing slots, and the unchanged prefix is never rewritten. Stable order, pending-event limits and terminal ownership cleanup are unchanged, with no new fields or allocations. Full queue and PCM/message/state comparisons cover all three cleanup modes, no matches, first/last/multiple removals, cancellation, late dispatch and reused slots. This is not independent release approval.

Scoped C review for shared frequency-ramp clocks: the integration owner checked that frame start/midpoint/end and ratio/Hz completion tests are shared only within one synchronous voice frame. Each operator still resolves fixed Hz versus its live ratio independently, multiplies before dividing, and scales only after Hz interpolation. The existing quadratic coefficient formula and substep path are unchanged, including frames that cross fractional endpoints. The helper writes only existing owned scratch arrays, takes reference arguments and returns no boxed number; no fields, buffers, input trust, callbacks or work budgets were added. Complete PCM/numeric-state/lifecycle comparisons include coupled ramps, retargeting, restored ratio mode, tuning, glide, tiny/fractional spans, stealing and reused slots. This is not independent release approval.

Scoped A/C review for removed pitch-control caches: the integration owner checked every ratio/Hz cache and ramp-mask consumer. Rendering and retuning already use the owned validated anchors and ratioFrames/frequencyFrames; the redundant mask bits did not govern pitch curves or completion. Ratio retargeting now evaluates its current anchor directly. Each operator's current Hz is captured into its own anchor before changing either timeline, and operators do not read one another's pitch anchors. Two private scratch arrays and unused mask bits were removed without changing input validation, phase calculations, work budgets or callback ordering. Complete retained numeric-state/PCM/lifecycle comparisons include simultaneous edits, restored ratio mode, tuning during ramps, fractional/tiny spans, stealing and pooled reuse. This is not independent release approval.

Scoped A/C review for lazy operator-level ramp caches: the integration owner verified that moving levels are already evaluated from the owned validated ramp anchors by both rendering and quietest admission. The cache is now materialized only at completion or retargeting; a retarget to the exact current value also refreshes the cache before clearing the ramp flag. Whole-frame and substep interpolation retain their original operation order. All other flag writers were checked for cache invalidation; pooled admission resets the levels before use. Complete PCM/state/lifecycle comparisons cover mid-ramp retargeting, non-operator edits, fractional/tiny spans, stealing and slot reuse. No fields, allocations, input trust or work budgets were added. This is not independent release approval.

Scoped A review for shared operator-level ramp clocks: the integration owner verified that only the current voice's already validated, owned ramp arrays and frame scalars are reused within a synchronous oscillator frame, after advanceControls and before terminal callbacks. The common end comparison preserves the original zero-duration and nonfinite behavior; individual interpolation still multiplies before dividing rather than changing rounding through a shared ratio. No voice fields, buffers, input permissions or work budgets were added. Complete PCM/state/lifecycle comparisons cover sub-frame endpoints, tiny spans, live edits, noise, stealing and recycled patches. This is not independent release approval.

Scoped A review for skipped note-only offline ownership maps: the integration owner verified that the branch reads only the private frozen prepared score. A note count equal to its event count excludes authored controls/stops, so no event can cancel a pending onset. IDs are validated unique before rendering; therefore an automatic off for a stolen, rejected or errored note cannot release a later unrelated gate. Mixed scores retain their Map and terminal cleanup. Complete PCM/capacity/diagnostic comparisons cover priority refusal, heavy stealing, noise, pending cancellation, chunk reuse and renderer cancellation. Existing input/event/frame budgets are unchanged. This is not independent release approval.

Scoped A review for offline pools bounded by total score notes: the integration owner verified that the requested maxVoices value still passes its original 1..32 validation before allocation. Only the privately prepared, frozen score's complete note count can lower the internal engine limit. Each unique note contributes at most one admission, so the smaller limit cannot force earlier stealing, overflow terminal buffers or weaken frame/event budgets; public estimates retain the requested capacity. Complete PCM/capacity/diagnostic comparisons cover overlapping releases, sparse reuse, pending cancellations, stealing, noise and live controls. This is not independent release approval.

Scoped A/C review for skipped unused synth pools for empty renders: the integration owner verified that score, rate, polyphony, engine/tuning options, signal and frame budgets validate before the empty-score branch. The private prepared score proves no events can arrive later. Captured native length/fill intrinsics bypass borrowed-array overrides and preserve the existing RangeError for detached output; cancellation still releases buffers/state and aborts still use the native signal getter. Nonempty event dispatch and DSP are unchanged. Complete PCM/diagnostic/rejection comparisons and the borrowed-buffer regression cover these boundaries. This is not independent release approval.

Scoped A review for shared immutable sequence capacity limits: the integration owner verified that the shared record contains only the same module-constant scalar bounds, all as own frozen data properties. No caller input or optional/inherited value enters it, and returned outer capacities remain fresh/frozen. Sharing therefore cannot let one caller mutate another preflight's budgets; all actual admission, allocation and frame checks retain their existing constants and order. Complete capacity/descriptor/PCM comparisons and mutation rejection cover these boundaries. This is not independent release approval.

Scoped A review for skipped note-only onset lookup tables: the integration owner verified that the identity in the existing private event-array registry must exactly match the supplied score before its frozen noteCount can select the fast path. Caller-constructed/frozen copies and metadata getters cannot claim that identity. A validated count equal to event-array length proves every event is a unique note; only then can both the unused Map and non-note traversal be skipped. Mixed controls retain their onset lookup, ADSR tail bounds and stable ordering, with unchanged validation/budgets. Complete queue/PCM comparisons include forged metadata and existing control/cancellation regressions. This is not independent release approval.

Scoped A/C review for skipped already-ordered sequence sorting: the integration owner verified that note pairs require a strictly later end frame and each onset must follow the prior end; appended non-notes must also preserve frame and stop/note/control priority order. Any failure permanently selects the unchanged stable sort, including NaN/collapsed frames. Validation, event ownership, onset clamping, release bounds, queue allocation and all budgets are unchanged. Complete queue/PCM comparisons and the tied-stop cancellation regression cover the changed path. This is not independent release approval.

Scoped C review for skipped inactive targeted AM factors: the integration owner checked every AM scratch consumer uses the local enabled-targeted flag, so retained inactive values are never read for folded levels or live operator ramps. Re-enabled factors are fully recomputed before consumption, including after delayed onset or pooled reuse. PM factor writes and pitch-step consumers remain unchanged; no persistent field, allocation, input validation or arithmetic approximation is added. Complete PCM comparisons and existing target/depth-transition references cover these boundaries. This is not independent release approval.

Scoped A/C review for hoisted voice-stealing policy flags: the integration owner checked that the policy is a validated constructor setting with no live mutator, and candidate audibility does not change it. Hoisting only keeps two local booleans for one bounded scan; priority admission, candidate skips, release/audibility/age tie-breaks and chosen-index updates remain ordered identically. No early callback, mutable persistent cache or changed ownership limit is introduced. Complete PCM/rejection/callback/ownership comparisons and existing stealing regressions cover these boundaries. This is not independent release approval.

Scoped A/C review for skipped automatic-ID duplicate scans: the integration owner verified that every admitted ID is a positive safe integer and automatic requests still have undefined IDs at the skipped comparison point. Supplied IDs retain the exact numeric and active-duplicate checks; automatic exhaustion, counter advancement, priority checks and failure rollback remain in their original order. No ownership limit, terminal callback ordering, caller validation or pool state changes. Complete ID/PCM/callback/ownership comparisons include repeated duplicate rejection and mixed explicit/automatic allocation. This is not independent release approval.

Scoped A/C review for reused pooled oscillator constants: the integration owner verified that waveform codes, noise steps and frequency scales have no writers outside note admission, and depend only on privately immutable operator data and the synth's fixed sample/oversampling rate. Same-identity reuse cannot retain live frequency/ratio edits because their separate note-dependent state is still reset. New patches refresh all three tables; failed admission clears prepared identity before recycling. Own optional-field checks remain on fresh initialization, with no new caller cache, slot property, numeric approximation or changed budget. Complete PCM/state comparisons and existing reuse/rejection regressions cover these boundaries. This is not independent release approval.

Scoped A/C review for reused pooled carrier indices: the integration owner verified that algorithm carrier arrays are dense own-data arrays, recursively frozen by the fixed graph definition, and no live-control/reset path mutates the private copied indices. Only identical privately prepared voice identity skips copying; different patches still replace the table before admission. Failed initialization clears that identity before the slot returns to the pool, preventing partial cache reuse. Sparse modulation-input arrays are deliberately still read per admission, so inherited-hole context cannot leave newly cached topology stale. No extra slot property, mutable caller cache or changed admission budget is introduced. Complete PCM/state comparisons and the failed-initialization recovery regression cover these boundaries. This is not independent release approval.

Scoped A/C review for skipped unity operator-level attenuation: the integration owner checked that required operator levels and optional scaling snapshots remain validated own data, and key/velocity attenuation is computed with the same reads and arithmetic. Only exact zero bypasses multiplication by the unit power; signed operator zero remains unchanged. Nonzero attenuation, frequency/envelope setup, admission failure/stealing, pooled resets and all bounds are untouched. Complete PCM/level comparisons and existing scaling/velocity regressions cover these boundaries. This is not independent release approval.

Scoped A review for skipped empty-array prototype transitions: the integration owner verified that native-array admission, own length validation and the complete Reflect.ownKeys allowlist still run before the fast return. Only captured length zero can skip the element loop/prototype transitions; the result is still a fresh ordinary array, with no input indices or inherited iteration read. Nonempty element descriptors, getter rejection, detached storage and entry budgets are unchanged. Snapshot/error comparisons and existing strict-array/empty-sequence regressions cover the changed path. This is not independent release approval.

Scoped A review for allocation-free MIDI controller classification: the integration owner checked that admitted data bytes are integers 0..127 before classification, so the inclusive 98..101 comparison selects exactly the four existing RPN/NRPN selectors. Data entry remains limited to 6/38, expression remains limited to 1/7/10/11, and sustain 64 still follows its earlier policy branch. Classification performs no caller-defined access, and all RPN state handling, omissions/rejections and file/generated-event budgets are unchanged. Exhaustive controller/value/policy comparisons and existing musical-control regressions cover these boundaries. This is not independent release approval.

Scoped A review for compact MIDI import channel flags: the integration owner verified that channel indices are already bounded integers 0..15 before wire events are stored, so every shift is confined to the low 16 bits. Pedal-up clears only its channel bit before closing that channel's sustained set; note closure records only that channel's history. Flags remain local to one import, and expression validation, gate ownership, EOF handling, warning counts and all budgets are unchanged. Complete-result/rejection comparisons and the extended channel-isolation regression cover the changed path. This is not independent release approval.

Scoped A review for lazy MIDI expression ownership sets: the integration owner verified that Array.from creates all 16 own slots before reads/writes, independently of inherited indexed accessors. Only validated note-on events instantiate sets; every preserved held note enters its channel set before closure, so close retains its existing ownership deletion. Missing sets mean empty fanout, not missing channel snapshots or skipped controller/RPN validation. Sets persist after becoming empty, and all source/generated-event limits and EOF policies remain unchanged. Complete-result/rejection comparisons and existing pre-onset/fanout/ownership regressions cover these boundaries. This supersedes the earlier eager preserve-mode set allocation only; it is not independent release approval.

Scoped A review for lazy MIDI import sustain sets: the integration owner verified that all 16 table indices are own data slots before any read/write, channel indices remain validated to 0..15, and only validated owned notes enter lazily created sets. Pedal-up handles missing sets as empty; existing sets clear after closure and remain bounded/reusable. End-of-file traversal retains channel order, pressed/sustained ownership remains disjoint, and warning/count/rejection behavior is unchanged. Complete-result comparisons and existing ownership/end-policy regressions cover the boundary. This is not independent release approval.

Scoped A/C review for direct integer PCM byte stores: the integration owner verified that validated quantization still yields signed values within the existing 16/24-bit bounds, and masks/arithmetic shifts emit their two's-complement little-endian bytes, including negative zero as zero. Offsets, allocation sizes, sample reads and pre-store finite/range checks are unchanged. No host-endian assumption or extra read from shared input is introduced; invalid chunks still cannot commit frame/dither state. Full-file comparisons and existing endpoint/dither/transaction regressions exercise the boundary. This is not independent release approval.

Scoped C review for shared zero-depth chorus taps: the integration owner verified that zero swing makes every voice's admitted delay offset identical. Delay reads have no side effects, so their result can be reused while the original per-voice weight arithmetic/order is retained. Ring writes, sanitization, feedback, LFO advancement and nonzero-swing interpolation are unchanged; parameter ramps select the branch from the current sample's depth. No new state, allocations, bounds or trust are introduced. Full PCM comparisons and existing wrap/depth-activation regressions exercise the boundary. This is not independent release approval.

Scoped A/C review for skipped immediate scalar ramp scans: the integration owner verified that the conditional flag write occurs after unchanged validation and scalar timeline assignment. Every nonzero scalar ramp still sets ENGINE_RAMP; zero-duration edits apply their immediate feedback/modulation effects directly. An existing ENGINE_RAMP bit is never cleared by this shortcut, so interrupted and unrelated pending scalar ramps still reach the original advancement/cleanup logic. No input bounds, arithmetic order, storage or lifecycle ownership changes. PCM/scalar/flag comparisons and existing live-control regressions cover the boundary. This is not independent release approval.

Scoped A/C review for immutable tuning-table reuse: the integration owner verified that reuse is gated by the existing private identity set, populated only after all 128 own finite bounded cents cells are copied and the output array is frozen (plus the private frozen zero table). Known arrays cannot lose/change cells or prototype. Raw arrays, frozen copies and proxies are not registered and still validate/detach. Outer own-data fields and referenceHz checks are unchanged, and no table mutation occurs in the known branch. Exact frequency comparisons and mutation/forgery/index-accessor regressions cover the boundary. This is not independent release approval.

Scoped B/C review for skipped unchanged worklet queue truncation: the integration owner verified that the original dense-array compaction and removal predicates are unchanged. When kept equals the original length, every event was retained in its existing order and there are no stale tail references to drop. Every actual removal still truncates before further dispatch/notification. Queue bounds and terminal-ID cleanup are unchanged. Queue-mode comparisons and real-processor PCM/message/state comparisons cover the modified path. This is not independent release approval.

Scoped A review for control snapshot descriptor reuse: the integration owner verified that the descriptor is new and private to each validation call, has a null prototype and own value/enumerable slots, and is never stored on the returned snapshot. Each native defineProperty copies the current descriptor into a distinct non-writable, non-configurable own property; subsequent descriptor edits cannot change earlier values. Tuple validation/freezing, malformed-input rejection and snapshot identity remain unchanged. Mixed-order descriptor comparisons and existing inherited-hook regressions exercise the boundary. This is not independent release approval.

Scoped A review for live-control validation key reuse: the integration owner verified that the tuple predicate recognizes exactly the previous four names, and every key still passes the same own-data descriptor and value checks before a result property is defined. After a successful loop the private key snapshot exactly matches the result's own fields, including non-enumerable input fields, so reusing it for ramp dependency checks cannot omit validation or admit unknown fields. Snapshot identity reuse, freezing and raw-input revalidation are unchanged. Snapshot/error comparisons and existing malformed-control regressions cover the boundary. This is not independent release approval.

Scoped A/C review for integer reverb pre-delay reads: the integration owner verified that the private direct-tap method is reached only after the existing bounded seconds-to-frames conversion and an integer check. Positive delays remain below the admitted ring length, so one wrap yields an in-bounds integer index; zero delay still uses the direct source. Delay cells are initialized or sanitized on write, preserving finite output and zero behavior without interpolation. Fractional reads, chorus modulation and trust-boundary validation are unchanged. Full PCM comparisons and existing wrap/extreme-input tests cover the change. This is not independent release approval.

Scoped C review for independent targeted LFO loops: the integration owner verified that target flags change only at note admission and every scratch-factor consumer selects the matching flag. Skipped arrays are therefore unread; targeted arrays still refresh all four entries, including inactive and zero-weight unity values, before static/dynamic pitch and amplitude paths use them. Slot reuse reselects the flags before rendering. No allocations, trust-boundary changes or arithmetic reordering are introduced. Full PCM comparisons and existing live/recycled-target reference tests exercise the boundary. This is not independent release approval.

Scoped A review for lazy MIDI batch ownership tracking: the integration owner verified that only private deduplication allocation is deferred. The first ID seeds the set before checking any matching candidate, every appended ID is recorded, and duplicate IDs still end the batch before ownership checks. The bounded operation array, channel/value matching and conflict rejection are unchanged. Full-file/rejection comparisons and the duplicate-owner regression cover these boundaries. This is not independent release approval.

Scoped A review for fixed-shape MIDI control snapshots: the integration owner checked that every private quantized field, including omissions, is defined as an own data property after unchanged control validation. All consumers read the four private allowlisted fields; onset merging now skips undefined values and writes only existing own fields on the full desired state. No untrusted spread or inherited getter/setter is introduced. Exact-file comparisons and partial-merge/prototype-accessor regressions cover the changed path. This is not independent release approval.

Scoped C review for folded operator amplitudes: the integration owner verified that the cache is an own Boolean on each existing pooled slot, reset at admission and every operator-level edit. It is reusable only with AM disabled; enabled AM leaves it invalid, and operator ramps bypass it until their final levels are ready. Static levels are fixed for a note, other frame scratch slots remain independent, and the multiplication order is unchanged. Exact PCM/state comparisons cover delay boundaries, modulation/depth changes, interrupted ramps and recycled slots. No new input trust or per-frame allocation is introduced. This is not independent release approval.

Scoped A/D review for in-place transport queue pruning: the integration owner verified that only the private dense pending-command array is compacted, writes target existing own slots at or before the read index, and removed tail references are truncated. The original strict time predicate, retained order, admission limits and terminal-event filtering remain unchanged; no timestamp ordering assumption or callback is introduced. Real-processor PCM/message comparisons and the bounded loop regression cover repeated expiry and reuse. This is not independent release approval.

Scoped A/D review for transport window eligibility: the integration owner verified that cached entries reference only private prepared tracks, whose beat bounds no longer mutate, and retain their original order. Both range endpoints key reuse; the key is invalidated before rebuilding. The list remains bounded by the existing score limit. Gates, command timing, reconstructed controls, density checks and ownership are not cached, so tempo edits and rejected preflights cannot reuse stale IDs or bypass admission. Real-processor PCM/message comparisons and a range-edit regression exercise the boundary. This is not independent release approval.

Scoped C review for noise-only frames: the integration owner checked that selection requires every nonzero static level to belong to a noise operator. Live controls cannot make a zero static level audible, and operator-level ramps retain generic rendering. The existing bounded hold-clock recurrence and carrier order are preserved without allocations or new input trust. Every operator value is checked for finiteness, including non-carriers whose noise ignores modulation, and phase validation precedes mixing. Exact PCM/state comparisons cover targeted LFO, pitch envelopes, control ramps and release/re-admission. This is not independent release approval.

Scoped C review for held-noise polarity: the integration owner checked that masking the Uint32 LFSR state yields only 0 or 1, and 2 * bit - 1 produces exactly the previous -1/+1 values. The clock recurrence, bounded tick loop, amplitude/finite checks and silent path are unchanged. Full PCM and state comparisons found no divergence across 54 scenarios. This is not independent release approval.

Scoped A/C review for single-point tempo snapshot reuse: the integration owner checked that the new validation-only registration applies only to newly returned, deeply frozen snapshots. Its undefined value retains validation identity through has() without enabling integral reuse through get(). Raw arrays, copies and BPM arguments still validate, transient single-point conversion results are not registered, and tempo arithmetic and inherited-field fallback paths are unchanged. Exact conversion/error comparisons and mutable-input coverage exercise these boundaries. This is not independent release approval.

Scoped A review for MIDI export validation field reuse: the integration owner checked that allowed and required field names and ordering are identical, lists remain private, and every event still passes the same own-data snapshot and value checks. Missing fields, symbol/unknown fields, accessor rejection and repeated mutable inputs were compared with the baseline; no caller getter ran. This is not independent release approval.

Scoped A/C review for format-0 MIDI assembly: the integration owner checked that the reused conductor array and channel tracks are private, append order matches the previous flatten/spread order, and event sorting, end markers, byte sizing and wire/byte budgets remain unchanged. Complete-file comparisons cover formats 0/1 and both expression policies. No caller-owned input is mutated. This is not independent release approval.

Scoped A/C review for MIDI import ownership tracking: the integration owner checked that each onset increments the bounded live count once, note-off either closes its pressed owner or transfers it to sustain, and pedal release closes only its sustain set before clearing it. At end-of-file, pressed queue suffixes and sustained releases are disjoint; closed prefixes are skipped. Byte/event budgets, orphan/zero-length rejection, expression ownership and warning counts are unchanged. Complete-result comparisons and the mixed closure regression cover both expression policies. This is not independent release approval.

Scoped A review for leaner live-note admission: the integration owner checked that only field names and immutable patch serialization keys are reused. Every options object and raw voice is still validated; unknown fields/accessors, timing and note bounds keep the same rejection paths. Skipping a singleton registry refresh cannot change eviction order, and multi-entry LRU updates, registration limits and disposal cleanup are unchanged. Actual processor-host message/PCM comparisons covered cache expansion and eviction. This is not independent release approval.

Scoped C review for integer exponential-table indexing: the integration owner checked that the unchanged guard admits only rounded integers in [-64, 64] before conversion, producing indices in [0, 128]. Nonfinite/out-of-range inputs still use the original fallback; the polynomial and table values are untouched. Exact scalar comparisons and targeted-LFO PCM comparisons found no divergence. This is not independent release approval.

Scoped C review for private sine parity: the integration owner checked the wrapped phase increments, bounded operator gains, modulation-index/control limits and feedback scale supplying this private kernel. Its rounded half-turn is integral and far inside Int32, so the low bit preserves positive and negative parity without changing the polynomial or gain multiplication. The public general-purpose sinPi() remains unchanged. Zero-gain handling, finite-state rejection and all buffer/voice bounds are retained; baseline PCM comparisons found no divergence. This is not independent release approval.

Scoped C review for settled effects output mixing: the integration owner checked that admitted sample rates keep the order ramp finite and its gain in [0, 1]. The unity-gain path retains final clean() sanitization; its finite result, including canonical positive zero, equals the previous zero-weight dry blend. Buffer validation, finite-input handling, delay writes and all intermediate transition calculations remain unchanged. Baseline PCM and internal-state comparisons found no divergence. This is not independent release approval.

Scoped A/C review for bounded expressive MIDI export: the integration owner reviewed the product-search lower bound and reuse of the local validated note map. Finite expression validation, strict improvement/tie handling, channel ownership checks, event budgets and wire encoding remain unchanged; the shared lookup is read-only inside track reconstruction. Complete-file comparisons covered all 32,259 half-unit lattice targets. This is a scoped source review, not independent release approval.

Unreleased generic-modulation review (integration owner, scoped C): only unused reads/arithmetic move behind the existing non-noise, nonzero-amplitude branch. Noise values remain available to later periodic operators; periodic modulation input order and feedback arithmetic remain identical. Every operator still advances/checks phase, the generic loop still checks operator/carrier output and the same noise clocks advance even while muted. Fixed operator/substep bounds, input validation, allocation and callback behavior are unchanged. Mixed-graph/control PCM comparisons and noise-state comparisons found no divergence. No scoped source blocker was found; this is not independent release approval.

Unreleased worklet queue-search review (integration owner, scoped A/B/C): all existing payload, frame, voice and capacity validation still precedes insertion. The dense private queue stays sorted through stable insertion, head removal and stable compaction. Binary search uses an upper bound on (frame, event priority), retaining admission-order ties, and indices remain within the unchanged 256-entry ceiling. Empty/small queues use the original scan without reading an inherited negative-index property. Late automatic-stop replacement removes its prior event before reinsertion; callback reclamation and terminal notification paths are unchanged. Complete admission/message/PCM baseline comparisons found no divergence. No scoped source blocker was found; this is not independent release approval.

Unreleased float-WAV-loop review (integration owner, scoped A/C): format dispatch follows the existing own-data/layout validation; float dither remains rejected. The specialized loop retains the ordered finite −1..1 sample bound, a single native sample read, frame/channel order and explicit little-endian output. Output size and channel count remain validated before allocation. Integer arithmetic/PRNG progression and success-only seed/frame commits are unchanged; failed output stays private. Baseline full/incremental byte comparisons found no divergence and no scoped blocker was found in source review. This is not independent release approval.

Unreleased paired-decimator review (integration owner, scoped C): each standard/high iteration still writes two ordered inputs through the same bounded duplicated ring before computing the first-stage output. The high second stage still runs after original input indices 3 and 7 (pair starts 2 and 6). Ring sizes, state allocation, tap arithmetic, finite-output handling, callback scheduling and public admission bounds are unchanged; the kernels receive separate engine-owned input/state arrays. Baseline comparisons preserved complete filter state and stereo PCM across all profiles. No scoped blocker was found. This is source review and targeted numerical evidence, not independent release approval or browser/device acceptance.

Unreleased idle-render/tempo/input-boundary review: IdleSecurity found no remaining supported-input checklist A/C blocker in the drained-FIR history-scan shortcut (filtering still advances), post-callback remainder clearing, immutable tempo prefix cache and effects offset validation before arithmetic. Its initial shared-array length-coercion finding was reproduced, fixed and rechecked: primitive safe-integer length validation precedes comparisons/traversal, retaining the 1024-point/8192-byte prefix ceiling. Review also covered mirrored histories, DC tails, callback bounds, native overlapping/subrange fills, exact frame accounting, prefix addition order, weak cache lifetime and rejected effects calls preserving delay/ramp state. It ran no runtime gates; this is scoped static inspection, not release approval or physical-device/listening acceptance.

The follow-up public tempo-conversion review also found no A/C blocker in reusing exact privately registered multi-point snapshots after BPM validation. Raw arrays, copies and proxies still validate; immutable data may share identity, now documented in the exported normalizer comment and README. This was read-only applied-source review, not runtime or release approval.

The follow-up incremental WAV review found no A/C regression in reusing private dither working storage with a success-only scalar seed commit. Rejected chunks retain accounting/noise continuity; metadata-triggered nested admission commits before the outer transaction begins. Native samples are still captured once, emitted bytes retain separate ownership, and channel/chunk/RIFF32 bounds are unchanged. IdleSecurity performed read-only applied-source inspection; runtime gates are recorded separately in CHANGELOG, not asserted by this review.

The sequence lower-bound follow-up found no scoped A/C regression. IdleSecurity confirmed that negative descriptor lengths reject before array traversal/snapshot allocation, while Number.isInteger short-circuiting still prevents object coercion and valid zero/upper bounds remain unchanged. This closes silent malformed-input acceptance, not a demonstrated resource-budget bypass. Review was read-only and ran no gates; the integration owner separately exercised all five public preparation/capacity/render entrypoints.

The unchanged-LFO-rate follow-up found no scoped A/C regression. IdleSecurity confirmed that only a genuine first rate change enables accumulated phase; controls still validate before application, other supplied fields are not skipped, and requesting the current rate during an existing live ramp still cancels it. No render-loop work, allocation, message shape or input bound was added. This was read-only applied-source inspection, not runtime or release approval.

The prepared-sequence-voice follow-up found no scoped A/C blocker. IdleSecurity confirmed that reuse is restricted to exact members of the existing private WeakSet after deep freezing, including separately frozen LFO target tuples. Raw values, frozen copies and proxies still normalize freshly; named lookup retains native Map operations. Shared patch data does not share slot-local oscillator/control state, and all short/long/render admission bounds remain unchanged. The weak registry does not keep unused patches alive. Review was read-only applied-source inspection and ran no runtime gates; it is not release approval.

The terminal-sequence-queue follow-up found no scoped A/C blocker. IdleSecurity confirmed per-renderer queue ownership, final clearing only after PCM rendering and frame accounting, unchanged cursor-based diagnostics/capacity, idempotent cancellation and unchanged return/abort dispatch. Completion invokes no new public cancellation hook or user callback; caller events, other iterators, shared patches and PCM are not mutated. Cleanup releases bounded queue-only references, not necessarily immediate GC or patches retained by callers/pooled slots. This was read-only applied-source inspection without runtime gates or release approval.

The JSON-byte-check follow-up found no scoped A/C blocker. IdleSecurity confirmed that the three-bytes-per-UTF-16-unit upper bound only skips certainly bounded inputs; larger text retains exact UTF-8 checking and oversized code-unit counts still reject before parsing. Canonical v1–v8 bank conversion validates ASCII names/enums, fixed keys and finite numbers before export; the null-prototype copier still excludes inherited JSON hooks. Exact-limit inclusion, byte ceilings, detached ownership and schemas remain unchanged. Review covered the applied guards, canonicalization and new/existing boundary and export-hook regression sources. It was read-only inspection without runtime gates or release approval.

The default-note-options follow-up found no scoped A/C blocker. IdleSecurity confirmed that the validation bypass requires strict identity with the module-private frozen complete default; caller objects, frozen copies and proxies retain their descriptor boundary. Admission immediately destructures primitive values without exposing or retaining the shared object. Defaults, ID/admission ordering and voice/fade bounds are unchanged, with no new per-frame work. Review was read-only applied-source inspection without runtime gates or release approval.

The subscription-ownership follow-up found no scoped lifecycle/input-boundary blocker. IdleSecurity confirmed clearable private callback records, idempotent unsubscribe, success/failure disposal clearing the shared Set, and restartable close preserving subscriptions. Dispatch retains ordered snapshots, skips removals, defers additions, preserves plain-call receiver/legacy ordering and isolates exceptions; the empty-registry guard does not change nonempty dispatch. Lookahead stop removes its record without clearing the callback needed for restart. Review was read-only applied-source inspection without runtime gates or release approval; executing callbacks may remain live until return.

The designer-file-ownership follow-up found no scoped UI blocker. IdleSecurity confirmed generation/lifetime checks after reading but before parsing or retriggering, stale error suppression, current-only chooser cleanup, and pagehide invalidation that survives pageshow. File size still rejects above 16 KiB before buffering; the model retains separate exact UTF-8 and strict schema checks. Independent audio generations and DSP are unchanged. Started reads are ignored rather than cancelled, without a new aggregate in-flight quota. This was read-only UI inspection without runtime gates or release approval.

The playground-DX7 follow-up found no scoped UI/input-boundary blocker. IdleSecurity confirmed that merged candidates commit through whole-bank validation before local lookup/option changes, preserving prior voices on rejection and the distinct default brass during initialization. Generation/lifetime checks suppress stale commits, errors and chooser cleanup; the 4104-byte pre-read bound remains, without cancelling started reads. The FrozenVoice input declaration adds no runtime trust: frozen entries still undergo full validation and detached copying, while CompleteVoiceInput remains unchanged. This was read-only applied-source inspection, not runtime or release approval.

The command-cancellation follow-up found no scoped cancellation/input/lifecycle blocker. IdleSecurity confirmed intrinsic signal authentication and shadow-accessor bypass, exact abort-reason preservation including null, and fallback allocation only when the native reason getter is absent. The private omitted-outcome marker is used only by cancellation; acknowledgement, timeout and lifecycle settlement still supply defined outcomes. Idempotent settlement, shared timer/listener cleanup, waiter/counter bounds and registration-race checks remain intact. Cancellation still affects only its waiter, not sibling waits or command receipt outcomes. This was read-only applied-source inspection without runtime gates or release approval.

The Worker-handoff follow-up found no scoped handoff/lifecycle/input blocker. IdleSecurity confirmed release of captured payload bindings after native cloning and on cleanup, with readiness/settlement guards preventing reuse. Chunk bytes clear in finally before awaiting, including synchronous throws, only from the private mutable own-data copy; incoming messages and sink-owned buffers remain unchanged. Intrinsic accounting precedes handoff, while metadata, backpressure, post-await cancellation checks, error propagation and no-wait abort behavior remain intact. This removes identified library references, not independently held sink data or a guarantee of immediate GC. Review was read-only applied-source inspection without runtime gates or release approval.

The Worker caller-input/observer follow-up found no scoped lifecycle/input/reentrancy blocker. IdleSecurity confirmed that inner closures capture validated settings rather than the complete options copy, and terminal paths drop private sink-copy, receiver and observer bindings only after rollback invocation and terminal notification. Local callback snapshots preserve executing notifications under reentrant cancellation; settlement guards prevent resumed async paths from accessing cleared bindings. Original objects/receivers, first-failure identity and non-awaited rollback remain unchanged. This was read-only applied-source inspection without runtime gates or release approval; reference clearing is not an immediate-GC guarantee.

The terminal-stream follow-up found no scoped lifecycle/input/reentrancy blocker. IdleSecurity confirmed eager score/density checks, cancellation before cleared-score access, and queue construction before snapshot release. Stop drops private score/normal-observer bindings without weakening ID/queue teardown; failure handling snapshots its observer before cleanup. Only an in-flight startup retains the separate final error observer, cleared before rejection notification or on successful/cancelled settlement. Existing callback-throw propagation and first-error identity for nonthrowing observers remain. This was read-only applied-source inspection without runtime gates or release approval; release of host references does not guarantee immediate GC.

The lookahead-disposal follow-up found no scoped lifecycle/input/reentrancy blocker. IdleSecurity confirmed that stop retains restart callbacks, while idempotent disposal clears only its private callback/observer bindings in finally, including when reporting throws. Context/stop/pump snapshots preserve an executing operation's final failure notification under reentrant disposal. Existing exception boundaries, input validation and batch/gate limits remain; disposed/generation checks prevent late startup from restoring the cleared observer, and post-callback running checks prevent admission after self-disposal. This was read-only applied-source inspection without runtime gates or release approval.

The inactive-targeted-LFO follow-up found no supported-input A/C blocker. IdleSecurity confirmed eager finite/bounded depth and target validation even when inactive, exact-unity scratch refresh before pitch glides read targeted factors, and unchanged delay/analytic/global/live-rate clocks. Unconditional live-clock advancement, numerical guards and bounded work remain; only redundant inactive-factor arithmetic is skipped, with no allocation, parser, protocol or signature change. Direct mutation of internal target arrays was outside this supported-input scope. This was read-only applied-source inspection without runtime gates or release approval.

The unity/zero-weight target-mask follow-up found no supported-input A/C blocker. IdleSecurity confirmed complete validation of detached frozen tuples before classification, reset/copy of all four weights on every admission, shared-factor selection for all-unity masks in static/dynamic pitch and AM, and continued unity refresh for nonuniform masks. Depths, modulation and targets remain eagerly finite/bounded even when inactive; clocks, work bounds and numerical-containment checks remain unchanged, without new allocation or persistent state. Caveat: direct nonfinite injection into internal LFO/target state can be masked by zero weights or shared-factor paths rather than counted; internal mutation is unsupported, and these checks are not comprehensive corruption detection. This was read-only applied-source review, without runtime gates or release approval.

The musical error-callback follow-up found no scoped lifecycle/input/reentrancy blocker. IdleSecurity confirmed that only private Transport/Arrangement error bindings clear on permanent disposal, including through gate-stop failures; pause/stop and natural completion retain restart callbacks. Failure paths snapshot their listener before normalization/cancellation, preserving plain-call receivers, existing exception behavior and the executing notification under reentrant disposal. Public snapshots/caller objects remain unchanged; eager own-data validation and generation/disposed guards preserve bounds, stale-start suppression and rejection propagation. This was read-only applied-source review without runtime gates or release approval; reference clearing is not an immediate-GC guarantee.

The Performance/MIDI callback-ownership follow-up cleared only private bindings while retaining listeners for entered observations, pending port opens and failed forced-release retries. Scoped review identified intermediate notification losses across channels/inputs; entry/disposal-wide snapshots resolved them. Review also found pre-existing refresh continuation after error-callback disposal; a terminal cutoff now prevents later input attachment/opening instead of retaining invalid post-disposal work. IdleSecurity's final read-only review found no remaining lifecycle/input/reentrancy blocker, with eager validation, scoped ownership, receiver and exception boundaries intact. It performed no runtime gates and is not release approval.

The zero-pitch-factor follow-up found no supported-input A/C blocker. IdleSecurity confirmed unconditional start/end evaluation in the original order, equivalent positive unity for both signed-zero exponents, and the unchanged exponential path for nonzero/nonfinite starts. Substep progression still computes/advances when a zero start has a nonzero end; validation, containment, all clocks and frequency/glide/envelope ramps remain unchanged. No allocation/state was added, and default static voices do not enter the dynamic-pitch path. This was read-only applied-source review without runtime gates or release approval.

The lazy fixed-Hz ratio follow-up found no supported-input A/C blocker. IdleSecurity confirmed that only unused, side-effect-free interpolation becomes lazy in frequency sampling/retuning; voice/control validation remains eager for both ratios and fixed Hz. Ratio timelines, logical tuning updates for voices/fades, used-branch arithmetic, frequency/pitch/substep progression, caps and containment remain unchanged. No allocation/cache/traversal was added. Unused corrupted internal ratio state was already excluded from fixed-Hz arithmetic; this is not a broader internal-state validation guarantee. The review was read-only without runtime gates or release approval.

The zero-swing chorus follow-up found no supported-input A/C blocker. IdleSecurity confirmed the same centred delay for both signed zeros, unchanged nonzero-swing arithmetic, and continued phase, delay, feedback and reverb progression even during dry bypass. Eager own-data/range validation, bounded ramps, buffer authentication and sanitation remain intact; no state/allocation/work-bound expansion was added. Caveat: directly corrupting private phase to NaN now avoids invalid delay reads while swing is zero; it is not publicly reachable, FX has no error counter, and output sanitation remains. This was read-only source review without runtime gates or release approval.

The effects API observer-ownership follow-up found no scoped ownership/lifecycle/input blocker. IdleSecurity confirmed that first disposal clears only the private observer before all node/no-node cleanup, while terminal paths snapshot it before cleanup or potentially reentrant error conversion. Entered notifications/original thrown values and synchronous callback isolation remain intact; stale handlers cannot revive the cleared binding, and recoverable replies keep the observer active. Validation, message allowlists, secure same-origin URLs and borrowed-context ownership are unchanged. The deterministic regression covers terminal notifications, frozen events, strict receiver and teardown-before-callback with throwing/reentrant observers. This was read-only review without runtime gates or release approval; clearing references does not imply immediate GC.

The invariant WAV-format follow-up found no supported-input A/C blocker. IdleSecurity confirmed that per-call flags derive from a private validated three-format Layout that is neither exposed nor mutated, so they cannot become stale during encoding. Sample capture remains once per value with finite [-1,1] validation before writing; quantization/endian order, Float32's 58-byte header and unaligned data offset, PCM24 sign/padding bytes, frame/channel/RIFF limits, output allocation and success-only frame/dither commit are unchanged. Existing format, split-parity, late-rejection, dither and hostile-metadata regressions remain applicable. Caveats: forged private Layout mutation violates internal preconditions, and shared PCM is captured per sample, not as a whole-buffer atomic snapshot. This was read-only scoped review without runtime gates or release approval.

The terminal chunk-render ownership follow-up found no supported-input A/C blocker. IdleSecurity confirmed error snapshots precede release of private Synth/buffer/signal references, repeated cancellation preserves diagnostics, and terminal guards prevent cleared-reference access. Stack-local live buffers preserve final returned arrays/views; capacity/frame/event/error metadata remain available to Worker/full-buffer callers. Natural completion uses private cleanup, while existing return() and observed-abort dispatch through the public method remains intact. Validation, render/work bounds and numerical containment are unchanged, including empty scores' positive 10 ms tail. Caller PCM and signal listeners are untouched, and the regression covers all four terminal paths. This was read-only scoped review without runtime gates or release approval.

The live-edited positive-sustain follow-up found no supported-input A/C blocker. IdleSecurity confirmed that the shortcut requires a held, post-attack/decay envelope with no sustain-rate decay and dB strictly above the floor; every substep therefore uses the identical edited fastExp2 expression, not the bit-distinct unedited sustain gain. Static-zero classification remains earlier, while floor, moving, sustain-rate and release paths stay unchanged. Release, later ADSR edits and pooled admissions invalidate steady gains; eager validation, numerical containment and traversal ceilings remain intact. No fields/allocation were added. Direct mutation of private envelope fields without invalidation can leave caches stale and remains unsupported. This was read-only applied-source review without runtime gates or release approval.

The priority-pruning follow-up found no supported-input A/C blocker. IdleSecurity confirmed that the selected voice already has the lowest eligible priority encountered, so a strictly higher-priority candidate cannot replace it under any policy. Equal/lower-priority comparisons, quietest bookkeeping, release/age ties and refusal stay unchanged. Skipped audibility/envelope/ramp helpers perform only reads/math, with no clock advancement, mutation, callback or containment check omitted. Eager validation/refusal still precede ID consumption and pool mutation; victim lifecycle, fade bounds and render-time numerical containment remain intact. No allocation/state/traversal was added. Directly corrupted internal voices remain unsupported; audibility was never an input-validation boundary. This was read-only applied-source review without runtime gates or release approval.

The steady-audibility-gain follow-up found no supported-input A/C blocker. IdleSecurity confirmed that only gainsSteady permits reuse of constant Float64 frame gains; otherwise evaluation uses the current admission time. Admission/release/ADSR invalidation stays complete, including normal sustain's precomputed arithmetic and edited sustain's distinct exponential. Static-zero carriers contribute the same finite zero, while operator/expression/layer ramps, carrier order, tie-breaking, bounds and render containment remain unchanged. No state, explicit allocation or traversal was added. Direct corruption of private gain arrays or validity flags remains unsupported; they are not public validation boundaries. This was read-only applied-source review without runtime gates or release approval.

The expressive-MIDI quantization follow-up found no scoped A/C blocker. IdleSecurity confirmed that validated CC7×CC11 candidates are exact integers in 0..16129: an error below half a unit cannot improve, and exact half-unit ties retain the first winner through descending CC7 order and strict improvement. The IEEE-rounded target, signed-zero handling, full own-data/finite validation, wire serialization and export budgets remain unchanged. Unavailable nearest products still use the bounded full search. No state or allocation was added, and work remains capped at 127 iterations. This was read-only applied-source review of quantization, validation, serialization/bounds and boundary regressions, without runtime gates or release approval.

The pooled-sustain admission follow-up found no supported-input A/C blocker. IdleSecurity confirmed that sustain is validated, detached and deeply frozen before private prepared identity grants trust. Fresh/null or different slot identities recompute canonical dB/gain; identical identity reuses only operators not marked live-ADSR-edited. Edits mark dirty before writing, and admission inspects flags before clearing them. Release, normal/error retirement, fade recycling and panic preserve these constants/flags; admission completes before reentrant callbacks. Note-, velocity- and rate-dependent state remains fresh, with no new fields, retention, allocation or unbounded work, and existing render containment stays intact. Direct internal array/flag corruption can invalidate reuse but no supported public-input path was found. This was read-only applied-source/identity/lifecycle/bounds/regression review without runtime gates or release approval.

The pooled-envelope-coefficient follow-up found no supported-input A/C blocker. IdleSecurity confirmed reuse requires identical privately prepared identity, pristine operator state and exactly zero/omitted rate key scaling; every positive value, including Number.MIN_VALUE, recomputes. Zero and negative-zero scaling produce an exact unit multiplier, leaving canonical durations note-independent. The owning Synth has no supported sample-rate/oversampling mutation, and rendering/recycling do not modify cached coefficients. Live ADSR marks dirty before writing; admission checks flags before clearing them. Original arithmetic/caps, signed-zero results, timeline/gain/release/history reset and callback ordering remain unchanged. Extreme coefficients retain original IEEE results, including possible overflow; this does not promise universally finite internal coefficients. Existing finite-output/error containment remains intact, with no new fields, allocation or retention. Direct readonly/internal-state mutation is unsupported. This was read-only applied-source/identity/lifecycle/bounds/regression review without runtime gates or release approval.

The Worker-cloned-patch follow-up found no supported-input A/C blocker. IdleSecurity confirmed that the sole production caller supplies owned native-message clones to synchronous preparation: no caller aliases, Proxy traps or callbacks can mutate accepted cloned fields between occurrences. First encounters still fully normalize, deeply freeze and privately brand a new snapshot before cache insertion; invalid data cannot populate it. Accepted voice parameters are detached scalar/plain-array data, not SAB-backed mutable values. The invocation-local WeakMap follows array-budget/key validation, is bounded by distinct note voices and is not retained by the renderer. Distinct identities remain distinct. All public factories retain the uncached raw path, preserving per-occurrence and cross-call mutation/Proxy semantics. No protocol marker, option, budget, parser or render-control relaxation was added. The owned-clone factory is internal, absent from the public core facade/package subpath exports, and requires its documented provenance precondition. This was read-only applied-source A/C review without runtime gates or release approval.

The immutable-score preflight follow-up found no supported-input A/C blocker. IdleSecurity confirmed that only newly created, successfully validated frozen output arrays become private weak keys; raw/frozen-lookalike/Proxy/cloned/independent-module arrays cannot inherit membership. Options and native Map branding validate before lookup; hits enforce event/horizon and short note/slot limits, while ineligible conversions fall through the original rejection path. Snapshot values contain immutable scalars, frozen wrappers, deeply frozen prepared voices and copied/frozen control tuples/ADSR objects. Engine, tuning, frame, chunk and signal validation stays fresh; no render plan, queue, DSP, callback or PCM state is cached. The root-to-array backreference creates no independent strong key registry. Caller-held arrays may intentionally retain the metadata wrapper; otherwise-unheld cycles remain eligible for collection. Cancellation's private-state release is unchanged. This was read-only applied-source A/C review without runtime gates or collection-timing verification, not release approval.

The immutable-control dispatch follow-up found no supported-input A/C blocker. IdleSecurity confirmed that only successfully validated, fully copied/frozen output roots enter the private WeakSet; raw inputs, frozen lookalikes, Proxies, clones and independent-module snapshots cannot forge membership. Own-data/accessor checks, scalar/tuple/ADSR bounds and empty/glide/ramp dependencies remain intact. Native message clones validate before Worklet admission/queueing; only local dispatch reuses their immutable data. Validation still precedes inactive-note lookup, context-specific MIDI restrictions still run, and current per-note clocks, ramps, envelope anchoring and coefficients are never cached. Weak membership stores no strong payload values. This scoped static review ran no runtime gates, verified no GC timing and is not release approval.

The scalar-ADSR-bound follow-up found no supported-input A/C blocker. IdleSecurity confirmed that replacing temporary bound tuples with scalar ternaries preserves inclusive a/d/r 0–10, s 0–1 and sr 0.01–100 limits. Signed zero and positive subnormals retain their previous acceptance; sr below its minimum still rejects. Non-numbers, NaN and infinities reject without coercion. Optional-sr presence, the single ownKeys snapshot, descriptor/accessor checks, read/error order, copying, deep freezing and private snapshot registration are unchanged. No supported-input validation bypass was found. This scoped static inspection ran no runtime gates and makes no allocation, GC or release-approval claim.

The final-Performance-composition follow-up found no supported-input A/C blocker. IdleSecurity confirmed that the private values builder only composes owned part/key data; public controls still validate before entering that state. Final retarget validation, including original-gate baseline resets, precedes ownership mutation. Final admission validation precedes dispatch within existing failure cleanup. Key and part updates retain complete preflight and rollback. Registry replacement does not replace a held gate's baseline; foreign-module consumers still receive ordinary fully validated data without a cross-module trust assumption. No cache, retained live-state alias, callback opportunity or unbounded work was added. This scoped static inspection ran no runtime gates and is not release approval.

The fixed-shape-Performance follow-up found no supported-input A/C blocker. IdleSecurity confirmed that supported patch-loading paths produce four dense immutable operators; explicit baseline literals retain fresh tuple/root ownership and the same immutable ADSR children. Retargeting mutates only its fresh owned temporary, preserving glide precedence/property order before the original reset/final-validation and gate-mutation boundary. Original-gate defaults, rollback, reentry guards, cleanup and foreign-module validation remain intact. The final adjustment preserves the original first feedback dereference when a configured named patch has been removed. No cache, shared mutable tuple or exported contract was added. This scoped static inspection ran no runtime gates, excludes arbitrary built-in corruption and is not release approval.

The Worker-owned cloned-controls follow-up received a final-source scoped A/C review with no findings. Successful full validation precedes local identity-table insertion; only detached deeply frozen outputs are reused, with no raw-clone branding or serialized trust marker. The controls table is lazy, bounded by the existing event budget and synchronous preparation lifetime, and does not escape into rendering. Public raw/frozen-lookalike/foreign inputs retain per-occurrence validation/detachment; event descriptors, contextual/resource checks, error precedence, current-clock DSP application, ramps and ADSR reanchoring remain fresh. Existing validator freezing makes the removed outer freeze redundant. No exported contract, protocol, dependency or global raw-input cache was introduced. This static review ran no runtime checks and is not release approval.

The static sequence-event schema follow-up received a final-source scoped A/C review with no findings. Four private readonly field-name lists preserve the original allowed/required contents, order and branch selection. The validator only reads them and never exposes references to callers or input callbacks; reentry cannot mutate shared validation state. as const is compile-time only, but no supported reference-escape or mutation path exists. Initial/later type-descriptor behavior, rejection precedence, raw freshness, existing immutable-score/Worker-clone identity boundaries and fresh DSP application are unchanged. Added module lifetime is fixed string metadata, not caller data. This static review ran no runtime gates, excludes arbitrary built-in corruption and is not release approval.

The private preparation-default/options-schema follow-up received a final-source scoped A/C review with no findings. Only an exact unexported frozen complete library default bypasses redundant option normalization, following the existing Synth convention; no reference escapes. Its own voices: undefined prevents inherited registry access. Caller objects, empty/frozen/lookalike/Proxy/foreign inputs retain full validation, and native Map checks plus applicable score limits still precede metadata reuse. Settings, frame budgets, signal and DSP boundaries remain fresh. Shared schema lists are private/read-only in use and contain no caller data. The consumer regression restores any prior prototype descriptor in finally before assertions/rendering, with no asynchronous gap while modified. This static inspection ran no runtime gates and is not release approval.

The owned-absent-registry/render-schema follow-up received a final-source scoped A/B/C review with no findings. IdleSecurity confirmed that only strict undefined, taken from already-inspected own-data options or the beat helper's registry argument, selects the existing private complete preparation default; nonundefined registries retain fresh schema/native Map checks. Outer caller/sink/signal/settings validation and exact error order remain intact. Private readonly render field lists preserve contents/order and both full-render scans, without escaping references or retaining caller data. Event, score/context, frame and signal limits remain fresh. Secure same-origin Worker loading, ready/start/ACK validation, exact byte/frame accounting, sink backpressure, cancellation and cleanup are unchanged. The reviewer inspected the three final changed files and supporting Worker entry, ran no runtime/build/test gates, excluded arbitrary built-in corruption and did not grant release approval.

The beat-event schema follow-up received a final-source scoped A/B/C review with no findings. IdleSecurity confirmed exact private list contents/order, unchanged initial/later type-descriptor behavior, invalid-type fallback, required-field/error precedence and numeric/context/registry checks. sequenceOwnData only reads schema arrays and does not expose them, so identical allowed/required control/stop lists may share references safely. Fixed module-lifetime string metadata retains no caller data; frozen output ownership remains unchanged. Worker-host schema/progress experiments did not establish reliable whole-export allocation gains and were rejected; original per-message literals and double-conditional validation were restored. Host state/progress/byte accounting, ACK/backpressure and lifecycle remain intact. The only retained host edit documents that imports create no Worker. The final recheck inspected retained beat schemas, restored host validation and supporting validator/lifecycle locations, superseding the earlier candidate-host disposition. It ran no runtime/build/test gates, excluded arbitrary built-in corruption and did not grant release approval.

The owned-default-tempo follow-up received a final-source scoped A/C review with no findings. IdleSecurity confirmed that unconditional scalar BPM validation still precedes both omitted-map construction and private metadata lookup. Only strict undefined selects the directly constructed point containing fixed beat zero and that validated BPM. Every call still returns a fresh frozen array and point with identical own values and absent optional fields; no identity sharing, new trust gate, cache or single-point offset registration was introduced. Provided maps retain full own-data, ordering, curve/slope, numeric and ownership checks, with private offsets only for multi-point outputs. Query arithmetic, uncached single-map behavior, inherited optional-field reads and existing error precedence remain unchanged. The reviewer inspected normalization, offset lifecycle, conversion helpers and caller references, ran no runtime/build/test gates and did not grant release approval.

The owned-default-meter follow-up received a final-source scoped A/C review with no findings. IdleSecurity confirmed that the private complete frozen 4/4 marker never escapes: omitted normalization returns a fresh frozen two-own-field copy, while omitted conversion helpers only borrow its fixed scalar values internally. Every provided signature, including previous normalized outputs and frozen/proxy/foreign lookalikes, retains full own-data/numeric validation and copying. Beat validation still precedes meter inspection in beat-to-bar conversion; provided-meter validation still precedes position inspection in the inverse. Position bounds, ordered arithmetic, signed-zero behavior and fresh bar/beat ownership remain unchanged. Fixed module metadata captures no caller data; no cache, caller-output brand, output sharing or DOM/Worker side effect was introduced. The reviewer inspected marker references, normalization/conversions, supporting validators and caller references, ran no runtime/build/test gates and did not grant release approval.

The transport-schema follow-up received a final-source scoped A/C review with no findings for the retained meter/position slice only. IdleSecurity confirmed exact private readonly field names/order and required fields, and that sequenceOwnData only reads these lists without mutation, storage or reference escape; using one list for identical allowed/required slots is safe. Descriptor inspection, rejection precedence, meter/position bounds, arithmetic, private-default non-exposure, fresh frozen outputs and full provided-input copying remain unchanged. The two fixed string-name lists retain no caller data and introduce no trust brand, cache or DOM/Worker side effect. Tempo-point schema experiments were not retained; their original per-point literals, offsets and validation remain untouched. The reviewer inspected the retained source, supporting validator and checklist A/C, ran no runtime/build/test gates and did not grant release approval.

The immutable-tuning-table follow-up received a final-source scoped A/C review with no supported-input findings (src/core/tuning.ts SHA256 158a888f2561fa6ca405a3deae85bbf562c647eb0aedf810a566aa80c6f161af). Root/prototype/unknown-field/own-data/reference-Hz validation always precedes table membership. A private WeakSet initially recognizes the existing frozen zero table; all other entries are copied, fully validated output tables registered only after freezing. Raw inputs, externally frozen arrays, Proxies, foreign-instance arrays and structured clones cannot inherit membership; unknown tables retain dense shape, all 128 own descriptors and finite cents bounds. Known tables still copy into fresh frozen arrays and roots remain fresh/frozen. Weak metadata retains no caller roots or live DSP state; interpolation, frequency arithmetic, tuning application, protocols and DSP clocks are unchanged. A consumer regression protects caller mutation and invalid roots carrying known leaves; independent Node/Chrome PCM/WAV and genuine trusted-click Worklet/Worker evidence is recorded in CHANGELOG. Arbitrary built-in corruption is outside this scoped review. No release, device/listening or general runtime-speed approval is implied.

The bounded-MIDI-VLQ follow-up received a final-source scoped A/C review with no supported-input findings (src/core/midi-file.ts SHA256 3bb7d192df3a88e1fe02f94fe272dbaf7a86ec51e00dd69944dd001168e5ed1d). The unchanged safe-integer/nonnegative/28-bit guard precedes &127 and unsigned seven-bit shifts, which operate only on relative deltas; cumulative ticks, including above signed 32-bit, remain ordinary numbers. Original event/byte budgets, size preflight, allocation, ordering, normalization and native result.set payload copying remain intact. A generic payload-copy experiment passed correctness proofs but regressed actual expressive-export timing and was rejected; the final disposition covers bitwise-only source. Public width/max/overflow/cumulative-tick regressions and independent full-byte Node/Chrome/project/PCM/WAV/original-Worker proof are recorded in CHANGELOG, with existing expressive warning and reexport behavior preserved. The reviewer ran no runtime/build/test gates; arbitrary built-in corruption is excluded. This is not release, physical-device/listening or whole-API-speed approval.

The noncenter-stereo-pan follow-up received a final-source scoped A/C review with no supported-input findings (src/core/synth.ts SHA256 4c74245bf5f07576793dba887bcb4b6b93e32384b7c024050c3862916d2ee4e4). Three private per-slot scalars retain only a last noncenter effective-pan key and raw trig, initialized with NaN to force required first computation. Center ±0 neither reads nor changes cache fields; endpoints never read unused factors. Returning to the same last noncenter key is safe across centered intervals, note/voice-pan decompositions, pooling, detached fades and sample rates. Fresh gain, literal-zero branches and left-associative products remain unchanged, as do admission/automation writers, validation, clocks and bounded voice storage. No caller references, trust brand or unbounded registry were introduced. Final Node/browser/Worker/worklet proofs, package gates, consumer regression and the measured moving-pan cost are recorded in CHANGELOG; the first center-key candidate was superseded rather than its regression hidden. Arbitrary private-state/built-in corruption is excluded. The reviewer ran no runtime gates; this is scoped static review, not release approval.

The tempo-prefix-context repair received a final-source scoped A/C review with no supported-input findings (src/core/transport.ts SHA256 4acc4dc447fda9bc5e97e89d1e814965a5edc978971444623e288e71daf9afa0). Frozen own point data does not make inherited optional fields or an inherited terminal array index immutable. Eligibility is established after input/slope callbacks, before unchanged prefix additions; dirty construction writes a permanent private NaN marker only after those additions, preserving normalization getter/error behavior and identity reuse. Queries require private membership, an eligible marker and a clean current context before any cached prefix read; the marker cannot enter output arithmetic. Own-property presence checks invoke no accessors, cover both terminal-index prototypes, and reject changed Array.prototype parent identity. Raw/proxy queries gain no extra length reads, and original fallback/inverse formulas, BPM-validation precedence, bounds, output prototypes/own-field shape and default behavior remain intact. No new registry, caller reference, message surface, dependency or metadata allocation was added. Node compiled/dist context and full-payload proofs, native Chrome context/Worker/Transport proof, public prototype-transition regression and full behavioral/type/security gates were run by the integration owner or explicitly delegated runtime owners, not the static reviewer. An initial cross-context Proxy fixture failure was preserved and corrected without changing valid baselines. The inverse-span proposal was rejected and is not covered as an applied feature. This is scoped static review with runtime evidence recorded in CHANGELOG, not release approval or physical-device/listening acceptance.

The voice-ownership/pooled-timing repair received an applied-source scoped A/C review with no supported-input findings (src/core/synth.ts SHA256 82b082da082b019e1dc0a36bf12ae4ef0bf301d9241a79e88b5ae5c4dd91938e; src/voices/normalize.ts SHA256 35e7db1d4558f73d374b63026ac7f808bf770c80f2c622f7f962d02a770c484f). Own-presence freeze checks exclude inherited foreign objects while preserving approved-own validation, detached deep freezing, snapshot shape and private identity registration. One bounded private slot boolean plus sticky per-operator current-context checks prevent inherited sustain/rate changes or earlier context-changing getters from leaving reusable timing. Required-own sustain constants and live envelopeEdited DSP semantics remain separate. The review identified an existing spare leak on inherited getter exceptions, additionally exposed to raw inputs by own-only freezing; actual reproduction confirmed pool exhaustion. Cleanup now covers unpublished initialization only, restores the spare, resets the factory voice-identity sentinel and eligibility, and rethrows the exact original value. Partial coefficient identity cannot survive failure. Stealing/publication/terminal callbacks stay outside cleanup; IDs/sequences remain monotonic because initialization may have invoked user code. No registry, caller reference, protocol surface, dependency or per-note typed-state allocation was added. Independent Node/native context and repeated-failure/partial-initialization proofs, full clean-byte comparisons, consumer regressions and full behavioral/type/security gates are recorded in CHANGELOG; runtime owners, not the static reviewer, executed them. Raw/trusted inherited-glide behavior was measured as equivalent and deliberately left unchanged. Internal pool corruption/native-intrinsic replacement remain excluded. This is scoped static review, not release approval or device/listening acceptance.

The prototype-presence guard follow-up received applied-source scoped A/C review with no supported-input findings (src/core/transport.ts SHA256 9732400b98bde9707f62ec4becbf5d823c993f9a0f9603d9bf1d00a96c71bf69; src/core/synth.ts SHA256 b8d7bcfc84b75ab4704374dec445cec800d08dba590c7da5588b9d3ead5e687e). Native Object.prototype has an immutable null parent, so presence checks remain equivalent to own checks and invoke no getters; exact array-parent verification precedes the terminal lookup. The numeric non-positive shortcut requires private multi-point-map membership and returns the original first-segment +0 without optional reads, even for dirty contexts. Explicit type gating preserves unsupported coercion/error ordering and NaN paths. Dirty markers, callback-sensitive sticky eligibility, rollback and publication boundaries are unchanged. Native-intrinsic replacement and private-state corruption remain outside the reviewed assumptions. IdleSecurity performed read-only source review, not runtime verification or release approval; actual output and cost observations are recorded separately in CHANGELOG.

The guarded inverse-span follow-up received applied-source scoped A/C review with no supported-input findings (src/core/transport.ts SHA256 e687714e11e9a489fdee54f2f667707576b951049851456efa55e040176dcdd3). One existing private vector holds N unchanged prefixes and N−1 exact full spans, bounded by 1024 points / 2047 cells / 16,376 logical bytes; single-point/default paths still allocate no vector. Private identity, clean construction marker, numeric input and clean current prototype context gate reuse. Dirty or observable inherited/coercive/proxy cases retain original traversal. Prefix addition and successive inverse subtraction retain their original order; the shared helper computes slope before reading point.beat, preserving raw getter/error/coercion ordering. Only immutable own-data/verified-absent reads can remain when the eligible terminal integral is omitted. Exceptional normalization cannot register incomplete metadata; no query buffer, extra registry or caller reference was added. Constructor interception observes logical capacity only, not native heap/GC behavior. Native-intrinsic replacement/private-state corruption remain excluded. IdleSecurity performed read-only applied-source review, not runtime gates or release approval; actual full-output, cost and storage tradeoffs are recorded separately in CHANGELOG.

The inherited-index-accessor repair received applied-source scoped A/C review in two passes. The first pass found additional tuning-table/default, arrangement score-collection and lookahead-length trust-anchor defects; these were repaired and exercised before the round's 517-test/type/static gates passed. The second pass also reported candidates involving Performance part ownership, MIDI-adapter ownership, arrangement reserved gain controls and asset-inventory copy paths. They remain unresolved pending consumer reproduction and repair; the earlier same-realm/internal-bookkeeping rationale was not evidence that those invariants hold and is withdrawn. Optional-key output writes and uncached terminal-index reads were separately recorded. This is scoped review, not release approval; CHANGELOG records the runtime coverage and the round's reconstructed BEFORE provenance.

The own-data repair for optional fields, descriptor literals, class state and event literals received two applied-source scoped A/C reviews. The first (SnapshotSecurity69, intermediate source) found that Object.defineProperty descriptor literals inherit get, set, configurable, writable, enumerable and value from Object.prototype; the integration owner reproduced it (an inherited configurable getter replaced a validated control with Infinity in a frozen, privately registered snapshot) before every descriptor literal became null-prototype and a six-key regression was added. The second (OwnDataFinalReview69, final source) found no write-side defect in the rewritten sites, no change to key or evaluation order beyond the corrected LFO case, freeze-before-registration intact and no weakened limit; it also reported further assignment sites (core/index.ts and core/sequence.ts engine options, worklet event literals), which were then repaired together with other sites found by a wider scan (named patches, prepared envelopes, OPM text import, Transport seek reconstruction, arrangement gain changes, render-worker diagnostics). Its inherited-read table — noteOn/updateNote reads of omitted optional fields, MIDI export controls, effects, engine-option and Performance-baseline objects — was open at that review and is repaired in the next round (below). The Performance/MIDI/arrangement/asset candidates above remain unresolved. Review was read-only and ran no gates; observed Node, Chrome and Worker evidence is recorded separately in CHANGELOG. This is scoped review, not release approval.

The omitted-field read repair received an applied-source scoped A/C review (OmittedReadReview70, read-only, no commands) with no supported-input defect in the changed sites: note admission, live controls, engine options, effects sections, Performance baselines, MIDI export controls and loaded-voice freezing read only own properties or null-prototype results, Object.hasOwn cannot be defeated by an ordinary prototype hook, and no exported API returns the null-prototype option or MIDI-control objects. The reviewer reported four further sites of the same class, none reproduced at runtime in that round: MIDI import (controls.modulation === undefined on {pitch}/{pan}/{expression} literals and held.modulation reads/writes in core/midi-file.ts), the original.voice ?? 'brass' default in core/arrangement-definition.ts, omitted-field reads on event.controls snapshots in arrangement-definition.ts, sequence.ts (release-tail bound) and api/transport.ts, and omitted Command.at / Gate fields in api/arrangement.ts and api/transport.ts. The reviewer did not exhaustively open normalize.ts, schema.ts, worklet/processor.ts, worker/render.ts or project.ts. This is scoped static review, not release approval.

The follow-up repair of those sites was reproduced first (an inherited operatorADSR inflated a planned render from 10,560 to 168,160 frames; an inherited gain rejected a valid arrangement layer; inherited id, at, offAt, cutAt and cutBeat changed Arrangement traces; 14 of 18 names changed Transport seek audio; an inherited modulation setter swallowed a MIDI-import write) and then received an applied-source scoped A/C review (OwnSlotReview71, read-only, no commands) with no supported-input defect in the changed sites. It reported one further reachable site, the MIDI-adapter controller mapping read of an inherited operator (a valid controllerMap was rejected with RangeError: controls.pan must be finite and in -1..1), which was reproduced and repaired with an own operator slot; a latent GainChange.activation read in Arrangement (api/arrangement.ts, no reachable path found, unchanged); tempo-point curve/endBpm reads that stableTempoContext already guards; and a policy note that internal bookkeeping arrays use push and are not hardened against Array.prototype hooks. It judged worklet/processor.ts and worker/render.ts reads of structured-cloned messages to run in a realm that page scripts cannot reach. This is scoped static review, not release approval.

The effects delay-tap indexing follow-up received integration-owner scoped A/C review (src/core/fx.ts SHA256 b1d2e328b32b2f5b48781a05cbfcdce73bddd53540754bf0a66b85b5da3f0a02). Chorus taps lie between 0.002 and 0.018 times the admitted integer sample rate, inside ceil(0.02 * rate) + 2 cells; pre-delay taps lie between 1 and 0.1 times the rate, inside ceil(0.1 * rate) + 2 cells. Parameter smoothing remains within those finite convex bounds. With the private position in [0, length), the first index is valid and only its successor can equal the ring length, making the conditional wrap equivalent to the former remainder. No input admission, arithmetic order, allocation or worklet protocol changed. The 110.25-frame independent impulse reference, 100 applied-source differential cases and four native Chrome effects-Worklet cases preserved PCM; 549 tests, type checks and package/static gates passed. This is owner review, not an independent release or device/listening approval.

The one-shot dry-effects follow-up received integration-owner scoped A/C review (src/core/fx.ts SHA256 b3b1b41370ec98eb85bce793019685126d4ef37422f459e38cf91b33f1760ce4). A newly constructed engine has a zero tail bound only when both normalized wet mixes are zero: every positive chorus/reverb mix contributes a strictly positive bound independently of its magnitude. The fast path therefore cannot suppress a tiny wet mix. Native-channel/rate/options validation, delay-state allocation and the 4,000,000-frame output check still precede it. It sanitizes the already detached Float32 outputs exactly as the old dry bypass did, without clipping finite values, flushing finite subnormals or losing signed zero; no observable engine history is returned. The stateful process/worklet path is unchanged. Ninety-six applied-source and 36 native Chrome cases, the numeric-boundary regression, 550 tests, types and package/static gates passed. This is owner review, not independent release approval.

The dry-helper state-allocation follow-up received integration-owner scoped A/C review (src/core/fx.ts SHA256 7a1cf6c422b750b7140055ee9db5a75d68868df4d4b5c882927602eea18293b9). Both supported construction paths share integer sample-rate admission followed by the existing strict option normalizer; the unexported engine consumes their fresh, deeply frozen snapshot without a second raw-object read. Wholly dry classification uses own chorus/reverb sections and exact positive-mix tests, so prototype fields and tiny positive mixes cannot select a false bypass. Stateful construction and updates preserve their bounded preallocation, normalization, smoothing and warmed histories. The helper still authenticates native channels before options, enforces the original output cap and uses native typed-array copies before scrubbing non-finite samples; admission-time buffer growth/detachment retains the former native error behavior. The built graph matched 44 reflection/admission traces, 96 helper cases and 900,000 stateful stereo frames. Chrome separately exercised helper/native-copy boundaries and the actual AudioWorklet. No new dependency, export, message protocol or trust token was introduced; this owner review and the passing 552-test/type/package gates do not constitute independent release approval.

The PCM24 payload-view follow-up received integration-owner scoped A/C review (src/core/wav.ts SHA256 11a4f0e57b7bf3089814152dc998b1dfb6c025395b1399a26a440f5f0012c1f9). The private layout admits exactly PCM16, PCM24 or float32; immutable local format flags allocate a DataView precisely for the two branches that use it. PCM24 writes native output bytes directly, without a new format, unchecked path or additional sample read. Header construction, native-channel authentication, finite/unit-range checks, frame/RIFF caps, little-endian packing, deterministic dither and successful-chunk-only state commits are unchanged. Exact byte/reference checks covered 80 files and 1,982,040 samples, including invalid-chunk recovery, while 60 boundary cases retained their behavior. Chrome exercised native decoding, direct constructor counts and 20 actual Worker/sink-transfer jobs against the old complete WAV output. The decoder probe allows the observed one-LSB PCM16 normalization difference; file-byte comparisons remain exact. Existing format/padding/rollback tests, all 552 tests, types and package/static gates passed. No public interface, worklet/Worker protocol or dependency changed; this owner review is not independent release approval.

The deployment-manifest read follow-up received integration-owner scoped A/D review (src/tools/assets.ts SHA256 2da049acc6432cf093ba9b206ddec29682f124744b7c5fa0fede470a19b5f224). A private scalar retains the regular manifest file's size from the existing symlink-rejecting walk; after the complete expected file set is verified, a known UTF-8 size mismatch returns false before loading that file. Matching size still leads to exact canonical-text comparison and all existing per-asset size/hash checks, so size alone grants no reuse. No extra filesystem stat, path authority, overwrite policy, transport option, public signature or dependency was introduced. Fixed-tree native observation avoided the malformed fixture's complete body read while preserving valid reuse and the rejection error. Thirteen old/built boundary cases preserved results and host/package bytes, and the actual CLI exercised fresh/reused/stale copies plus HTTP/gzip and negative MIME/nosniff/hash/redirect checks. Eight asset tests, all 552 tests, types and package/static gates passed. This is an early check of inspected metadata, not an atomic snapshot or a hard cap if a hostile writer changes a file after inspection; it is owner review, not independent release approval.

The deployment-publication follow-up reproduced the final-rename boundary with a real child process. Non-empty host content kept its inode and bytes and staging was removed, but macOS/Node 26 replaced a different process's newly created empty directory; no renameat2-style exclusive directory publication is exposed. This is retained as a documented limitation for hosts that allow unrelated writers into the deployment parent, not a path-containment, symlink, source-copy or hash-verification bypass. Source, public API and dependencies were unchanged. The added regressions cover non-empty preservation before the source's final check and at native rename, plus staging removal; the first catches unconditional replacement, while the second depends on operating-system behavior. Linux/Windows platform behavior remains unverified.

The effects-worklet graph follow-up received integration-owner scoped B/C/D review (src/core/limits.ts SHA256 59695cf53969b2451f67c6cd7cbf021f6a6c7b5e4dc458bcb2958381f40a8340, src/core/fx.ts 21c00b2856fb8b8ac60ccc88b5b6589cdeb31e2231a4a6e2577f495c0768fe62, src/core/sequence.ts 2b2f447fa3d11c0438e1b5d082452743f15b03e8ade1a4a050fd47814a6f172e). The leaf contains one immutable numeric export and imports nothing; the sequence module re-exports that identical binding, so the public core export and every existing budget comparison retain their value. The effects processor still validates raw messages through effectsData, normalizeEffectsOptions and its flood bound before enqueueing/rendering, and the offline helper still checks the same output cap. A throwaway fresh-process V8 script-list probe observed the effects worklet's static module closure; its exact-file-list assertion was removed rather than maintained as a wiring test. Native Chrome loaded the worklet and matched the previous effects PCM. No dynamic import, dependency, URL option, message protocol or trust identity changed. The build adds three deployable files, and package/asset checks inventoried them. This is owner review of a dependency edge, not independent release approval or a CDN/device startup guarantee.

The OPM UTF-8-budget follow-up received integration-owner scoped A/D review (src/voices/opm.ts SHA256 eecb52c73680f315d70cfeb402d79f0f85aab0e2007c31fa895bcbc27a73b6c9). Both guards operate only on primitive strings: each UTF-16 code unit contributes at most three UTF-8 bytes (a surrogate pair contributes four across two units; a lone surrogate encodes as three replacement bytes). The shortcut therefore cannot admit an over-budget input or line; candidates above the conservative threshold still take the same exact native encoding check. The original code-unit rejection remains first, NUL checks still follow line-budget checks, and the native Uint8Array/Latin-1 path is untouched. No change to parsing, normalization, warnings, deep copying, name sanitization, voice version or host URL/file authority. Exact-boundary tests and old/new comparisons covered multibyte and lone-surrogate cases; Chrome conversion-to-PCM and package gates passed. This is owner review, not independent release approval or a general parser performance guarantee.

The grouped OPM byte-decoding follow-up received integration-owner scoped A/D review (src/voices/opm.ts SHA256 fbb8d4610a07a3317eff90ee290ae2ccb7da7b42d4f731a2e29b7649d8c826b4). The intrinsic Uint8Array-kind/length checks, 256 KiB bound and native private-copy step still precede conversion. Each eight-byte group runs only when index + 8 <= length, reads the copied view's valid integer indices, and passes exactly eight 0–255 numbers to String.fromCharCode; at most seven bytes use the scalar tail. There is no variable argument list, endian interpretation, decoder remapping, species/subarray access or new external authority. The private text preserves byte order and all final bytes; source/parser/NUL budgets remain unchanged. Old/new consumer comparisons, offset/remainder/NUL regressions and Chrome binary-import-to-PCM observations passed. This is owner review, not independent release approval, a memory-allocation measurement or a non-V8 performance certification.

The separate OPM outputs follow-up received integration-owner scoped A/D review (src/voices/opm.ts SHA256 100c6448acb19fd80b4e9c74bc65b7b9eb9ec30eaa7f23adbf5c46dad932c24c). Both public entry points still execute parse() in full before converting any patch: source/native-view bounds, own copied bytes, decimal syntax, every section's field count/ranges, SLOT mask, complete sections and patch count/name handling are unchanged. Description reads only those private validated patch records, not caller objects, and no longer builds a voice whose normalizer result would be discarded. Voice import still invokes normalizeVoice; its operator/ADSR/noise construction and own-data spreads are preserved. Both paths share the identical raw LFO/noise rate expressions, and metadata warnings retain their original label order, clamp thresholds and Set de-duplication. The expanded existing regression rejects out-of-range voice-only fields through description too; seeded/binary old/new comparisons and native Chrome PCM passed. No new cache, trust identity, dependency, accessor, URL authority, public signature or voice-format change. This scoped owner review is not independent release approval or a claim of measured GC/device improvement.

The DX7 topology-mask follow-up received integration-owner scoped A/C/D review (src/voices/dx7.ts SHA256 f4410e701db7a5aa6127580549c4cbbcd50b83f83cd105dd6637a5b449132b48). Source framing, intrinsic length/type admission, private byte copy, 7-bit data, checksum, reserved bits and all parameter ranges still validate before selection. The new private table derives only from existing immutable ALGORITHMS; its four carrier bits occupy positions 16–19 and its sixteen edge bits positions 0–15. Source/target indices remain 0–3; the signed -1 lazy sentinel is initialized to zero before any XOR, whose operands are bounded to 0xffff. The fixed integer population count returns exactly the 0–16 edge mismatch count. Original rank, permutation/algorithm order, carrier identity test and strict-less-than update preserve deterministic ties; four-carrier selection still returns early. No cache of input patches, native-code dependency, third-party emulator source, new trust path or DSP math was introduced. Exhaustive strict-loudness-order comparisons, consumer routing ties, malformed-source regressions and Chrome PCM passed. This owner review is not independent release approval, measured GC savings or a non-V8/device performance certification.

The packed SMF message follow-up received integration-owner scoped A/D review (src/core/midi-file.ts SHA256 50117a677b9391206529a5645ebf91bf6d5f020c4cff02655a8f71f9f0391936). The helper reads only private validated/quantized numeric fields and defines every event field as own data. Each lane is masked to eight bits before packing; the positive low-24-bit word is written through native Uint8Array stores in the original byte order. Ticks, order and indices remain separate full-precision numbers; metadata retains its original bounded arrays. All constructors, including expressive messages and EOT, use the same representation consumed by both sizing and serialization. Event/byte/VLQ checks still precede final output allocation; there is no new input path, authority, cache, dependency or real-time DSP/worklet change. The full-byte/error corpus and existing input/ownership regressions passed; runtime evidence is recorded separately in CHANGELOG. This scoped inspection is not independent release approval.

The optional SMF expression-ownership follow-up received integration-owner scoped A/D review (src/core/midi-file.ts SHA256 7dd95e1414353feeaac86414c3bb0e54aedd02efcc3b392aeb3072b1872c43a3). The strict own-data controls policy still produces an immutable local boolean. Only preserve-mode parsing can create an expression wire event; the remaining channel-ownership read is confined to that event branch, and note-on/close mutations now use the same boolean guard as allocation. Legacy mode therefore needs no channel-fanout sets, while preserve mode keeps all sixteen. The independent global live set, pressed-key FIFO queues, sustain sets/pedals, release flags and EOF closure order/count remain unchanged. Binary admission through intrinsic native-view metadata, shared-memory rejection, framing/data-byte checks and file/wire/generated-event/time budgets are untouched. No cache, new input authority, dependency, public type or real-time DSP/worklet change was introduced. This scoped owner inspection is not independent release approval; observed consumer, malformed-input and package evidence is recorded separately in CHANGELOG.

The optional SMF controller-initialization follow-up received integration-owner scoped A/D review (src/core/midi-file.ts SHA256 b106227edf10cb5c8b29dccfabf8b701ca9e238b6ea3ed250743882553b3fa87). Strict own-data configuration and finite 0–48 initial bend-range validation remain unconditional before binary traversal. midiRpnState only constructs private snapshots; it performs no validation that could be lost by skipping it. Only the preserve parser branch can construct expression/RPN wire events; every remaining snapshot read is inside those branches or preserve-only note initialization. Omit mode therefore never reads the empty local arrays, while preserve mode retains its original per-channel defaults and fractional RPN range behavior. Program selection, release flags, gate ownership, global live/FIFO/sustain tracking, EOF ordering, intrinsic native-view admission and all byte/wire/generated-event/time bounds are unchanged. No imports, runtime dependencies, public declarations or permission boundaries changed. Both final compiled/minified modules matched complete results/errors in 3,726 cases each, including malformed range rejection under both policies; 557 tests and strict/public/Node-only type checks passed. Native Chrome's 16 import/compile/render/PCM24/decode cases retained 1,341,760 exact finite samples with zero DSP errors. This is scoped integration-owner review and offline consumer evidence, not independent release approval, physical-device/listening acceptance or a real-time claim.

The single-track SMF ordering follow-up received integration-owner scoped A/D review (src/core/midi-file.ts SHA256 4c9491220e914d809056d62060595a7484b3c2267338f7d7ba497979e27b6d3a). The header's native unsigned track count still validates against format/count limits before parsing. Every accepted delta comes from the existing four-byte nonnegative VLQ reader, cumulative ticks retain the existing beat horizon and each admitted event retains the parser's increasing wire index. A single track therefore yields the same tick/track/order sequence without sorting; omitted records form an ordered subsequence. Multiple tracks still use the unchanged comparator. The sort performs no validation removed by the guard: intrinsic native-view/shared-memory/framing/data-byte checks, metadata bounds, unsupported policies and file/wire/generated-event/time limits remain before or within their original stages. Same-tick note/control ownership, repeated-pitch FIFO, tempo/meter rejection, sustain and EOF count/order were checked through full public results and error classes/messages in 8,050 cases per final compiled/minified target. Existing 557 tests and strict/public/Node-only checks passed; native Chrome's 20 consumer cases retained 1,563,200 exact finite samples and zero DSP errors through native PCM24 decoding. No input authority, imports, runtime dependencies, public declarations or permissions changed. This is scoped integration-owner review and offline evidence, not independent release approval or physical/listening/real-time acceptance.

The owned WAV metadata follow-up received integration-owner scoped A/C/D review (src/core/wav.ts SHA256 616defd0ff2d1e7141740f730d8baf9db9f445b19324351a8bbb72e6d7975719). Public full-buffer/encoder/chunk entry points retain identical allowlisted own-data schemas, required fields and labels; the stream state guard still precedes input inspection. The private channel helper receives only values from those null-prototype snapshots, and intrinsic kind/length, stereo matching and expected channel-count checks remain unconditional. The private layout helper receives either the public encoder's null-prototype snapshot or a private projection defining all five fields as own data, including undefined optional format/dither fields. Every scalar, format/dither, frame/chunk and RIFF32 bound is preserved; no caller-supplied unchecked record, trust tag or new export is admitted. The per-sample single read/range check, separate emitted-byte ownership, header/padding and success-only dither commit are unchanged, as are Worker transfer/ACK and host completion accounting. Expanded inherited optional-field coverage, differential rejection/maximum-frame checks and actual native codec/Worker consumers passed. Packaging gates are recorded separately; this scoped integration-owner review is not independent release approval.

The Worker diagnostic-snapshot reuse follow-up received integration-owner scoped A/B/C/D review (src/worker/render.ts SHA256 ba679386970d77e96fb91bb69d1b3fdf9cb3a3178e1663d9d3f1f588475bfeb7). Only the private sender and its data-chunk caller changed. Each trusted renderer chunk freezes numeric diagnostics after DSP advancement and terminal cleanup; synchronous encoding neither advances the renderer nor yields to another message, so its snapshot equals the previously repeated getter result. Header/final-padding defaults and terminal reporting still request current diagnostics. No caller-provided snapshot, new message field, cross-message cache, shared PCM alias, import, dependency or authority is introduced. Start/options/ACK admission, waiting/index/finalized guards, error paths, frame/byte budgets, native transfer ownership, host progress validation and sink invalidation remain unchanged. Compiled/minified real-thread wire/audio/error parity and actual browser result/progress/decoder/ownership consumers passed; existing behavioral and strict/public/Node-only checks passed. This is scoped integration-owner inspection and runtime evidence, not independent release approval or a real-time performance claim.

The scalar WAV dither follow-up received integration-owner scoped A/C/D review (src/core/wav.ts SHA256 2ceabcd4a28e1e03b13d8f274324a7ba18d5a65982cbbcf3a331c67c3c028ce4). Admission and every format/dither, native-channel/sample, frame/chunk and RIFF32 bound remain unconditional. Enabled state still starts at the fixed seed; disabled state is zero, and no caller seed is admitted. Signed local XOR/shift operations preserve the original Uint32Array word at every sample boundary; both unsigned draw conversions, subtraction before scaling by 2^-32, sample/channel order and saturation are unchanged. Each sample is still captured once before validation and RNG advancement. The stream reads its committed seed after own-data/native metadata admission, processes only a local scalar and assigns the returned unsigned seed only after complete success. Metadata-triggered nested prefixes therefore commit before the outer transaction, while outer rejection preserves both that prefix and its current noise sequence. The new regression exercises both metadata trap positions, formats, channel counts and success/rejection transitions. Native shared/offset sample handling, separate emitted-byte ownership, encoder state guards and Worker protocol/permissions are unchanged; no cache, dependency or public API was added. Compiled/minified byte/error/transaction parity, 558 behavioral tests, strict/public/Node-only checks and native codec/Worker consumers passed. Timings are context-dependent offline evidence, not general performance, heap/GC or independent release approval.

The ordered WAV magnitude-bound follow-up received integration-owner scoped A/C/D review (src/core/wav.ts SHA256 3422a4831b3dcf2bf9ad89266a378d79d34fd2eec1b2ba7885e2ccf975eb47a7). The replacement is confined to the private sample predicate after unchanged intrinsic Float32 kind/length and frame/channel admission. Native indexed reads yield numbers, or undefined for an absent sample; no arbitrary coercible object can reach the predicate. For these values, !(Math.abs(value) <= 1) rejects exactly the former non-finite/out-of-range cases: NaN fails the ordered comparison, either infinity exceeds the bound and undefined becomes NaN. The original captured sample, not its magnitude, is serialized or scaled, preserving sign/negative zero/subnormals. No second sample read or validation/copy pass admits a concurrent shared-buffer race. Error class/message, validation order, RNG advancement, transactional seed/frame commit, bounds, imports and authority are unchanged; no allocation or input backing-store alias was added. Actual compiled/minified graphs matched 1,402,572 sample API cases per target, large/partitioned exports, metadata/native-view boundaries and concurrent native shared-memory mutation. Native Chrome 150 additionally verified real decoding, ordered progress and transfer-detached backpressured Worker sinks; installed-package/static/type gates remain required. This scoped owner review does not replace independent release review or prove physical-device/listening or real-time improvements.

The fractional effects delay-endpoint correction received integration-owner scoped A/C/D review (src/core/fx.ts SHA256 7a274aa4db7ad19ea332c5ef5fcfedde8e06cf7d1d4df6ab60ef6f69c379f02f). Strict own-data parameter admission, finite/range checks, intrinsic Float32 kind/length checks and frame bounds remain unconditional. Private chorus/pre-delay coordinates are finite and inside their allocated rings; subtracting the delay from the write position can produce a tiny negative value whose addition to the ring length rounds to that exclusive endpoint. Only that equality after negative-index adjustment now maps to zero, before either interpolation read. The ordinary arithmetic/read order and following-tap wrap are unchanged. This prevents an undefined read and consequent internal NaN/sample loss without changing clean(), clipping, feedback, phase/ring advancement, ramps or caller validation. No allocation, state, import, dependency, message or authority was added. Two failing-before public regressions and actual native Worklet/core comparisons cover wet chorus, bypass-history activation and reverb pre-delay at 8–192 kHz; ordinary stateful controls remain exact. Scope is this unreleased correction, not independent release/package approval or physical-device/listening certification.

The inactive chorus-tap follow-up received integration-owner scoped A/C/D review (src/core/fx.ts SHA256 b8d3466ab12020c9fcd11258c3fabb2bbf777ca267e60c8395929f06edc56b78). Parameter/frame/native-buffer admission is unchanged and unconditional. Only private current mix/feedback coefficients select the guard; either signed zero selects it, while every nonzero coefficient retains tap calculation. With normalized ring endpoints, clean-written finite delay data, bounded phase/delay/voice weights and a denominator of at least one, skipped taps are finite and have no state or validation side effects. A zero feedback product can change only the sign of zero added to the input; the unchanged push clean() canonicalizes it, preserving stored samples. Input capture, both ring writes, phase progression, target interpolation, order handling, resets, output cleaning and native metadata bounds remain unconditional/unchanged. Nonzero feedback still reads taps even with zero wet mix, and no epsilon prunes positive controls. No storage, import, dependency, protocol, authority or shared backing-store alias was added. Seeded scalar identities, exact four-graph stateful controls, a public activation/reference regression and final native Worklet/core comparisons support the scoped change; this is not independent release approval or a physical-device/listening/deadline certification.

The frame-local reverb damping follow-up received integration-owner scoped A/C/D review (src/core/fx.ts SHA256 f745d7362847de964d8a7565a922fd61207fee80a0ccc085f51bc38668a46f29). The moved expression reads only the private native current-coefficient array after the unchanged per-sample ramp update. That array has its own backing store, separate from low-pass and delay data, and is not exposed by public parameter snapshots. Within the synchronous reverb frame, pre-delay/comb/diffuser operations mutate only their private data/positions and low-pass state, not current coefficients; there is no user callback or task interleaving. The same finite admitted damping value and multiplication are therefore reused for both channels' combs without changing arithmetic order at their use sites. Signed-zero/subnormal values, current/target progression, feedback, reset/tail behavior, intrinsic native-buffer/frame admission, cleaning and all worklet protocols remain unchanged. No allocation, storage, import, dependency, authority or alias was introduced. Exact stateful controls, actual rebuilt boundary/ramp smoke and native Worklet/core comparisons support this scoped source move, not independent release approval or physical-device/listening/deadline certification.

The frame-local chorus coefficient follow-up received integration-owner scoped A/C/D review (src/core/fx.ts SHA256 90dfad9329b7707a449fb2155453d150b8195bca2c4374e66ca663501ba70780). The two captured values come only from the independently allocated private native current array, after unchanged per-sample interpolation, not from caller properties or target values. Private tap reads, delay pushes/cleaning and built-in math do not mutate that array or invoke user callbacks; message tasks do not interleave the synchronous frame. The same primitive coefficients are therefore reused at every original use site without changing floating-point operation order or extending their lifetime across samples. Either signed zero and every positive subnormal retain their original guard/feedback/mix behavior. Both channel inputs, ring writes, phase advancement, clipping/cleaning, history/reset/tail handling, own-data parameter admission, intrinsic native-view/frame bounds and worklet protocols are unchanged. No storage, import, dependency, authority or backing-store alias was introduced. Exact stateful source/minified controls, actual rebuilt coefficient-boundary/ramp smoke and native Worklet/core comparisons support this scoped capture, not independent release approval or physical-device/listening/deadline certification.

The contiguous effects coefficient-target follow-up received integration-owner scoped A/C/D review (src/core/fx.ts SHA256 634ceebd940db8f63ba13f717ec9c4739082624bcd265dbda02b3927e5bb06a7). The removed padding slot was initialized to positive zero, never assigned a target, and never consumed outside its own independent interpolation. Both private arrays and the interpolation bound now have 21 cells; eight gain targets/readers moved together to indices 13–20. All 21 target cells are initialized before use, and used-field interpolation has no cross-cell dependency or callbacks. Own-data/range/native-view/frame checks, scalar indices, delay/filter/phase writes, target replacement, reset, order ramps and tail accounting are unchanged. The logical array payload is 16 bytes smaller; no allocation/GC or deadline guarantee follows. Actual rebuilt modules matched the measured candidate, stateful and repeated-update core probes, and same-runtime native static/automation PCM. Native subnormal pre-delay versus main-thread divergence was separately isolated with a library-free numeric control and an exact explicit-zero counterfactual; no validation, protocol, floating-point threshold or runtime security control was changed to conceal it. Expected invalid-message FIFO fences used the existing bounded validator without processor instrumentation, and all intentional errors were accounted for. This is scoped unreleased integration-owner review, not independent release approval, publication, physical-device or listening acceptance.

The frame-local effects ramp-endpoint follow-up received integration-owner scoped A/C/D review (src/core/fx.ts SHA256 5019c9cb0a2a260359bcfdbae4ac2f960e956629fee7c85cff108a51cf8c47dd). The private remaining count is an integer set from the bounded sample-rate ramp, decremented once per processed frame, and reset to zero by reset; the former per-cell endpoint condition is invariant throughout the synchronous loop. Current/target are independently allocated fixed-size native Float64 arrays of 21 cells, not caller buffers or public parameter snapshots, with no supported detachment, alias or callback interleaving. All target coefficients are finite after unchanged admission/target generation. At remaining one, native same-kind set() copies those exact cells, matching the former finite scalar stores, including signed zero/subnormal bits; constructor/reset already rely on this native operation. Intermediate arithmetic/read order, decrement timing, input/native-view/frame checks, delay/filter/LFO/order/tail writes and protocols are unchanged. No view, storage, dependency, authority or user-controlled metadata read was added. Actual rebuilt core/stateful/update probes, native raw-copy phases and same-runtime static/automation PCM support the cutover. The documented native near-underflow/main-thread boundary was retained and diagnosed separately, with expected validator-error FIFO fences fully counted and no weakened control. This is scoped unreleased integration-owner review, not independent release approval, registry publication, physical-device/listening or deadline certification.

The bounded effects tap-index follow-up received integration-owner scoped A/C/D review (src/core/fx.ts SHA256 631e0365b0f3361826b6d8b15423f517e3ea6d46b053268e80a556f56bbac421). Unchanged integer sample-rate admission (8,000–192,000) bounds independently owned rings to 19,202 cells. Only chorus and pre-delay taps call the private reader; their derived delays are strictly positive and shorter than their ring, while positions start at positive zero and advance/reset within the ring. After the unchanged negative-index wrap and exclusive-endpoint correction, the finite index lies in [0, length) and is not negative zero. Int32 conversion therefore produces exactly the former floor base and fraction, with no modulo overflow or new coercion of caller data. Own-data/numeric/native-view/frame admission, immutable snapshots, interpolation, cleaning, ring writes, phase, reset, order ramps, tail accounting and resource bounds are unchanged. No caller-controlled alias, callback, buffer/view, cache, field, dependency or message protocol was introduced. Actual rebuilt consumer and native-capture proofs are recorded in CHANGELOG; existing native underflow/readback behavior is explicitly distinguished from same-runtime bit parity. This scoped source review is not independent release approval or a new tooling/runtime audit.

The ordered arrangement gain-history follow-up received integration-owner scoped A/C/D review (src/api/arrangement.ts SHA256 0e00c9c154ea9ac9dc8e69a422e66ac243a8919ea8771971d8b7656e83b1894b). Gain records and their dense array are private, not caller snapshots. Initialization/non-running replacement use equal beats; insertion sorts numerically; stable filters preserve order; pause reconstruction places the current beat before strictly later retained changes. OPM admission/update/stop callbacks occur before pruning, and their existing generation/ownership checks remain unchanged; the indexed predicate reads owned primitive fields without introducing a callback or interleaving point. The strict future cutoff preserves the original played + EPSILON boundary, same-layer qualification and stable result order, retaining every future change and the latest played entry for each layer. Existing resource/admission/native-message bounds, gain timing, own bookkeeping slots, cancellation and teardown remain unchanged. No new collection, persistent state, dependency, declaration or public contract was introduced; the existing outer filter allocation remains. Actual compiler/minified consumer traces and raw Float32 output matched in Node and Chrome, and final native public graphs exercised retarget/pause/resume/gain/tempo behavior with zero diagnostic errors and complete context/node cleanup. Build, 562 behavioral tests and strict/public/Node-only type checks passed. This is an unreleased scoped integration-owner review, not independent release approval or physical-device/listening acceptance.

The exact-zero arrangement fade correction received integration-owner scoped A/C/D review (src/api/arrangement.ts SHA256 6f622ac8eaa80abdcee725dd81ac5c059972495f3bbdbdb273b3d91e03e03acd). Only privately constructed gain records are read after the existing layer/boundary checks. An exact fade === 0, including negative zero, now copies the already admitted finite target and reports no remaining ramp; it neither interpolates that target nor derives duration from a rounded onset. All strictly positive fades retain their former clamp/divide/multiply/add order, without an epsilon shortcut or floor. The existing before break, future-entry eligibility, own bookkeeping slots, callbacks, cancellation, stable history pruning and teardown remain intact. No pending-note/command bound, parser or authorization check was weakened to admit the formerly rejected valid chord. There is no new collection, cache, persistent state, dependency or public signature. Both permanent consumer regressions failed before and passed after; all 564 behavioral tests and strict/public/Node-only types passed. Actual compiler/minified positive-fade bit parity and exact-zero offline-oracle proofs ran in Node and Chrome, and actual native dense scheduling reproduced the baseline failure while corrected starts retained bounded voices and clean diagnostics. All native contexts/nodes were cleaned up. This scoped unreleased review is not independent release approval, a tooling audit or physical-device/listening acceptance.

The completed-positive arrangement fade correction received integration-owner scoped A/C/D review (src/api/arrangement.ts SHA256 719cfa0735046307397958f791db0c45eac49727ed15bf7e2bb59720c3b55380). After the unchanged private-record layer/future checks and clamped progress calculation, an exact completed progress now selects the already admitted finite target instead of losing it through affine cancellation. Strictly in-flight arithmetic and the remaining-duration expression are unchanged; the prior exact-zero branch remains intact. No epsilon threshold, input coercion, validation bypass, extra allocation, persistent cache, callback, ownership transfer or resource-limit change was introduced. Existing temporal/getter reentrancy, cancellation and teardown boundaries remain in place. The public PCM regression and independent offline oracle distinguish this intentional endpoint correction from baseline preservation. This scoped review is not an independent release approval.

The sample-frame arrangement fade correction received integration-owner scoped A/C/D review (src/api/arrangement.ts SHA256 6b3661b8b62156dc0ff8c1b85fb36275f4a202077dc5877bf565447e21cc01e3). gainAt now takes the sample rate from the already-validated running context and compares integer rounded frame distance with fade × sampleRate; zero fades, in-flight interpolation, exact endpoint targets, callbacks, ownership, cancellation and capacity checks are unchanged. No new state, dependency or public signature. Scoped review only, not independent release approval.

For v1.2, final A/B/C/D independent review and observed integration verification are recorded in CHANGELOG before release. Configured Node 22/24/26 and Chromium/Firefox/WebKit CI jobs are capabilities, not evidence of an external run. Missing browser binaries/host support or unrun CI must be reported, not represented as passing coverage.

v1.5 feature-completion review: InputBoundaryReview covered A/B; DspSupplyReview covered C/D. The integration owner reproduced and fixed null mixGain/tuning acceptance and overridable render-buffer metadata, then also prevented offset coercion before default-length calculation. Runtime evidence and remaining registry/physical-device prerequisites are recorded separately in CHANGELOG; static review is not a claim of runtime coverage.

FinalInputsReview (A/B) and FinalDspReview (C/D) rechecked the final hardened source and release controls, with no new evidence-backed findings. Their PASS applies to scoped static inspection only; they ran no build, payload, tests, audit or browser commands.

v1.5 release review: Release15Inputs approved scoped static A/B inspection; Release15DspSupply approved C/D for GitHub distribution of package 1.5.0, with no evidence-backed blockers. Neither reviewer executed runtime gates or certified external npm settings. The integration owner's fresh package, native browser, numerical, audit and report-only benchmark evidence is recorded in CHANGELOG.

v1.5 interruption-repair recheck: Release15Inputs initially found that deferred running notifications could leave deduplication state stale. Both initial and existing-node resume now synchronize successful state observation; repeated fully deferred transitions and pending diagnostics are covered by consumer regressions. Release15Inputs then approved A/B and Release15DspSupply approved C/D without remaining scoped static findings. The original Linux WebKit CI failure blocks publication until repaired-candidate verification; static approval is not a waiver or runtime certification.

v1.6 release review: a security review found two command-waiter boundary issues (abort-signal state/listener shadowing and receipt-eviction handling around correlated panic resets). Both were fixed with regressions and rechecked natively against a borrowed context. No fresh independent A/B/C/D approval was obtained for v1.6; the maintainer explicitly authorized the GitHub release on the integration owner's runtime evidence, recorded as a waiver in CHANGELOG. npm publication still requires the independent review record described in doc/publishing.md.

Unreleased seven-capability checkout review: SecurityDataReview approved scoped A, SecurityProtocolReview B, SecurityDSPReview C, and SecuritySupplyReview D static inspection. Initial findings about release-tail controls, sink-transferred buffer accounting and deferred file-picker/writable teardown were fixed and the affected source rechecked without remaining scoped findings. These reviewers executed no tests, builds, audits or browser commands; their PASS does not certify runtime behavior, deployment permissions, physical devices or registry protections. The integration owner's observed tests, package gates, native browser smoke and report-only CPU measurements are recorded separately in CHANGELOG. This is not a release approval or a new waiver.

v1.7 release review: Release17Data approved scoped static A, Release17Protocol B, Release17DSP C, and Release17Supply D, with no evidence-backed blockers in the final seven-capability source and 1.7.0 release metadata. All four reviews were read-only and executed no runtime gates. Fresh isolated package/build/test/type/audit/quality checks and managed native Chromium AudioWorklet observations are recorded in CHANGELOG. Remote CI must pass before the release tag is published; its run URL and outcome belong in the GitHub release record. No waiver or npm authentication/provenance/external-protection certification is asserted.

v1.8 review record: InputProtocolReview approved scoped static A/B and DspAssetsReview scoped static C/D after the bounded arrangement, MIDI own-data, finite tempo-slope and canonical asset-overlap fixes. Their static approval does not certify runtime or external npm settings. The release commit d793d69056c68a971ede1af988338412687227fd has an observed successful Node 22/24/26 and Chromium/Firefox/WebKit CI run; the separate review record and release package record retain the evidence and tarball digest. This is not registry provenance, physical-device/MIDI or listening acceptance.

v1.8.1 documentation/package patch review: Patch181Inputs approved scoped static A/B and Patch181DspSupply scoped static C/D, with no evidence-backed blockers. Reviewers were read-only and ran no build, tests or external actions. The integration owner confirmed the source diff against v1.8 changes only src/version.ts; runtime validation, protocols and DSP are unchanged. Final regenerated assets, package gates and remote CI are separate release prerequisites, recorded in CHANGELOG and the GitHub release notes. No npm provenance, physical-device/MIDI or listening certification is asserted.

Unreleased integration-quality review: FinalImprovementInputs approved scoped static A/B after the pedal-ownership and applied-workload evidence fixes. FinalImprovementDspSupply approved scoped static C/D specifically for an isolated immutable canonical candidate (47 runtime modules with 141 matching distribution assets), after generated-link validation and the DOM-free core/project/MIDI type boundary were hardened. No surviving scoped findings remain. Both reviewers were read-only and executed no runtime gates or publication. The integration owner separately observed 381 passing behavioral tests, type checks including installed DOM-free Node consumers, numerical/dependency/package checks and native Chromium UI/smoke/stress checks. Unexpected numbered generated-file copies were preserved outside the checkout; live-tree packaging remains blocked by their reappearance and is not covered by the isolated-candidate approval. Desktop automation and numerical analysis do not certify physical devices, physical MIDI or human listening. No release approval, npm authentication/provenance/registry protection, physical-device or listening certification is asserted.

v1.9 release review: Release19Inputs approved scoped static A/B and Release19Supply scoped static C/D for an isolated canonical package 1.9.0 candidate, with no evidence-backed security findings. Reviewers ran no runtime gates. Numbered live-tree generated copies are not approved for packaging and must remain outside the candidate. GitHub publication requires exact clean-commit artifacts, passing remote Node/browser CI and an archive digest retained in the release record. Physical-device/MIDI, human listening and npm provenance remain unverified and are not claimed by this GitHub-only release.

v1.9 deadline repair: Release19Supply rechecked and approved scoped static C/D topology-cache/pooling/render changes after the initial release candidate failed the Node 22 prepared-burst p99 gate. Fixed slot-local caches derive only from the existing validated graphs, overwrite all edges, preserve summation order and retain finite checks, bounded fades and reentrant callback behavior. The reviewer executed no checks; this is not a performance waiver. The repaired exact commit must pass the unchanged remote gates before tagging.

Unreleased readiness review: ExpressionSecurity approved scoped static A/B for final expressive SMF boundaries, ownership and loss accounting; ArrangementCaptureSecurity approved scoped A/C/D for portable/shared arrangement validation, lifecycle, inert imports, pure core contracts and bounded text-only local MIDI capture. No evidence-backed findings remained. Reviewers executed no gates. The integration owner separately observed 403 passing tests, installed package/types/security/audit checks, 108 bit-identical baseline renders, scoped capacity measurements and native isolated Edge UI/worklet checks, recorded in CHANGELOG. Physical phones/controllers and genuine eighteen-preset listening originals remain blocked/unverified. This is not release/publication approval.

v1.10 release review: Release110Inputs approved scoped static A/B and Release110DspSupply scoped static C/D for an immutable canonical package 1.10.0 candidate (48 runtime modules and 144 matching distribution assets), with no evidence-backed blockers. Both approved the final documentation/generated-HTML delta. Reviewers ran no runtime gates. The integration owner separately observed 403 behavioral tests, public/DOM-free core types, numerical matrices, zero-vulnerability development/runtime/Vite audits, isolated installed-package/asset/type gates, expressive MIDI-to-Arrangement PCM/WAV smoke and the unchanged isolated p99 deadline gate. Unexpected numbered live-tree generated copies are preserved and excluded. Publish only exact committed canonical assets after remote Node/browser CI passes; retain the commit, CI URL and archive digest in the GitHub release record. This is not npm provenance or physical-device/MIDI/listening certification.

v1.11 review: SecInputsProtocol approved scoped static A/B (voice v7 validation, .opm parser, MIDI program/RPN boundaries, synth and effects worklet protocols, effects URL/lifecycle) with no evidence-backed vulnerability. SecDspSupply returned approved-with-fixes C/D with low/informational findings only: the deployment inventory now requires worklet/fx-processor.js (with a rejection test), the effects headroom documentation is qualified as a steady-state ceiling (a feedback decrease can briefly exceed 0.7 during its 20 ms ramp), the input table above now covers v7 and .opm, and capacity candidates are documented as sine-operator measurements. Reviewers ran no runtime gates. The integration owner separately observed the typecheck, the full behavioral suite, the npm run security gate, and a real Chromium AudioWorklet smoke of the noise and waveform voices through the effects insert. Physical devices, MIDI hardware and human listening remain unverified; this is not a release, npm publication or deployment record.

v1.11.1 review: SecFastSin approved a scoped static review of the fastSin polynomial and all-sine render fast path (NaN/Infinity containment, |value| ≤ 1 bound, determinism, O(1) cost, state parity with the generic path) with no evidence-backed vulnerability. The reviewer ran no runtime gates; the integration owner ran tests, typecheck, the package-smoke security gates and a Chrome AudioWorklet smoke.

v1.12.0 review: SecPortV112 approved a scoped static review (checklist C plus option intake) of the per-algorithm sine frames, steady-gain and settled-pitch caching, carrier-based retirement, LFO delay fade, fastSin/fastExp2, soft-knee saturation, the DC blocker and saturation/dcBlock intake across Synth, OPM, sequence, Worker and project settings, with no evidence-backed vulnerability. Its informational hardening items were applied (the DC blocker state resets on a non-finite mix; the fastExp2 power-of-two table is built by exact doubling). Remaining low/info notes: the all-sine frames check modulator finiteness at frame end, so a transient non-finite modulator value behind zero downstream gains is not counted (no reachable trigger from validated finite envelopes; output and state are unaffected); renderNote destructures its options rather than reading own data (pre-existing; values are still validated by readSynthOptions); and OPM throws RangeError where the core throws TypeError for an invalid saturation, matching the existing stealing behavior. The reviewer ran no runtime gates; the integration owner ran the build, tests, typecheck, sound-quality, voice-quality, npm run security -- --package-smoke and a headless Chromium OfflineAudioContext smoke of the synth and effects worklets for every quality profile with both output stages.

Unreleased performance review: SecPerfRound2 approved a scoped static checklist C review of half-turn phases and sinPi, Estrin fastExp2, the geometric envelope carry with segment-end and voice-level fast paths, the all-zero-gain silent frame, note-on LFO/kernel/pitch-envelope snapshots and the per-frame decimator API, with no evidence-backed vulnerability. Its hardening items were applied: the LFO waveform code is resolved before a voice slot is taken, and the silent frame also counts non-finite folded amplitudes. The reviewer ran no runtime gates; the integration owner ran tests, typecheck, build, npm run security -- --package-smoke, npm run sound-quality, bit-identity scripts against the previous step and a Chrome core/worklet/Worker smoke.

Unreleased allocation follow-up: SecAllocReview approved a scoped static checklist C review of the 4-slot decimator header with DECIMATOR_OUTPUT, void decimateFrame and dcBlockStep, boolean renderVoice with an internal fade gain, prepareGains/preparePitch without per-frame double arguments, and per-branch generic operator values. All ring offsets stay within DECIMATOR_STATE_SIZE (150); non-finite voices and mixes are still counted as errors and silenced with state reset; fade gain and determinism are unchanged; no loops or allocations were added; and peak/settle/idle logic correctly excludes the derived output slot. Its comment suggestion was applied. A ring-layout assertion was not added because the per-quality bit-identity and impulse tests already exercise every ring. The later change in periodicWaveform, adding unary + to number-valued cases, is an identity on numbers. Its non-finite input guard is unchanged, and bit-identity scripts confirmed the output. The later storeGain wrapper writes gainAt at the same time expression (elapsed / sampleRate, plus subTimes[sub]) into the gain arrays prepareGains already wrote, at in-bounds indices; it adds no state, loops or validation paths. Bit-identity scripts confirmed the output.

Unreleased waveform-frame review: SecWaveFrames approved a scoped static checklist C review of waveFrame0–waveFrame7. These are per-algorithm frames for noise-free voices that mix sine with other periodic shapes. The review also covered the frameKernel selection and rename.

  • Each frame keeps the sine frames' per-sample and end-of-frame finiteness checks, and writes state back only after they pass.
  • Waveform codes are written only at admission (0 selects sine frames, 1–7 wave frames, 8 the generic loop).
  • Per-frame work is fixed and allocation-free.
  • Topology and state updates match the generic loop, and the strengthened identity test checks this for all eight algorithms.
  • Its comment suggestion, that non-sine operators mask non-finite phases exactly as the generic loop does, was applied.

Unreleased WAV dither review: SecDither reviewed the opt-in dither option.

  • Approved on security.
    • Dithered samples are clamped, so neither setInt16 nor 24-bit packing can wrap.
    • The xorshift32 state cannot reach zero.
    • The option is validated through sequenceOwnData, without prototype or getter leaks, and rejected for Float32.
    • The Worker requires an own boolean dither field, as it does format.
    • Undithered output is unchanged.
  • Its Low determinism finding was fixed: a chunk rejected midway used to advance the dither state, so later bytes diverged from encodeWav. encode() now dithers a copy of the state and commits it only after the chunk succeeds, and a regression test covers this.

v1.13.0 release: covered by the SecPerfRound2, SecAllocReview, SecWaveFrames and SecDither records above (all approved, findings applied). The release adds no further source changes beyond the version number.

Unreleased voice v8 review: SecVoiceV8 approved a scoped static review of checklist A, C and the B paths that reach voice/control validation, for adsr.sr, voice pan, the noise LFO, the 5-key operatorADSR, the held-decay envelope segment, lfoCycle/lfoNoise, the pan clamp and the .opm/DX7 mappings, with no evidence-backed vulnerability.

  • Both validation paths reject accessors, symbol and unknown keys, and legacy versions carrying the new fields; the strict path rejects and the bank path clamps out-of-range values; prepared snapshots stay frozen.
  • The smallest key-scaled sustain rate (about 1.9e-9 s) is still positive; its per-substep ratio underflows to exactly zero, never NaN, and the floor clamp keeps every dB value finite.
  • Work per frame stays fixed and allocation-free; the new segment uses the existing anchor grid, so output stays chunk independent. lfoCycle over a 24-hour render stays far below 2^53, so the hash inputs are exact.
  • Its informational hardening item was applied: each path now probes sr once (one hasOwn or one ownKeys snapshot), so a main-thread proxy cannot answer the version gate and the read differently.
  • The reviewer ran no runtime gates; the integration owner's tests, bit-identity A/B and smoke checks are recorded in CHANGELOG.

v1.13.1 release: covered by the SecVoiceV8 record above (approved, hardening applied); the release adds only version numbers and documentation beyond that reviewed source. Commit ae7b5e6 passed Node 22/24/26 and Chromium/Firefox/WebKit CI.

The branchless-sine-sign follow-up (sineOp parity from a second round-to-nearest instead of an int32 conversion and branch) was reviewed read-only by SineOpReview (security-reviewer agent): no supported-input A/C blocker. It confirmed exact equivalence to the previous sign for every |k| < 2^51 (phase stays below tens of half-turns given the 16 rad modIndex limit), ties-to-even giving d = ±0.5 for odd k, signed zero, the unchanged gain === 0 early return, and that NaN/Infinity phases or gains still propagate to non-finite results caught by the existing finite checks. No allocation, state, work or containment change. The reviewer ran no code; the SHA-256 output identity across qualities and algorithms is recorded in CHANGELOG. This is not release approval.

v1.14.0 release: the src/core/, src/worklet/ and voice-parsing changes since v1.13.1 are covered by the Unreleased review records above in this file (scoped static reviews, hardening applied); the final sineOp change is recorded with its SHA-256 identity check. The release adds only version numbers and documentation beyond that reviewed source. CI for this exact commit has not been observed.

Non-goals

  • Sandboxing the host page (OPM.js runs in the page's trust domain; XSS protection is the embedder's job)
  • DRM / copy protection of voice banks
  • Remote code loading of any kind — never supported

There aren't any published security advisories