@denaudio/den 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -5,6 +5,52 @@ and migration instructions first. Unreleased entries do not imply npm availabili
 
 ## Unreleased
 
+## 0.2.0 — 2026-11-12
+
+- **Breaking:** requires `@unworklet/core` **0.6.0**. Update the compiler, offline
+  renderer, Vite plugin and test helpers to 0.6.0 together. Node 24 is unchanged.
+- **Breaking:** pass `ctx.renderQuantumSize` to spectral framing, convolution,
+  spatial-chain and resident time-stretch construction configs. Their dispatch
+  periods now preserve saved hop phase at the actual quantum boundary. Rebuild
+  processors for the target context; old or cross-target snapshots are not a
+  supported migration path.
+- FFT and spectral work-buffer loops use `forIndex` instead of assuming that an
+  audio loop always runs 128 samples. Transform and partition sizes retain their
+  existing sample-based meaning.
+- The playground uses the actual AudioContext sample rate and render quantum
+  (128 on browsers without `renderQuantumSize`) for worker compilation, metadata
+  and schema identity. It no longer forces or requires 48 kHz.
+- The spectral-freeze example waits for input before filling its capture history,
+  so delayed source setup cannot freeze an empty startup buffer.
+- Add multi-rate and multi-quantum spectral regression coverage, including
+  continuation after snapshots at non-128 boundaries. Dependency regression
+  checks now exercise the upstream fixes included in 0.6.0.
+- Audio remains CANDIDATE. This compatibility update does not grant human
+  listening approval or clear the existing real-time capacity limitations.
+
+### Migrating construction configs
+
+Add `renderQuantumSize: ctx.renderQuantumSize` inside the `defineProcessor(ctx =>
+...)` callback when constructing `stftIdentity`, `spectralGate`, `spectralFreeze`,
+`spectralBlur`, `spectralCrossSynthesis`, `partitionedConvolution`,
+`preparedConvolution`, `residentTimeStretch`, `hybridReverb` or
+`feedforwardPitchedReverb`. For example:
+
+```ts
+// Inside the existing defineProcessor(ctx => { ... }) callback:
+const stft = instantiate(stftIdentity, {
+  size: 256, hopSize: 128, renderQuantumSize: ctx.renderQuantumSize,
+}, { name: 'stft' });
+```
+
+Host-side `prepareConvolutionSpectrum` and its `PreparedConvolutionConfig` keep
+their existing shape; the DSP constructor uses `PreparedConvolutionRuntimeConfig`.
+Frame lengths, partition lengths, latency in samples and control sampling times
+retain their meaning. Native scheduler counters are not snapshot state, so
+dispatch uses a divisor of both hop and quantum; smaller or non-dividing quanta
+can perform more FFT/search work. This is functional support, not a new
+real-time performance guarantee.
+
 ## 0.1.0 — 2026-10-09
 
 - First public npm release of `@denaudio/den`, with 54 ESM module entry points,

package/README.md

@@ -32,7 +32,7 @@ builds the English TypeScript playground at `/`. Its Monaco editor resolves real
 package declarations for completion, hover, signatures and diagnostics. Every
 public import has an editable audio example. Run compiles in a cancellable
 worker, creates a native node, and exposes its AudioParams; Stop disposes it.
-See the [source format and host contract](https://github.com/yuichkun/den/blob/3042e73435986fa2804f5811604e784d93470c1f/playground/README.md).
+See the [source format and host contract](https://github.com/yuichkun/den/blob/main/playground/README.md).
 
 The earlier public website was deleted before this replacement. Old
 `catalog.html`, `audition.html`, `diagnostics.html` and `playground.html` routes
@@ -46,7 +46,7 @@ See the [acceptance record](docs/initial-acceptance.md).
 
 ## Public package boundary
 
-The ESM-only `@denaudio/den` requires **@unworklet/core 0.4.1** as a peer. All
+The ESM-only `@denaudio/den` requires **@unworklet/core 0.6.0** as a peer. All
 exercised compiler, renderer, plugin and test dependencies are locked. Import
 editable construction functions/subgraphs through these public subpaths:
 
@@ -66,7 +66,12 @@ export default createInstrument(bassConfig);
 Use the existing `@unworklet/unplugin` Vite plugin and `createNode`; den adds no
 loader, parameter, MIDI, routing, snapshot or serialization framework. Settings
 are plain engine construction options and complete native parameter maps.
-Snapshots require the same processor/schema/sample rate. See the
+Compilation follows the AudioContext's sample rate and render quantum. Spectral
+framing, both convolution modules, spatial chains and resident time stretch
+require the processor's `ctx.renderQuantumSize` in their construction config so
+snapshot restoration preserves hop timing even at short quantum boundaries. See the
+[0.2.0 migration notes](CHANGELOG.md#020--2026-11-12).
+Snapshots require the same processor/schema/sample rate/render quantum. See the
 [instrument contract](docs/instrument.md), [sound settings](docs/instrument-settings.md),
 [Delay FX contract](docs/delay-fx.md), [effect settings](docs/delay-settings.md),
 [shared contracts](docs/contracts.md), and [dependency limitations](docs/dependency-findings.md).

package/dist/convolution.d.ts

@@ -1,5 +1,7 @@
 import { type EveryNSamples, type Node } from '@unworklet/core';
 export interface PartitionedConvolutionConfig {
+    /** Pass ctx.renderQuantumSize; aligns native dispatch with snapshot boundaries. */
+    renderQuantumSize: number;
     /** Construction-fixed power of two in [4,32]. FFT size is twice this value. */
     blockSize: number;
     /** Fixed IR, length 1..4*blockSize. Every tap in [-1,1], total absolute gain <=4. */

package/dist/convolution.js

@@ -1,5 +1,5 @@
 import { defineSubgraph, f32, f64, i32, instantiate, select, state } from '@unworklet/core';
-import { spectralFft } from './spectral-fft.js';
+import { spectralDispatchPeriod, spectralFft } from './spectral-fft.js';
 /** Bounded uniform-partition convolution candidate, exactly blockSize latency.
  * Call once per sample in stride-1 forSample with its native everyNSamples.
  * Input must be finite normalized audio [-1,1]. No IR loader/swap or dry path.
@@ -13,6 +13,7 @@ export const partitionedConvolution = defineSubgraph((config) => {
         config.impulse.reduce((sum, tap) => sum + Math.abs(tap), 0) > 4) {
         throw new RangeError('partitionedConvolution requires power-of-two blockSize [4,32], 1..4*blockSize finite IR taps in [-1,1], and IR absolute sum <=4');
     }
+    const dispatchPeriod = spectralDispatchPeriod(block, config.renderQuantumSize);
     const impulse = [...config.impulse], size = 2 * block, partitions = Math.ceil(impulse.length / block);
     // Construction-only O(P*N*B) coefficient preparation. No host FFT runtime,
     // asset read, callback allocation or coefficient update on the audio thread.
@@ -43,11 +44,15 @@ export const partitionedConvolution = defineSubgraph((config) => {
             validSamples.write(select(reset, i32(0), validSamples.read()));
             validBlocks.write(select(reset, i32(0), validBlocks.read()));
             pendingReset.write(pendingReset.read().or(reset));
-            everyNSamples(block, () => {
+            // A quantum need not divide blockSize. Persistent cursor phase keeps
+            // frame commits exact when native scheduler counters restart on restore.
+            everyNSamples(dispatchPeriod, () => {
+                const frameDue = cursor.read().mod(block).eq(0);
                 const transformed = fft.transform(n => select(n.lt(block).and(validSamples.read().gte(i32(block).sub(n))), history.read(cursor.read().add(n).mod(block)), f64(0)), () => f64(0), false);
                 for (let k = 0; k < size; k++) {
-                    previousReal.write(spectrumCursor.read().mul(size).add(k), transformed.real(k));
-                    previousImag.write(spectrumCursor.read().mul(size).add(k), transformed.imag(k));
+                    const index = spectrumCursor.read().mul(size).add(k);
+                    previousReal.write(index, select(frameDue, transformed.real(k), previousReal.read(index)));
+                    previousImag.write(index, select(frameDue, transformed.imag(k), previousImag.read(index)));
                 }
                 for (let k = 0; k < size; k++) {
                     let real = f64(0), imag = f64(0);
@@ -64,11 +69,12 @@ export const partitionedConvolution = defineSubgraph((config) => {
                 const frame = fft.transform(n => mixedReal.read(n), n => mixedImag.read(n), true);
                 for (let n = 0; n < size; n++) {
                     const index = cursor.read().add(n).mod(size);
-                    overlap.write(index, select(pendingReset.read(), f64(0), overlap.read(index)).add(frame.real(n)));
+                    const prior = overlap.read(index);
+                    overlap.write(index, select(frameDue, select(pendingReset.read(), f64(0), prior).add(frame.real(n)), prior));
                 }
-                spectrumCursor.write(spectrumCursor.read().add(1).mod(partitions));
-                validBlocks.write(validBlocks.read().add(1).min(partitions - 1));
-                pendingReset.write(false);
+                spectrumCursor.write(select(frameDue, spectrumCursor.read().add(1).mod(partitions), spectrumCursor.read()));
+                validBlocks.write(select(frameDue, validBlocks.read().add(1).min(partitions - 1), validBlocks.read()));
+                pendingReset.write(pendingReset.read().and(frameDue.not()));
             });
             const output = select(reset.or(pendingReset.read()), f32(0), f32(overlap.read(cursor.read()).div(scale)));
             overlap.write(cursor.read(), f64(0));

package/dist/prepared-convolution.d.ts

@@ -1,12 +1,16 @@
 import { type EveryNSamples, type MessageGraphPayload, type Node } from '@unworklet/core';
 import { type PreparedConvolutionConfig, type PreparedConvolutionPacket } from './convolution-spectrum.js';
 export { prepareConvolutionSpectrum, type PreparedConvolutionConfig, type PreparedConvolutionPacket } from './convolution-spectrum.js';
+export interface PreparedConvolutionRuntimeConfig extends PreparedConvolutionConfig {
+    /** Pass ctx.renderQuantumSize; aligns native dispatch with snapshot boundaries. */
+    renderQuantumSize: number;
+}
 /** Fixed B128/P64 prepared-spectrum mono convolution candidate.
  * Correctness/gain bounds require an unchanged packet from host preparation.
  * Caller owns native CAPACITY_16 ingress with payloadCapacity 131072 bytes.
  * Copy/scan runs in native dispatch, so preload with audible playback gated off.
  */
-export declare const preparedConvolution: import("@unworklet/core").SubgraphDecl<[config: PreparedConvolutionConfig], {
+export declare const preparedConvolution: import("@unworklet/core").SubgraphDecl<[config: PreparedConvolutionRuntimeConfig], {
     /** Module-specific native event payload; this is not a host loader/ack. */
     load(packet: MessageGraphPayload<PreparedConvolutionPacket>): void;
     /** Once per sample, inside stride-1 forSample with its native scheduler.

package/dist/prepared-convolution.js

@@ -1,5 +1,5 @@
 import { defineSubgraph, f32, f64, i32, instantiate, select, state } from '@unworklet/core';
-import { spectralFft, spectralForEach } from './spectral-fft.js';
+import { spectralDispatchPeriod, spectralFft, spectralForEach } from './spectral-fft.js';
 import { PREPARED_BLOCK as B, PREPARED_FFT_SIZE as N, PREPARED_PARTITIONS as P, PREPARED_VALUES as VALUES, validatePreparedConvolutionConfig } from './convolution-spectrum.js';
 export { prepareConvolutionSpectrum } from './convolution-spectrum.js';
 /** Fixed B128/P64 prepared-spectrum mono convolution candidate.
@@ -9,6 +9,7 @@ export { prepareConvolutionSpectrum } from './convolution-spectrum.js';
  */
 export const preparedConvolution = defineSubgraph((config) => {
     validatePreparedConvolutionConfig(config);
+    const dispatchPeriod = spectralDispatchPeriod(B, config.renderQuantumSize);
     const coefficients = state.buffer.f32({ size: VALUES }).expose({ name: 'coefficients', snapshot: 'persistent' });
     const history = state.buffer.f64({ size: B }).expose({ name: 'historyScaled', snapshot: 'persistent' });
     const previous = state.buffer.f64({ size: VALUES }).expose({ name: 'previousSpectraScaled', snapshot: 'persistent' });
@@ -55,12 +56,15 @@ export const preparedConvolution = defineSubgraph((config) => {
             validSamples.write(select(invalidate, i32(0), validSamples.read()));
             validBlocks.write(select(invalidate, i32(0), validBlocks.read()));
             pendingReset.write(pendingReset.read().or(invalidate));
-            everyNSamples(B, () => {
+            // Keep B-sample frame phase in the persistent cursor. A fresh native
+            // scheduler must also align after snapshots taken inside a B-sample hop.
+            everyNSamples(dispatchPeriod, () => {
+                const frameDue = cursor.read().mod(B).eq(0);
                 const frame = fft.transform(n => select(n.lt(B).and(validSamples.read().gte(i32(B).sub(n))), history.read(cursor.read().add(n).mod(B)), f64(0)), () => f64(0), false);
                 spectralForEach(N, k => {
                     const index = spectrumCursor.read().mul(N).add(k).mul(2);
-                    previous.write(index, frame.real(k));
-                    previous.write(index.add(1), frame.imag(k));
+                    previous.write(index, select(frameDue, frame.real(k), previous.read(index)));
+                    previous.write(index.add(1), select(frameDue, frame.imag(k), previous.read(index.add(1))));
                 });
                 spectralForEach(N, k => {
                     sumReal.write(0);
@@ -82,11 +86,12 @@ export const preparedConvolution = defineSubgraph((config) => {
                 const result = fft.transform(n => mixedReal.read(n), n => mixedImag.read(n), true);
                 spectralForEach(N, n => {
                     const index = cursor.read().add(n).mod(N);
-                    overlap.write(index, select(pendingReset.read(), f64(0), overlap.read(index)).add(result.real(n)));
+                    const prior = overlap.read(index);
+                    overlap.write(index, select(frameDue, select(pendingReset.read(), f64(0), prior).add(result.real(n)), prior));
                 });
-                spectrumCursor.write(spectrumCursor.read().add(1).mod(P));
-                validBlocks.write(validBlocks.read().add(1).min(P - 1));
-                pendingReset.write(false);
+                spectrumCursor.write(select(frameDue, spectrumCursor.read().add(1).mod(P), spectrumCursor.read()));
+                validBlocks.write(select(frameDue, validBlocks.read().add(1).min(P - 1), validBlocks.read()));
+                pendingReset.write(pendingReset.read().and(frameDue.not()));
             });
             const output = select(invalidate.or(pendingReset.read()), f32(0), f32(overlap.read(cursor.read()).div(scale)));
             overlap.write(cursor.read(), f64(0));

package/dist/resident-time-stretch.d.ts

@@ -1,6 +1,8 @@
 import { type EveryNSamples, type Node } from '@unworklet/core';
 import type { ResidentSample } from './sample.js';
 export interface ResidentTimeStretchConfig {
+    /** Pass ctx.renderQuantumSize; aligns native dispatch with snapshot boundaries. */
+    renderQuantumSize: number;
     /** Match ctx.sampleRate; integer 8000..192000. */
     sampleRate: number;
     /** Resident sourceSampleRate must also be an integer in [8000,192000]. */

package/dist/resident-time-stretch.js

@@ -1,5 +1,5 @@
 import { defineSubgraph, f32, f64, i32, select, state } from '@unworklet/core';
-import { spectralForEach } from './spectral-fft.js';
+import { spectralDispatchPeriod, spectralForEach } from './spectral-fft.js';
 // Exact binary internal scaling protects tiny waveform differences from the
 // native 1e-30 scalar-store scrub. Even opposite finite f32 extrema produce
 // a 64-term squared score below 2**649, far inside finite f64 range.
@@ -17,6 +17,7 @@ export const residentTimeStretch = defineSubgraph((config) => {
         ![128, 256].includes(H) || ![0, 8, 16, 32, 64, 128].includes(S)) {
         throw new RangeError('residentTimeStretch requires integer sampleRate/sourceSampleRate [8000,192000], hopSamples 128/256 and searchFrames 0/8/16/32/64/128');
     }
+    const dispatchPeriod = spectralDispatchPeriod(H, config.renderQuantumSize);
     const active = state.bool(false).named('active'), pending = state.bool(false).named('pending');
     const ended = state.bool(false).named('ended'), rejected = state.bool(false).named('rejected');
     const previousGate = state.bool(false).named('previousGate'), revision = state.i32(-1).named('revision');
@@ -70,10 +71,10 @@ export const residentTimeStretch = defineSubgraph((config) => {
             sourceLength.write(select(clear, i32(0), sourceLength.read()));
             const request = c.trigger.or(c.gate.and(previousGate.read().not())).and(c.gate).and(c.reset.not()).and(missing.not());
             pending.write(pending.read().or(request));
-            // 0.4.1 does not snapshot native everyNSamples counters. A 128-sample
-            // scheduler realigns at every allowed snapshot boundary; persistent clock
-            // carries H=256 phase. Search is eager every 128, even when not committing.
-            everyNSamples(128, () => {
+            // Native scheduler counters are not snapshotted. This period divides H
+            // and the actual quantum, so every block-atomic restore realigns dispatch.
+            // The persistent clock carries H phase; off-phase searches do not commit.
+            everyNSamples(dispatchPeriod, () => {
                 const due = clock.read().eq(0), attempt = due.and(pending.read()).and(c.gate).and(c.reset.not());
                 const valid = c.durationScale.gte(.5).and(c.durationScale.lte(2)).and(c.pitchRatio.gte(.5)).and(c.pitchRatio.lte(2));
                 launching.write(attempt.and(valid).and(missing.not()));

package/dist/spatial-chains.d.ts

@@ -1,5 +1,7 @@
 import { type EveryNSamples, type Node } from '@unworklet/core';
 export interface SpatialChainConfig {
+    /** Pass ctx.renderQuantumSize for the early convolution snapshot phase. */
+    renderQuantumSize: number;
     /** Match the enclosing ctx.sampleRate; integer 8000..192000. */
     sampleRate: number;
 }

package/dist/spatial-chains.js

@@ -5,12 +5,12 @@ import { algorithmicReverb } from './reverb.js';
 import { windowedPitchShift } from './windowed-pitch-shift.js';
 // Construction-only composition. Each existing module retains its own state,
 // scheduler and native snapshot contract; no new runtime routing is introduced.
-function spatialPaths({ sampleRate }) {
+function spatialPaths({ sampleRate, renderQuantumSize }) {
     if (!Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) {
         throw new RangeError('spatial chains require integer sampleRate [8000,192000]');
     }
     const color = instantiate(partitionedConvolution, {
-        blockSize: 8, impulse: [.625, 0, 0, .25, 0, 0, 0, -.125],
+        renderQuantumSize, blockSize: 8, impulse: [.625, 0, 0, .25, 0, 0, 0, -.125],
     }, { name: 'earlyColor' });
     const reflections = instantiate(multiTapDelay, {
         sampleRate, maxDelaySeconds: .023,

package/dist/spectral-fft.d.ts

@@ -3,12 +3,18 @@ import { type Node } from '@unworklet/core';
  * No audio/parameter indexing or sample-clock advancement belongs in this body.
  */
 export declare function spectralForEach(size: number, body: (index: Node<'i32'>) => void): void;
+/** Internal sample dispatch period. Native scheduler phase is not snapshotted.
+ * A divisor of both the hop and quantum realigns a fresh scheduler at every
+ * block-atomic restore; persistent module cursors decide when to commit frames.
+ * Keep the historical 128-sample maximum dispatch period at ordinary targets.
+ */
+export declare function spectralDispatchPeriod(hopSize: number, renderQuantumSize: number): number;
 /** Internal construction-fixed FFT. Not a separate runtime or public package API. */
 export declare const spectralFft: import("@unworklet/core").SubgraphDecl<[config: {
     size: number;
 }], {
     /** JS functions/loops run during graph capture. Butterfly iteration uses the
-     * public fixed-128 native forSample loop over work-buffer indices, nested
+     * public fixed-count native forIndex loop over work-buffer indices, nested
      * inside the caller's hop body. It performs no audio I/O or audio-time update.
      * Inputs must not alias these work buffers.
      * Result aliases scratch and must be consumed before the next transform.

package/dist/spectral-fft.js

@@ -1,20 +1,30 @@
-import { SAMPLES_PER_BLOCK, defineSubgraph, f64, forSample, i32, select, state } from '@unworklet/core';
+import { defineSubgraph, f64, forIndex, i32, select, state } from '@unworklet/core';
 /** Internal fixed-capacity buffer iteration, using only public native loops.
  * No audio/parameter indexing or sample-clock advancement belongs in this body.
  */
 export function spectralForEach(size, body) {
-    if (SAMPLES_PER_BLOCK !== 128 || size < 4 || size > 1024 || !Number.isInteger(Math.log2(size))) {
-        throw new RangeError('spectral buffer iteration requires fixed-128 loops and power-of-two size [4,1024]');
+    if (size < 4 || size > 1024 || !Number.isInteger(Math.log2(size))) {
+        throw new RangeError('spectral buffer iteration requires power-of-two size [4,1024]');
     }
-    const stride = Math.max(1, 128 / size);
-    for (let chunk = 0; chunk < Math.max(1, size / 128); chunk++)
-        forSample.byN(stride, inner => body(inner.div(stride).add(chunk * 128)));
+    forIndex(size, body);
+}
+/** Internal sample dispatch period. Native scheduler phase is not snapshotted.
+ * A divisor of both the hop and quantum realigns a fresh scheduler at every
+ * block-atomic restore; persistent module cursors decide when to commit frames.
+ * Keep the historical 128-sample maximum dispatch period at ordinary targets.
+ */
+export function spectralDispatchPeriod(hopSize, renderQuantumSize) {
+    if (!Number.isInteger(renderQuantumSize) || renderQuantumSize < 1) {
+        throw new RangeError('spectral renderQuantumSize must be the positive integer ctx.renderQuantumSize');
+    }
+    let divisor = Math.min(hopSize, 128), remaining = renderQuantumSize;
+    while (remaining !== 0)
+        [divisor, remaining] = [remaining, divisor % remaining];
+    return divisor;
 }
 /** Internal construction-fixed FFT. Not a separate runtime or public package API. */
 export const spectralFft = defineSubgraph((config) => {
     const { size } = config;
-    if (SAMPLES_PER_BLOCK !== 128)
-        throw new RangeError('spectral FFT requires the public unworklet fixed-128 loop contract');
     if (!Number.isInteger(size) || size < 8 || size > 1024 || !Number.isInteger(Math.log2(size))) {
         throw new RangeError('spectral FFT size must be a power of two in [8,1024]');
     }
@@ -33,7 +43,7 @@ export const spectralFft = defineSubgraph((config) => {
     };
     return {
         /** JS functions/loops run during graph capture. Butterfly iteration uses the
-         * public fixed-128 native forSample loop over work-buffer indices, nested
+         * public fixed-count native forIndex loop over work-buffer indices, nested
          * inside the caller's hop body. It performs no audio I/O or audio-time update.
          * Inputs must not alias these work buffers.
          * Result aliases scratch and must be consumed before the next transform.

package/dist/spectral-freeze.d.ts

@@ -1,5 +1,7 @@
 import { type EveryNSamples, type Node } from '@unworklet/core';
 export interface SpectralFreezeConfig {
+    /** Pass ctx.renderQuantumSize; aligns native dispatch with snapshot boundaries. */
+    renderQuantumSize: number;
     /** Construction-fixed power of two in [8,1024]. Reference alignment is size samples. */
     size: number;
     /** Exactly size/2 or size/4. Rebuild to change. */

package/dist/spectral-gate.d.ts

@@ -1,5 +1,7 @@
 import { type EveryNSamples, type Node } from '@unworklet/core';
 export interface SpectralGateConfig {
+    /** Pass ctx.renderQuantumSize; aligns native dispatch with snapshot boundaries. */
+    renderQuantumSize: number;
     /** Construction-fixed power of two in [8,1024]. Reference alignment is size samples. */
     size: number;
     /** Exactly size/2 or size/4. Rebuild to change. */

package/dist/spectral-stft.d.ts

@@ -8,6 +8,7 @@ export interface StftSpectrum {
 export declare function createStftIdentity(config: {
     size: number;
     hopSize: number;
+    renderQuantumSize: number;
 }, maximumSize: number, processSpectrum?: (spectrum: StftSpectrum) => StftSpectrum): {
     tick(input: Node<"f32">, reset: Node<"bool">, everyNSamples: EveryNSamples): Node<"f32">;
 };

package/dist/spectral-stft.js

@@ -1,5 +1,5 @@
 import { f32, f64, i32, instantiate, select, state } from '@unworklet/core';
-import { spectralFft, spectralForEach } from './spectral-fft.js';
+import { spectralDispatchPeriod, spectralFft, spectralForEach } from './spectral-fft.js';
 /** Internal construction only. Public wrappers choose their reviewed capacity. */
 export function createStftIdentity(config, maximumSize, processSpectrum) {
     const { size, hopSize } = config;
@@ -7,6 +7,7 @@ export function createStftIdentity(config, maximumSize, processSpectrum) {
         (hopSize !== size / 2 && hopSize !== size / 4)) {
         throw new RangeError(`stftIdentity requires power-of-two size [8,${maximumSize}] and hopSize size/2 or size/4`);
     }
+    const dispatchPeriod = spectralDispatchPeriod(hopSize, config.renderQuantumSize);
     const fft = instantiate(spectralFft, { size }, { name: 'fft' });
     // Public 0.4.1 flushes buffer writes below 1e-30. Exact power-of-two
     // scaling retains finite f32 subnormals without adding an audio threshold.
@@ -28,12 +29,12 @@ export function createStftIdentity(config, maximumSize, processSpectrum) {
         tick(input, reset, everyNSamples) {
             valid.write(select(reset, i32(0), valid.read()));
             pendingReset.write(pendingReset.read().or(reset));
-            // Native hop counters are not snapshot state in 0.4.1. Dispatch at a
-            // period dividing the 128-sample snapshot boundary; the named persistent
-            // ring cursor carries the actual H phase. For H>128 this eagerly computes
-            // an FFT pair every 128 samples, committing only at the true frame phase.
+            // Native scheduler counters are not snapshot state. The dispatch period
+            // divides both the hop and actual quantum, so a fresh scheduler aligns
+            // after any block-atomic restore. The persistent ring cursor carries H
+            // phase; off-phase FFT results are computed eagerly but never committed.
             // No CPU-saving claim is attached to the select-based commit condition.
-            everyNSamples(Math.min(hopSize, 128), () => {
+            everyNSamples(dispatchPeriod, () => {
                 const frameDue = cursor.read().mod(hopSize).eq(0);
                 // sin(pi*n/N) equals the nonnegative periodic sqrt-Hann window.
                 // Reanchor per frame; one native buffer loop replaces N code copies.

package/dist/spectral-texture.d.ts

@@ -1,5 +1,7 @@
 import { type EveryNSamples, type Node } from '@unworklet/core';
 export interface SpectralBlurConfig {
+    /** Pass ctx.renderQuantumSize; aligns native dispatch with snapshot boundaries. */
+    renderQuantumSize: number;
     /** Construction-fixed power of two in [8,256]; live reference delay is size. */
     size: number;
     /** Exactly size/2 or size/4. */
@@ -8,6 +10,8 @@ export interface SpectralBlurConfig {
     radius: number;
 }
 export interface SpectralCrossSynthesisConfig {
+    /** Pass ctx.renderQuantumSize; aligns native dispatch with snapshot boundaries. */
+    renderQuantumSize: number;
     /** Construction-fixed power of two in [8,256]; live reference delay is size. */
     size: number;
     /** Exactly size/2 or size/4. */

package/dist/spectral.d.ts

@@ -1,4 +1,6 @@
 export interface StftIdentityConfig {
+    /** Pass ctx.renderQuantumSize; aligns native dispatch with snapshot boundaries. */
+    renderQuantumSize: number;
     /** Construction-fixed power of two in [8,1024]. Latency is size samples. */
     size: number;
     /** Exactly size/2 or size/4. Rebuild to change. */
@@ -7,8 +9,8 @@ export interface StftIdentityConfig {
 /** Graph-native FFT/IFFT identity candidate, periodic sqrt-Hann WOLA.
  * Call exactly once inside stride-1 forSample, supplying its everyNSamples.
  * Finite f32 input required. Reset silences immediately and discards that sample.
- * Reset does not rephase frames. For hops above128, FFT work still runs every
- * 128 samples; the persistent cursor controls frame commits and snapshot phase.
+ * Reset does not rephase frames. FFT dispatch divides hop, quantum and 128;
+ * the persistent cursor controls frame commits and snapshot phase.
  * No realtime guarantee.
  */
 export declare const stftIdentity: import("@unworklet/core").SubgraphDecl<[config: StftIdentityConfig], {

package/dist/spectral.js

@@ -3,8 +3,8 @@ import { createStftIdentity } from './spectral-stft.js';
 /** Graph-native FFT/IFFT identity candidate, periodic sqrt-Hann WOLA.
  * Call exactly once inside stride-1 forSample, supplying its everyNSamples.
  * Finite f32 input required. Reset silences immediately and discards that sample.
- * Reset does not rephase frames. For hops above128, FFT work still runs every
- * 128 samples; the persistent cursor controls frame commits and snapshot phase.
+ * Reset does not rephase frames. FFT dispatch divides hop, quantum and 128;
+ * the persistent cursor controls frame commits and snapshot phase.
  * No realtime guarantee.
  */
 export const stftIdentity = defineSubgraph((config) => createStftIdentity(config, 1024));

package/docs/catalog-modulation-fx.md

@@ -13,7 +13,7 @@ Public entries:
 
 All use existing `defineSubgraph` / `instantiate` and state/snapshot mechanisms.
 No loader, routing, serialization, parameter, or test framework is added.
-Keep unworklet at 0.4.1. The root entry does not re-export these candidate modules.
+Use the tested unworklet 0.6.0 dependency. The root entry does not re-export these candidate modules.
 
 ## Shared entry contract
 

package/docs/catalog-status.md

@@ -59,7 +59,9 @@ Contracts, controls and limitations are detailed in [filters](catalog-filters.md
 [filter-bank vocoder](filterbank-vocoder-entry.md),
 and [musical examples](musical-examples.md).
 All remain editable unworklet subgraphs. No parameter, MIDI, state, routing,
-loader, asset or test framework is introduced. Dependencies stay at unworklet 0.4.1. The only initial-DSP source exception is
+loader, asset or test framework is introduced. The current dependency is unworklet
+0.6.0; older measurements below retain their original version and scope. See the
+[0.2.0 migration notes](../CHANGELOG.md#020--2026-11-12). The only initial-DSP source exception is
 a narrowly tested one-sample read-head construction-boundary correction; existing
 common-rate audio/state/WASM parity is required.
 

package/docs/contracts.md

@@ -7,6 +7,16 @@ implemented initial package/site boundary are linked from [the README](../README
 and [the acceptance record](initial-acceptance.md). Later reviewed module-specific
 contracts supersede the provisional choices below.
 
+The current package uses unworklet **0.6.0**. Its entry gate renders in real
+Chromium at 44.1/48/96 kHz, and snapshots include current AudioParam values even
+before rendering or while suspended. The 0.4.1 rate restriction and suspended-edit
+workaround below are historical. Incompatible slot types are now skipped instead
+of reinterpreted; live restore applies saved AudioParams before persistent state.
+See [dependency findings](dependency-findings.md) for the checked regressions and
+remaining constraints. Snapshots still require the same processor/schema, sample
+rate and render quantum; this upgrade does not imply general automation rollback,
+cross-target migration, transient-state clearing or human audio approval.
+
 ## Authority and provisional choices
 
 The approved initial-scope specification says that individual DSP methods and

package/docs/convolution.md

@@ -1,6 +1,6 @@
 # Bounded uniform convolution candidate
 
-`partitionedConvolution({ blockSize, impulse }).tick(input, reset,
+`partitionedConvolution({ blockSize, impulse, renderQuantumSize: ctx.renderQuantumSize }).tick(input, reset,
 everyNSamples)` uses the existing stride-1 `forSample` scheduler. This is a small
 uniform-partition frequency-domain convolution, not a direct FIR relabeled as
 FFT processing. It is CANDIDATE and has no human or realtime acceptance.
@@ -9,6 +9,11 @@ not a practical convolution-reverb or complete catalog §10 capability.
 
 ## Contract
 
+- Pass `ctx.renderQuantumSize` from the enclosing processor. Dispatch runs every
+  `gcd(B, renderQuantumSize)` samples, and the persistent cursor commits only at
+  true B-sample boundaries. This preserves block-atomic snapshot phase even when
+  the quantum does not divide B. Off-phase work is eager; small or coprime
+  quanta increase cost and do not gain realtime clearance.
 - B is a construction-fixed power of two in 4..32; N=2B. The original/fixed IR has
   1..4B taps, each finite in [-1,1], and sum of absolute tap values <=4. Input is
   finite normalized audio [-1,1]; output is not clipped or gain-normalized.
@@ -30,7 +35,7 @@ not a practical convolution-reverb or complete catalog §10 capability.
   are double constants. No treatment of arbitrary nonfinite inputs is promised.
 - Persistent history, overlap, spectra and indices use native full snapshots.
   FFT/mixed-spectrum scratch is transient and rewritten before use. Same graph
-  and rate are required. Changing IR/configuration requires a new graph; no
+  and rate/quantum are required. Changing IR/configuration requires a new graph; no
   migration, IR swap, crossfade, stereo adapter or long-room support is implied.
 
 ## Required evidence

package/docs/dependency-findings.md

@@ -1,61 +1,58 @@
-# unworklet 0.4.1 findings
+# unworklet compatibility findings
 
-The upstream reports #68–106 were read as reports, not assumed verified. These
-checks use registry-installed 0.4.1 packages and the checked-in dependency locks.
-No unworklet repository or dependency source was modified.
+The current checks use registry-installed **0.6.0** packages and the checked-in
+locks. The initial 0.4.1 findings are retained below as historical context; fixes
+are checked against their correct behavior rather than preserving upstream bugs.
+No unworklet source or package internals are patched.
 
-| Issue | Independently observed here | Smallest den-local constraint |
+| Issue | 0.4.1 observation | 0.6.0 regression check and remaining constraint |
 | --- | --- | --- |
-| [#78](https://github.com/yuichkun/unworklet/issues/78) | Real Chromium: gain initialized 0.5 but pre-render snapshot stores 0; editing to 0.25 while suspended still stores last-rendered 0.5. | Save after stable parameter values have rendered. Browser test verifies 0.5 → 0.25 → restored 0.5 in actual output. Suspended preset editing remains unsupported. |
-| [#79](https://github.com/yuichkun/unworklet/issues/79) | Restoring f32(1) into same-name i32 state yields 1065353216. | Gate accepts identical schema/rate only. Do not expose incompatible saved presets without reviewed migration tests. No den serializer added. |
-| [#96](https://github.com/yuichkun/unworklet/issues/96) | duration=896/48000 executes 8 blocks instead of 7. | Fixed gate durations 128/sampleRate and 256/sampleRate are verified by lengths/state; do not infer arbitrary durations are safe. |
-| [#98](https://github.com/yuichkun/unworklet/issues/98) | Unity DC fails the frequency-gain helper with 6.021 dB. | Direct independent sample comparisons; no FFT is needed for this gate. |
-| [#104](https://github.com/yuichkun/unworklet/issues/104) | Default config `{name:'default'}` swallows `{name:'x'}`, output 7 rather than 1. | Required config parameter plus explicit separate instance name renders 1. Used by gate and consumer. |
-| [#106](https://github.com/yuichkun/unworklet/issues/106) | Pure lang type import under TS 5.9.3 ESNext fails with Volar TS2416; ES2023 has zero diagnostics. | ES2023, strict=true, skipLibCheck=false. No type shim or blanket declaration skipping. |
-
-The pinned dependency reproduction assertions intentionally capture known wrong
-behavior. On dependency upgrade, investigate changes and replace them with correct
-regression expectations; do not preserve upstream bugs as product requirements.
-
-`expectAudioMatches` is exercised against an independently calculated one-sample
-memory and against an intentionally incorrect answer. The helper passes the former
-and rejects the latter. No audio snapshot matcher or golden update is used.
-
-Reviewed but **not reproduced** here: #95 (snapshot matcher name reuse), #97
-(integer WAV golden scale). The gate uses no approved golden; its WAVs use the
-existing float encoder, and numerical assertions inspect raw samples. Before future
-golden adoption, test these helper paths rather than assuming approval machinery.
-#100/#101/#102 concern build/HMR reuse; the gate uses a new build process and a new
-AudioContext, and does not claim HMR/repeated in-process build correctness.
-`.uwk` lowering, SIMD, MIDI dispatch, DevTools, arbitrary schema migration, and the
-other reported APIs are outside this fixture; their reports are not cleared by
-this PR. Later lanes must inspect and reproduce the bugs relevant to their APIs.
-
-## Browser sample-rate scope (known, non-blocking)
-
-The supported entry consumer creates a **48000 Hz** AudioContext. Offline render
-coverage at 44100/48000/96000 is separate and does not prove browser support at
-those rates. The manifest names `offlineSampleRates`, `browserRenderedSampleRates`,
-and per-context `browserCoverage` explicitly.
-
-Real Chromium contexts at 44100 and 96000 are also probed: `createNode` refuses the
-plugin's 48000-Hz artifact, reporting the compiled and actual rates. This is the
-intentional safety guard associated with upstream
-[#22](https://github.com/yuichkun/unworklet/issues/22), not a den DSP failure. In
-published 0.4.1, unplugin calls `compile(processor)` without options and its public
-options expose only analysis-artifact and cross-origin-isolation flags. Core
-`compile` supports a rate for offline/custom bundling, but `createNode` does not
-recompile at context rate; `lang/browser.compileSource(source)` likewise has no
-rate argument in 0.4.1. No metadata bypass, custom runtime/loader, or upstream edit
-is introduced. The rejection probes document this limitation; non-48-kHz browser
-support is not an acceptance requirement and does not block den's next lanes.
+| [#78](https://github.com/yuichkun/unworklet/issues/78) | A pre-render snapshot stored gain 0 instead of initial 0.5; suspended edits stored the last rendered value. | Real Chromium snapshots retain initial 0.5 and a suspended edit to 0.25. Rendering verifies 0.5 → 0.25 → restored 0.5 at 44.1/48/96 kHz. |
+| [#79](https://github.com/yuichkun/unworklet/issues/79) | Restoring f32(1) into a same-name i32 slot yielded the reinterpreted bits 1065353216. | The incompatible slot is skipped and keeps its initial i32 value 7. den promises identical-schema/rate continuation; deliberate type changes still need a reviewed migration. |
+| [#96](https://github.com/yuichkun/unworklet/issues/96) | duration=896/48000 executed 8 blocks instead of 7. | Exact 896- and 256-sample durations execute 7 and 2 default quanta. |
+| [#98](https://github.com/yuichkun/unworklet/issues/98) | Unity DC measured 6.021 dB. | Unity DC measures 0 dB; the helper rejects the doubled-gain expectation. Direct sample comparisons remain independent checks. |
+| [#104](https://github.com/yuichkun/unworklet/issues/104) | A default config `{name:'default'}` swallowed `{name:'x'}`, producing 7 instead of 1. | **Still reproduced.** Required config plus a separate explicit instance name renders 1; den continues to use this form. |
+| [#106](https://github.com/yuichkun/unworklet/issues/106) | A lang type import under TS 5.9.3 ESNext failed with Volar TS2416. | Both ES2023 and ESNext pass strict checking with `skipLibCheck:false`. The consumer keeps ES2023 without a declaration shim. |
+
+The 0.5.0 and 0.6.0 [upstream changelog](https://github.com/yuichkun/unworklet/blob/v0.6.0/CHANGELOG.md)
+describes the snapshot, duration, gain, declaration and compilation changes.
+`tests/dependency.spec.ts` and the packed browser entry test independently check
+the paths above. `expectAudioMatches` accepts an independently calculated
+one-sample memory and rejects an intentionally incorrect answer. No audio golden
+is regenerated or approved by these tests.
+
+Reviewed but not independently reproduced here: #95 (snapshot matcher name reuse)
+and #97 (integer WAV golden scale). This gate uses float WAV output and direct
+sample assertions. Build/HMR reuse (#100/#101/#102), arbitrary schema migrations,
+SIMD, DevTools and other APIs remain outside this fixture's coverage.
+
+## Browser sample rate and render quantum
+
+The packed entry consumer renders at **44100, 48000 and 96000 Hz** through the
+public `?worklet` import and `createNode`. At non-default rates, unworklet 0.6.0
+compiles in its generated Web Worker for the actual AudioContext. The test checks
+real output, live gain changes and snapshot restoration at each rate, and records
+the actual rate and quantum in the browser evidence. Offline sample-rate coverage
+is recorded separately; it is not substituted for browser evidence.
+
+A processor compiled directly, including the playground's compiler worker, must
+receive `{ sampleRate: context.sampleRate, renderQuantumSize:
+context.renderQuantumSize ?? 128 }`. Its runtime metadata and schema hash must
+come from that compile result. The playground browser gate separately checks
+44.1/48/96 kHz with 32/128/256-sample quanta. Fixed-length DSP buffer traversal uses
+`forIndex`; FFT lengths and sample-based hop periods are not render quanta.
+See the [spectral contract](spectral.md) for snapshot dispatch behavior.
+
+These tests establish the listed contexts and operations, not arbitrary device
+performance or realtime deadline clearance. Cross-rate snapshot continuation and
+human sound approval remain outside this gate.
 
 ## Tooling security
 
-Vite is pinned to **7.3.6** in both the package and isolated consumer. The earlier
+Vite remains pinned to **7.3.6** in the package and isolated consumers. The former
 7.3.1 pin was affected by
 [GHSA-p9ff-h696-f583](https://github.com/vitejs/vite/security/advisories/GHSA-p9ff-h696-f583)
-and other advisories returned by `npm audit`. The gate only serves a production
-preview on `127.0.0.1`, not a network-exposed development server; nevertheless the
-affected tooling has been replaced. Both lockfiles also resolve the patched
-esbuild dependency. Root and consumer audit results are checked after installation.
+and other reported advisories. The gate serves a production preview on
+`127.0.0.1`; it does not expose a development server to the network. Locks retain
+the patched esbuild dependency. Root and consumer audit results are checked after
+installation.

package/docs/prepared-convolution.md

@@ -1,14 +1,18 @@
 # Prepared-spectrum convolution candidate
 
 `@denaudio/den/prepared-convolution` exports `preparedConvolution`, the host-only
-`prepareConvolutionSpectrum`, and `PreparedConvolutionConfig` /
-`PreparedConvolutionPacket`. This is an offline-validated **CANDIDATE**, without
+`prepareConvolutionSpectrum`, and the types `PreparedConvolutionConfig`,
+`PreparedConvolutionRuntimeConfig` and `PreparedConvolutionPacket`. The original
+configuration type remains the host spectrum shape; the runtime configuration
+extends it with the required render quantum. This is an offline-validated **CANDIDATE**, without
 browser, realtime-capacity or human-audition clearance.
 
 ## Fixed boundary
 
-- Mono, block size B=128, FFT N=256, P=64 partitions. Configuration must be exactly
-  `{ blockSize: 128, partitions: 64 }`; unsupported configurations throw.
+- Mono, block size B=128, FFT N=256, P=64 partitions. Host preparation accepts
+  `{ blockSize: 128, partitions: 64 }`. DSP instantiation additionally requires
+  `renderQuantumSize: ctx.renderQuantumSize`; unsupported configurations throw.
+  The host spectrum and packet format do not depend on the quantum.
 - Original IR: 1..8192 finite real taps, each in [-1,1], with absolute sum <=4.
   No normalization, truncation, sample-rate conversion or output limiter.
 - Audio input must be finite and normalized to [-1,1]. Output can exceed unity.
@@ -54,7 +58,8 @@ import {
 } from '@denaudio/den/prepared-convolution';
 
 const convolver = instantiate(preparedConvolution,
-  { blockSize: 128, partitions: 64 }, { name: 'convolver' });
+  { blockSize: 128, partitions: 64, renderQuantumSize: ctx.renderQuantumSize },
+  { name: 'convolver' });
 const ir = event<PreparedConvolutionPacket>({
   from: 'main', name: 'ir', capacity: CAPACITY_16, payloadCapacity: 131072,
 });
@@ -109,8 +114,8 @@ practical test budget, not a proven bound for every implementation/environment.
 ## Load, reset, state and scheduling
 
 `tick(input, reset, everyNSamples)` returns `{ output, loaded, rejected,
-revision }`. Call it once per sample inside stride-1 native forSample. This
-implementation requires the core 0.4.1 128-sample quantum.
+revision }`. Call it once per sample inside stride-1 native forSample.
+Its fixed buffer loops use `forIndex` independently of the audio quantum.
 
 - Valid full packet: loaded=true, rejected=false. A shorter IR still carries
   the complete padded 32768-value table, so previous coefficients are replaced.
@@ -128,12 +133,16 @@ implementation requires the core 0.4.1 128-sample quantum.
 - Missing/unloaded/rejected assets are silent. Invalidation is logical, not
   secure erasure; bytes may remain in buffers/snapshots until overwritten.
 
-FFT+64-partition MAC+IFFT+OLA run eagerly once every 128 samples, including while
-unloaded. Indices are explicit; native counted loops avoid graph expansion by
-P*N. B equals quantum size, so the dispatch phase is identical at every native
-snapshot boundary. Named persistent cursor, spectral cursor, valid counts,
-coefficients/status/revision, histories and overlap fully describe continuation.
-Same-graph/config/rate native snapshots continue bit-identically. Pending queued
+FFT+64-partition MAC+IFFT+OLA run eagerly every `gcd(128, renderQuantumSize)`
+samples, including while unloaded. Only the persistent cursor's true B-sample
+boundaries commit spectral history, overlap, counters and pending reset. The
+native scheduler realigns after any block-atomic snapshot, even inside a hop.
+Indices are explicit; fixed `forIndex` loops avoid graph expansion by P*N.
+At quantum 32 the eager workload is four times that at 128; coprime quanta can
+increase it by 128 times. These targets do not imply realtime capacity.
+Named persistent cursor, spectral cursor, valid counts, coefficients/status/
+revision, histories and overlap fully describe continuation.
+Same-graph/config/rate/quantum native snapshots continue bit-identically. Pending queued
 messages, cross-configuration migration and live-swap crossfades are outside
 this contract. Transient FFT/mix buffers are overwritten before use.
 

package/docs/resident-time-stretch.md

@@ -8,7 +8,8 @@ a phase vocoder, formant preservation or a transparent general-purpose stretcher
 
 ## Entry, native ownership and cost
 
-Instantiate with `sampleRate: ctx.sampleRate` (integer 8000..192000), an existing
+Instantiate with `sampleRate: ctx.sampleRate` (integer 8000..192000),
+`renderQuantumSize: ctx.renderQuantumSize` (positive integer), an existing
 `ResidentSample`, `hopSamples: 128 | 256` (default 256) and
 `searchFrames: 0 | 8 | 16 | 32 | 64 | 128` (default 64). H is the synthesis hop in
 output frames; the two overlapping source grains each span 2 H output frames.
@@ -30,13 +31,16 @@ buffer. Resident PCM and ingress allocation are shared, not copied per instance.
 Sixteen maximum ingress slots reserve 4 MiB, plus 256 KiB resident PCM.
 
 The graph uses bounded native counted loops, not expanded code per PCM frame or
-search candidate. Every 128 output samples it evaluates 64 reference reads and
+search candidate. Every `gcd(H, 128, renderQuantumSize)` output samples it
+evaluates 64 reference reads and
 (2 S+1)×64 candidate comparisons; each comparison uses zero-padded linear sampling.
-H256 commits only alternate evaluations. This eager 128 scheduling, including
-when stopped, is deliberate: unworklet 0.4.1's native hop counters are not snapshot
+Only true H-sample boundaries commit evaluations. This eager scheduling,
+including when stopped, is deliberate: unworklet's native hop counters are not snapshot
 state, whereas the module's persistent H clock is. Muting/gate-off does not remove
 search cost. S0 still evaluates the zero-offset baseline. Maximum S128 means
-16,448 comparisons per 128-sample quantum; there is no average-cost CPU-saving claim.
+16,448 comparisons per dispatch. Quantum 32 causes four times the work per
+sample of quantum 128; a quantum coprime to 128 can increase it by 128 times.
+There is no average-cost CPU-saving claim or realtime clearance.
 
 ## Controls, launch and transitions
 
@@ -120,7 +124,9 @@ All launch/clock/time/grain/EOF and resident state use native persistent snapsho
 comparison, score and output scratch are transient. Restoration is bit-identical
 only for the same graph, configuration, resident metadata and rate, at the native
 quantum boundaries. In particular, H256 halfway-hop and pending launches must
-continue exactly after a 128-aligned snapshot. No serializer or migration layer is
+continue exactly after any native block-aligned snapshot at the same rate and
+quantum. The persistent clock retains hop phase while the native dispatch
+period divides the actual quantum. No serializer or migration layer is
 introduced.
 
 ## Audible and acceptance limits

package/docs/spatial-chains-entry.md

@@ -22,12 +22,13 @@ catalog categories. Existing frozen-tail support remains separate.
 
 One new subpath, `@denaudio/den/spatial-chains`; no root-entry re-export:
 
-- `hybridReverb({ sampleRate }).tick(input, controls, everyNSamples)` returns
+- `hybridReverb({ sampleRate, renderQuantumSize }).tick(input, controls, everyNSamples)` returns
   `{ left, right }`.
-- `feedforwardPitchedReverb({ sampleRate, windowSamples? }).tick(input,
+- `feedforwardPitchedReverb({ sampleRate, renderQuantumSize, windowSamples? }).tick(input,
   controls, everyNSamples)` returns `{ left, right, ratioRejected }`.
 - `SpatialChainConfig`: integer `sampleRate` in 8000..192000, taken from the
-  enclosing `ctx.sampleRate`.
+  enclosing `ctx.sampleRate`, and positive integer `renderQuantumSize` from
+  `ctx.renderQuantumSize` for the early convolution's snapshot-safe dispatch.
 - `FeedforwardPitchedReverbConfig`: same rate plus even integer `windowSamples`
   in 32..16384, default 2048. This is the pitch delay excursion, not a grain or
   FFT-frame duration.
@@ -147,7 +148,7 @@ advances the pitched entry's readers. Retrigger resets both pitch phases before
 their current read, retains history and can click. No smoothing or universally
 click-free automation, reset, retrigger or bypass is claimed.
 
-Use only native same-rate, same-schema snapshots. Every inherited persistent
+Use only native same-rate, same-quantum, same-schema snapshots. Every inherited persistent
 history/cursor/valid count, convolution scheduling state, FDN damping state and
 pitch ratio/phase persists; transient scratch must be rewritten before use.
 Restore requires the same configuration and coordinated input/control timeline.

package/docs/spectral-freeze-entry.md

@@ -8,7 +8,7 @@ sustain, phase-vocoder or phase-locking claim.
 
 ## Public contract
 
-`spectralFreeze({ size, hopSize }).tick(input, freeze, reset, everyNSamples)`
+`spectralFreeze({ size, hopSize, renderQuantumSize: ctx.renderQuantumSize }).tick(input, freeze, reset, everyNSamples)`
 
 - Instantiate once with an explicit subgraph name. Call exactly once per sample
   inside stride-1 `forSample`, supplying its existing `everyNSamples`.
@@ -79,15 +79,17 @@ Persistent state contains the existing history/overlap/cursor/reset state, two
 (N/2+1)-element f64 capture planes, the hold flag, held phase and a private
 modulo-H sample clock. The latter mirrors the reviewed framing cursor%H; neither
 clock changes phase on reset. Frame controls and capture decisions are transient.
-Full snapshots continue exactly for the identical graph, configuration and rate.
+Full snapshots continue exactly for the identical graph, configuration, rate
+and quantum.
 Tests cover inactive, frozen, post-reset and release/rearm states at every
-128-sample snapshot offset class. No cross-rate or cross-configuration migration
-promise is added.
-
-The shared STFT dispatch remains every min(H,128) samples. For H>128, the FFT,
-hook and IFFT still execute eagerly every128 samples; only true t=mH frames
-capture, advance the held phase or commit overlap. These extra hook calls do not
-change persistent capture/hold phase. No CPU saving is implied by a select.
+native block-aligned snapshot offset class, including non-128 boundaries.
+No cross-rate, cross-quantum or cross-configuration migration promise is added.
+
+The shared STFT dispatch runs every `gcd(H, 128, renderQuantumSize)` samples.
+The FFT, hook and IFFT execute eagerly, but only true t=mH frames capture,
+advance the held phase or commit overlap. These extra hook calls do not change
+persistent capture/hold phase. No CPU saving is implied by a select; smaller or
+coprime quanta increase workload as documented in the [spectral contract](spectral.md).
 
 ## Headroom derivation
 

package/docs/spectral-gate-entry.md

@@ -7,7 +7,7 @@ This is one bounded spectral effect built on the independently reviewed
 
 ## API and meaning
 
-- `spectralGate({ size, hopSize }).tick(input, threshold, floor, reset, everyNSamples)`
+- `spectralGate({ size, hopSize, renderQuantumSize: ctx.renderQuantumSize }).tick(input, threshold, floor, reset, everyNSamples)`
 - Construction-fixed power-of-two N=8..1024 and H=N/2 or N/4.
 - Input: finite normalized f32 audio in [-1,1]. Controls: f32. Threshold is clamped to [0,max-f32], floor to [0,1];
   infinities saturate, NaN threshold becomes 0 and NaN floor becomes 1 (all-pass).
@@ -29,9 +29,11 @@ This is one bounded spectral effect built on the independently reviewed
 ## Framing, state and headroom
 
 Retain the original periodic sqrt-Hann analysis/synthesis windows, normalization
-2H/N, reset discard semantics, persistent cursor, and every min(H,128) dispatch.
-For H>128 an FFT/IFFT pair still executes every128 samples; only cursor%H==0
-commits frames. No H-rate CPU-saving claim.
+2H/N, reset discard semantics and persistent cursor. Dispatch now follows
+`gcd(H, 128, renderQuantumSize)` to align every native snapshot boundary; only
+cursor%H==0 commits frames. Off-phase FFT/IFFT work is eager. See the shared
+[spectral contract](spectral.md) for increased costs at small or coprime quanta;
+there is no H-rate CPU-saving claim.
 
 The WOLA alignment/reference delay is N samples; a processed transient can spread
 across its synthesis frame [t,t+N), so its first nonzero sample need not occur at
@@ -43,7 +45,7 @@ old history/overlap and leaves absolute frame phase unchanged.
 
 Only the existing history, overlap, cursor, valid history and pending reset need
 persistent storage. Frame controls and spectrum work are transient and overwritten
-before use. Identical graph/rate full-snapshot continuation remains in scope.
+before use. Identical graph/rate/quantum full-snapshot continuation remains in scope.
 
 Attenuating bins can increase individual time-domain peaks. For normalized input,
 an ideal contraction bound per frame and the overlapping windows give the
@@ -52,10 +54,12 @@ not a limiter or loudness promise; measured peaks accompany candidate evidence.
 
 ## Implementation boundary and verification
 
-Add a narrow optional internal construction-time spectrum-copy hook to the
+The original gate entry added a narrow optional internal construction-time
+spectrum-copy hook to the
 existing STFT function. The identity branch must produce the same graph, schema,
-PCM and full snapshots as its frozen predecessor. Do not modify the FFT kernel,
-existing convolution or unworklet. The public gate wrapper is separate; shared
+PCM and full snapshots as its frozen predecessor. The 0.2.0 compatibility
+migration separately replaces fixed-quantum FFT loops and extends snapshot-safe
+dispatch; its numerical and continuation assertions preserve this gate behavior. The public gate wrapper is separate; shared
 exports, CI and site belong to integration.
 
 Required tests: independent direct DFT/bin-mask/inverse-DFT/time-indexed WOLA;

package/docs/spectral-large-candidate.md

@@ -22,6 +22,13 @@ for windowed framing, snapshots, practical concurrency or realtime acceptance.
 
 ## Persistent frame phase
 
+The measurements and dispatch description below record the original 0.4.1
+candidate at quantum 128. Since den 0.2.0, callers pass `ctx.renderQuantumSize`
+and dispatch is `gcd(H, 128, renderQuantumSize)`; fixed FFT loops use `forIndex`.
+The [current spectral contract](spectral.md) describes snapshot behavior and
+increased work for smaller or coprime quanta. Historical timings below are not
+measurements of those targets.
+
 Public unworklet 0.4.1 has no condition-driven statement block. Its select is
 eager; everyNSamples/byN bounds are construction-fixed. Native everyNSamples
 counters are omitted from snapshots. Simply changing a hop to256 or512 would

package/docs/spectral-texture-entry.md

@@ -7,6 +7,9 @@ locking, human sound approval, or real-time clearance.
 
 ## Shared framing
 
+- Pass `renderQuantumSize: ctx.renderQuantumSize` in both module configurations.
+  Dispatch follows the shared [spectral contract](spectral.md), preserving
+  block-atomic snapshot phase at the actual render quantum.
 - Construction-fixed power-of-two N=8..256, H=N/2 or N/4. Rebuild to change.
 - Instantiate with an explicit subgraph name and call exactly once per sample
   inside stride-1 `forSample`, passing its native `everyNSamples`.
@@ -16,11 +19,11 @@ locking, human sound approval, or real-time clearance.
   synthesis, forward unnormalized DFT, inverse 1/N, WOLA scale 2H/N, internal
   2^128 scaling, and live reference delay N.
 - A committed frame at t=mH consumes [t-N,t), excludes current input, and samples
-  controls at t. Missing startup/reset history is zero padded. H<=128 divides
-  the native 128-sample block; there are no eager noncommitting frame calls.
-  The existing N1024 single-input clearance is not inherited: two full framers
-  add cost and scheduling/state proof obligations. N<=256 bounds that initial
-  composition and avoids H>128's eager noncommitting hooks entirely.
+  controls at t. Missing startup/reset history is zero padded. Dispatch occurs
+  every `gcd(H, 128, renderQuantumSize)` samples; off-phase work is eager and
+  commits no overlap. At the original quantum 128, H<=128 needs no off-phase
+  calls. Smaller or coprime quanta add work; the N1024 single-input evidence is
+  not inherited by this two-framer composition. N<=256 retains its initial bound.
 - Clamp amount to [0,1]; NaN becomes 0, infinities clamp. Interpolation is linear
   in bin magnitude, not dB, power, audio time, or equal-power gain. It replaces
   newly committed frames; previous overlap remains until it finishes within N.
@@ -31,7 +34,7 @@ locking, human sound approval, or real-time clearance.
 
 ## Frequency-magnitude blur
 
-`spectralBlur({ size, hopSize, radius }).tick(input, amount, reset, everyNSamples)`
+`spectralBlur({ size, hopSize, radius, renderQuantumSize }).tick(input, amount, reset, everyNSamples)`
 
 Radius is a fixed integer 1..min(8,N/2-1). Let X[k] be the full two-sided complex
 DFT and A[k]=|X[k]|. Define a circular triangular blur on the raw, two-sided DFT
@@ -76,7 +79,7 @@ not a time-memory blur or a freeze.
 
 ## Gain-bounded cross-synthesis
 
-`spectralCrossSynthesis({ size, hopSize, maxGain }).tick(carrier, modulator, amount, reset, everyNSamples)`
+`spectralCrossSynthesis({ size, hopSize, maxGain, renderQuantumSize }).tick(carrier, modulator, amount, reset, everyNSamples)`
 
 maxGain is a finite construction-fixed number in [1,16]. Let C[k], M[k] be the
 synchronized carrier/modulator frames, A[k]=|C[k]|, and B[k]=|M[k]|:
@@ -124,11 +127,12 @@ per instance. Magnitudes, FFT buffers, windows and sampled controls are transien
 and are fully recomputed before use at the next frame. No cross-frame blur
 memory or private snapshot format is introduced.
 
-Only full native same-graph/configuration/sample-rate snapshots are supported.
+Only full native same-graph/configuration/sample-rate/quantum snapshots are supported.
 Restoring only one member of a cross-synthesis pair is outside the contract.
 Tests must prove exact continuation across every legal H class at native
-128-sample boundaries, including active processing, pending reset, and held
-reset. No cross-configuration/schema/rate migration is promised.
+block boundaries, including non-128-aligned boundaries, active processing,
+pending reset, and held reset. No cross-configuration/schema/rate/quantum
+migration is promised.
 
 ## Ideal headroom and validation
 

package/docs/spectral.md

@@ -7,23 +7,26 @@ realtime clearance is implied.
 
 ## Entry contract
 
-`stftIdentity({ size, hopSize }).tick(input, reset, everyNSamples)` is an ordinary
+`stftIdentity({ size, hopSize, renderQuantumSize: ctx.renderQuantumSize }).tick(input, reset, everyNSamples)` is an ordinary
 unworklet subgraph. Instantiate it once with an explicit name. Call tick exactly
 once per sample from stride-1 `forSample((i, everyNSamples) => ...)`. The last
 argument is unworklet's existing conditional scheduler, not a den scheduler or a
 runtime JavaScript callback. `select` is never used to skip the FFT workload.
 
+- Pass the enclosing processor's `ctx.renderQuantumSize` in the configuration.
+  It is a positive integer, matching unworklet's compile target, not the FFT size
+  or hop. All STFT-based modules use this value for snapshot-safe dispatch.
 - Supported N is a power of two in 8..1024. H is N/2 or N/4. These are
   offline-candidate bounds, not a performance or concurrency recommendation.
 - The internal, non-public complex radix-2 kernel has natural-order real/imaginary
   planes, forward exponent -i2πkn/N, inverse exponent +i2πkn/N and inverse scale 1/N.
   All intermediate work/history use fixed f64 buffers; I/O is f32. The stream
   uses an exact 2^128 scale internally to avoid 0.4.1's 1e-30 buffer-write
-  flush discarding quiet f32 inputs. Stage/chunk JavaScript loops execute during
-  graph construction. Within each stage, the public fixed-128 `forSample` loop
-  iterates explicitly addressed work buffers, without audio/parameter reads or
-  updates to sample time. The kernel checks `SAMPLES_PER_BLOCK===128`; other
-  quantum sizes are unsupported. Twiddle step constants are calculated at build
+  flush discarding quiet f32 inputs. Stage JavaScript loops execute during
+  graph construction. Within each stage, the public `forIndex(count)` loop
+  visits exactly the work-buffer capacity, independently of the render quantum,
+  without audio/parameter reads or updates to sample time. The outer `forSample`
+  loop alone follows the audio quantum. Twiddle step constants are calculated at build
   time, then a bounded f64 recurrence reanchors to (1,0) at every butterfly group.
 - A frame at sample t=mH consumes samples [t-N,t), with absent history set to
   zero. It is added to output samples [t,t+N). Output therefore has exactly N
@@ -41,14 +44,17 @@ runtime JavaScript callback. `select` is never used to skip the FFT workload.
   or new storage/snapshot system is supplied.
 - Native persistent history/overlap/cursor/valid/reset state is saved. FFT and
   spectral scratch are transient and fully overwritten at each scheduled frame.
-  Only identical graph/rate full-snapshot continuation is in scope; migration
-  and cross-rate continuation are not promised.
-  Native 0.4.1 hop counters are not included in offline snapshots. Dispatch
-  therefore occurs every min(H,128) samples, a divisor of the128-sample restore
-  boundary; the named persistent cursor modulo H selects frame commits. For
-  H>128 the FFT pair still executes every128 samples and off-phase results are
-  discarded. This explicitly preserves snapshot phase rather than promising
-  H-rate CPU savings. See [large-frame evidence](spectral-large-candidate.md).
+  Only identical graph/rate/quantum full-snapshot continuation is in scope;
+  migration and cross-rate or cross-quantum continuation are not promised.
+  Native hop counters are not included in snapshots. Dispatch therefore occurs
+  every `gcd(H, 128, renderQuantumSize)` samples, a divisor of both the hop and
+  every block-atomic restore boundary. The persistent cursor modulo H selects
+  frame commits. Off-phase FFT results are computed eagerly and discarded.
+  At quantum 128 this retains the former dispatch period. For H>=128, quantum
+  32 evaluates four times as many FFT pairs per sample; a quantum coprime to
+  128 dispatches every sample, up to 128 times the old workload. Correct output
+  and snapshot phase do not imply realtime feasibility. See
+  [large-frame evidence](spectral-large-candidate.md) for historical costs.
 
 ## Verification required before integration
 
@@ -56,13 +62,16 @@ Independent direct O(N²) DFT covers complex impulse, DC, Nyquist, positive and
 negative bins, off-bin tone, seeded inputs, signs, natural ordering, conjugate
 symmetry and inverse normalization. Independent time-indexed DFT/WOLA covers
 startup, every hop phase, held/arbitrary resets, block boundaries and three
-offline rates (44.1/48/96 kHz). Exact same-schema snapshots and reset discard are
-checked separately. Larger construction sizes require measured capture/compile
+offline rates (44.1/48/96 kHz). The rate/quantum matrix includes quantum
+32/128/256, independent numerical oracles and exact quantum-128 PCM comparisons.
+Exact same-schema snapshots include non-128-aligned boundaries at quantum 32
+and non-power-of-two quantum 48. Reset discard is checked separately. Larger construction sizes require measured capture/compile
 cost, WASM size, memory and quantum-burst timing before becoming public bounds.
 
 Node driver measurements describe that environment only, including whether copies
 were included. They do not certify browser deadlines, concurrency or a device
-budget. The browser boundary remains unworklet 0.4.1's existing 48-kHz support.
+budget. The playground now compiles for its actual AudioContext sample rate and
+render quantum using unworklet 0.6.0; this does not grant realtime clearance.
 
 ## Initial local evidence
 

package/docs/voice-policy.md

@@ -31,8 +31,8 @@ All voice and held-key storage uses unworklet transient state. Snapshots exclude
 
 ## Verification
 
-The numerical fixture renders voice state through diagnostic outputs using published unworklet 0.4.1. It checks FIFO duplicates, stolen-note releases, release reuse, mono priority/legato/retrigger, channel controls, reset, independent instances, bounded overflow and repeated reuse. These outputs are diagnostics, not audition audio or approved goldens. Offline 44.1/48/96 kHz tests do not extend the browser gate's existing 48 kHz support claim.
+The numerical fixture renders voice state through diagnostic outputs using published unworklet 0.6.0. It checks FIFO duplicates, stolen-note releases, release reuse, mono priority/legato/retrigger, channel controls, reset, independent instances, bounded overflow and repeated reuse. These outputs are diagnostics, not audition audio or approved goldens. Offline 44.1/48/96 kHz tests are separate from the [browser entry coverage](dependency-findings.md#browser-sample-rate-and-render-quantum).
 
-Upstream issue #99 is independently reproduced: `expectMidiBalance` counts velocity-zero note-on as another held note. Den uses explicit numerical gate/identity assertions instead. The fixture stays inside the last render quantum to avoid the independently reproduced #96 duration rounding issue. No dependency changes or helper patches are made.
+Upstream [#99](https://github.com/yuichkun/unworklet/issues/99) was fixed in unworklet 0.5.0: `expectMidiBalance` treats velocity-zero note-on as note termination. The 0.6.0 regression accepts a positive-velocity note-on followed by velocity-zero note-on, and rejects both a hanging note and an additional unmatched note-off. Den retains its independent numerical gate/identity assertions. The legacy half-sample duration margin remains in this fixture; exact-duration behavior is checked separately in the [dependency regressions](dependency-findings.md).
 
 Capacity probes also exposed recursive expression expansion in unworklet's analysis of nested selects. Transient scratch accumulators keep the traversal and selection expressions shallow. Before this change the default-capacity test was stopped after more than one minute of CPU work; afterward the full numerical suite including capacity probes ran in seconds. A 64-voice/256-held diagnostic graph failed WebAssembly compilation with `local count too large`; the supported construction ceiling is therefore 32 voices, tested with 256 held identities. Larger combined instrument graphs still require their own compile and runtime budget checks. The current release-completion path performs rank maintenance across slots; passing these fixtures does not establish a real-time CPU budget for a complete instrument.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@denaudio/den",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Composable DSP modules and instrument/delay engines for unworklet",
   "type": "module",
   "license": "MIT OR Apache-2.0",
@@ -251,14 +251,14 @@
     "test:release": "node --test tests/release.test.mjs tests/release-package.test.mjs"
   },
   "peerDependencies": {
-    "@unworklet/core": "0.4.1"
+    "@unworklet/core": "0.6.0"
   },
   "devDependencies": {
-    "@unworklet/core": "0.4.1",
-    "@unworklet/lang": "0.4.1",
-    "@unworklet/offline": "0.4.1",
-    "@unworklet/test": "0.4.1",
-    "@unworklet/unplugin": "0.4.1",
+    "@unworklet/core": "0.6.0",
+    "@unworklet/lang": "0.6.0",
+    "@unworklet/offline": "0.6.0",
+    "@unworklet/test": "0.6.0",
+    "@unworklet/unplugin": "0.6.0",
     "playwright": "1.60.0",
     "typescript": "5.9.3",
     "vite": "7.3.6",