@scalable-vector-audio/sva-wasm 0.5.1 → 0.7.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "@scalable-vector-audio/sva-wasm",
   "type": "module",
   "description": "JS bindings: a composition a page fills node by node, rendered in the browser",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/sva_wasm.d.ts

@@ -1,55 +1,46 @@
 /* tslint:disable */
 /* eslint-disable */
 
-export class Checkpoint {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    readonly position: number;
-}
-
 export class Composition {
     free(): void;
     [Symbol.dispose](): void;
-    bound_cache(max_bytes: number): void;
-    /**
-     * Empties the memory tier only: a persistent pack outlives it by design.
-     */
     clear_cache(): void;
-    clear_volatile(): void;
     insert(path: string, text: string): void;
     constructor(name?: string | null);
     /**
-     * `name` labels the composition as `new` does; renders persist under `cache` in a dedicated
-     * worker's private file system, and anywhere none opens, or `cache` is held, memory-only.
+     * Over the store in `dir`, an origin-private file system directory, or memory alone
+     * where there is none.
      */
-    static persistent(name: string | null | undefined, cache: string, max_bytes?: number | null): Promise<Composition>;
+    static open(name?: string | null, dir?: FileSystemDirectoryHandle | null): Promise<Composition>;
     /**
-     * Unset, `target` is `master`; `until` is the horizon in seconds, or `"silent"` to end
-     * where every later sample is provably under `2^-bits` (default the profile's own), by
-     * `max_secs` at the latest. `rate` is the observation rate. What reads a `volatile`
-     * parameter is kept in a slot, never in either store.
+     * The only write to the directory `open` was handed: every value computed since the last.
      */
-    render(target: string | null | undefined, rate: number | null | undefined, until: any, volatile?: string[] | null, bits?: number | null, max_secs?: number | null): Rendering;
+    persist(): Promise<number>;
     /**
-     * A stream of `target` (`master` unset) at `rate`, `block` samples a block, each key of
-     * `bindings` a named argument on the target. `until: "silent"` ends it at the first block
-     * whose end proves every later sample under `2^-bits`, throwing past `max_secs`.
+     * `"oldest"` evicts what the latest render neither stored nor read, `"forks"` every value
+     * fewer than two nodes read.
      */
-    stream(target: string | null | undefined, rate: number | null | undefined, block: number, bindings: any, until: any, bits?: number | null, max_secs?: number | null): Stream;
+    prune(policy: string): void;
     /**
-     * The memory tier's, as `cache_max_bytes` is; `persistent_bytes` is the pack's.
+     * `target` as `sva-cli render` takes it, `@piano([0, 2b], f0=C4)`; `representations`
+     * what `representations()` answers, `samples` where unset, each a call as
+     * `--representation` writes it. `options` sets `rate`, `bits`, `flop_budget`, `until`,
+     * `volatile` and `cache`.
      */
-    readonly cache_bytes: number;
-    readonly cache_max_bytes: number;
-    readonly persistent: boolean;
+    render(target: string, representations: string[] | null | undefined, options: any): Promise<Rendering>;
+    set_cache_policy(policy: string): void;
+    set_prune_policy(policy: string): void;
     /**
-     * Zero on a memory-only composition, as `persistent_max_bytes` is.
+     * `target` block by block, through this store. `options`: `rate`, `bits`, `until`, `cache`,
+     * `live`.
      */
-    readonly persistent_bytes: number;
-    readonly persistent_max_bytes: number;
-    volatile_max_bytes: number;
-    readonly volatile_bytes: number;
+    stream(target: string, block: number, options: any): Stream;
+    readonly cache_bytes: number;
+    readonly cache_entries: number;
+    readonly cache_evictions: number;
+    cache_max_bytes: number;
+    readonly cache_policy: string;
+    readonly prune_policy: string;
 }
 
 export class Rendering {
@@ -57,45 +48,59 @@ export class Rendering {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * The object `sva-cli render --as <name>` puts under `data`, arrays capped as it caps.
+     * The object `sva-cli render` puts under `data`, one reading per representation asked,
+     * arrays capped as it caps.
      */
-    query(representation: string, from_secs?: number | null, to_secs?: number | null): any;
-    samples(channel: number, from_secs?: number | null, to_secs?: number | null): Float32Array;
+    representations(): any;
+    samples(channel: number): Float32Array;
     /**
-     * The object `sva-cli render` puts under `data.cache.stats`.
+     * Every lookup this render made of the composition's store, and what each came to.
      */
     stats(): any;
     work(): any;
     readonly channels: number;
     readonly duration_secs: number;
     readonly sample_rate: number;
+    readonly start_secs: number;
     readonly target: string;
 }
 
 /**
- * A target block by block, for a player that cannot know how long a note is held.
+ * A target block by block, reading `@notes` as the sum of its terms, as `@hall(t, x=@notes)`.
+ * A key-up replaces a term with one whose release is a number. A term leaves with its handle
+ * once its node ends, bar the last.
  */
 export class Stream {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    checkpoint(): Checkpoint;
+    /**
+     * `term` summed into `@notes`.
+     */
+    add(term: string): number;
+    /**
+     * `expr` in place of the target.
+     */
+    edit(expr: string): void;
     /**
      * Writes the next block into `out`, component `c` from `c * block`, and returns the
      * samples each component took: `block`, fewer where silence ends inside it, `0` after.
      */
     next(out: Float32Array): number;
+    remove(handle: number): boolean;
     /**
-     * `until` as `stream` takes it, `max_secs` counted from the checkpoint.
+     * False where the stream no longer holds `handle`.
      */
-    resume(checkpoint: Checkpoint, bindings: any, until: any, bits?: number | null, max_secs?: number | null): Stream;
+    replace(handle: number, term: string): boolean;
+    stats(): any;
     /**
-     * `{ samples, proofs, priced_flops, waves }` since it opened or resumed.
+     * `{ samples, priced_flops, waves }` since it opened.
      */
     work(): any;
     readonly block: number;
     readonly channels: number;
     readonly end: number | undefined;
+    readonly held_bytes: number;
     readonly position: number;
     readonly sample_rate: number;
 }
@@ -111,48 +116,53 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly __wbg_checkpoint_free: (a: number, b: number) => void;
     readonly __wbg_composition_free: (a: number, b: number) => void;
     readonly __wbg_rendering_free: (a: number, b: number) => void;
     readonly __wbg_stream_free: (a: number, b: number) => void;
     readonly builtins: () => [number, number, number];
-    readonly checkpoint_position: (a: number) => number;
-    readonly composition_bound_cache: (a: number, b: number) => void;
     readonly composition_cache_bytes: (a: number) => number;
+    readonly composition_cache_entries: (a: number) => number;
+    readonly composition_cache_evictions: (a: number) => number;
     readonly composition_cache_max_bytes: (a: number) => number;
+    readonly composition_cache_policy: (a: number) => [number, number];
     readonly composition_clear_cache: (a: number) => void;
-    readonly composition_clear_volatile: (a: number) => void;
     readonly composition_insert: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly composition_is_persistent: (a: number) => number;
     readonly composition_new: (a: number, b: number) => number;
-    readonly composition_persistent: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
-    readonly composition_persistent_bytes: (a: number) => number;
-    readonly composition_persistent_max_bytes: (a: number) => number;
-    readonly composition_render: (a: number, b: number, c: number, d: number, e: any, f: number, g: number, h: number, i: number, j: number) => [number, number, number];
-    readonly composition_set_volatile_max_bytes: (a: number, b: number) => void;
-    readonly composition_stream: (a: number, b: number, c: number, d: number, e: number, f: any, g: any, h: number, i: number, j: number) => [number, number, number];
-    readonly composition_volatile_bytes: (a: number) => number;
-    readonly composition_volatile_max_bytes: (a: number) => number;
+    readonly composition_open: (a: number, b: number, c: number) => any;
+    readonly composition_persist: (a: number) => any;
+    readonly composition_prune: (a: number, b: number, c: number) => [number, number];
+    readonly composition_prune_policy: (a: number) => [number, number];
+    readonly composition_render: (a: number, b: number, c: number, d: number, e: number, f: any) => any;
+    readonly composition_set_cache_max_bytes: (a: number, b: number) => void;
+    readonly composition_set_cache_policy: (a: number, b: number, c: number) => [number, number];
+    readonly composition_set_prune_policy: (a: number, b: number, c: number) => [number, number];
+    readonly composition_stream: (a: number, b: number, c: number, d: number, e: any) => [number, number, number];
     readonly outline: (a: number, b: number) => [number, number, number];
     readonly rendering_channels: (a: number) => number;
     readonly rendering_duration_secs: (a: number) => number;
-    readonly rendering_query: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+    readonly rendering_representations: (a: number) => [number, number, number];
     readonly rendering_sample_rate: (a: number) => number;
-    readonly rendering_samples: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+    readonly rendering_samples: (a: number, b: number) => [number, number, number, number];
+    readonly rendering_start_secs: (a: number) => number;
     readonly rendering_stats: (a: number) => [number, number, number];
     readonly rendering_target: (a: number) => [number, number];
     readonly rendering_work: (a: number) => [number, number, number];
+    readonly stream_add: (a: number, b: number, c: number) => [number, number, number];
     readonly stream_block: (a: number) => number;
     readonly stream_channels: (a: number) => number;
-    readonly stream_checkpoint: (a: number) => number;
+    readonly stream_edit: (a: number, b: number, c: number) => [number, number];
     readonly stream_end: (a: number) => [number, number];
+    readonly stream_held_bytes: (a: number) => number;
     readonly stream_next: (a: number, b: number, c: number, d: any) => [number, number, number];
     readonly stream_position: (a: number) => number;
-    readonly stream_resume: (a: number, b: number, c: any, d: any, e: number, f: number, g: number) => [number, number, number];
+    readonly stream_remove: (a: number, b: number) => [number, number, number];
+    readonly stream_replace: (a: number, b: number, c: number, d: number) => [number, number, number];
     readonly stream_sample_rate: (a: number) => number;
+    readonly stream_stats: (a: number) => [number, number, number];
     readonly stream_work: (a: number) => [number, number, number];
     readonly wasm_bindgen__convert__closures_____invoke__h76bd71bceeca2b95: (a: number, b: number, c: any, d: any) => void;
     readonly wasm_bindgen__convert__closures_____invoke__hd55bb211d6a08150: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h2cf8ee606c8af385: (a: number, b: number) => any;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/sva_wasm.js

@@ -1,32 +1,5 @@
 /* @ts-self-types="./sva_wasm.d.ts" */
 
-export class Checkpoint {
-    static __wrap(ptr) {
-        const obj = Object.create(Checkpoint.prototype);
-        obj.__wbg_ptr = ptr;
-        CheckpointFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        CheckpointFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_checkpoint_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    get position() {
-        const ret = wasm.checkpoint_position(this.__wbg_ptr);
-        return ret;
-    }
-}
-if (Symbol.dispose) Checkpoint.prototype[Symbol.dispose] = Checkpoint.prototype.free;
-
 export class Composition {
     static __wrap(ptr) {
         const obj = Object.create(Composition.prototype);
@@ -45,17 +18,24 @@ export class Composition {
         wasm.__wbg_composition_free(ptr, 0);
     }
     /**
-     * @param {number} max_bytes
+     * @returns {number}
      */
-    bound_cache(max_bytes) {
-        wasm.composition_bound_cache(this.__wbg_ptr, max_bytes);
+    get cache_bytes() {
+        const ret = wasm.composition_cache_bytes(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * The memory tier's, as `cache_max_bytes` is; `persistent_bytes` is the pack's.
      * @returns {number}
      */
-    get cache_bytes() {
-        const ret = wasm.composition_cache_bytes(this.__wbg_ptr);
+    get cache_entries() {
+        const ret = wasm.composition_cache_entries(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cache_evictions() {
+        const ret = wasm.composition_cache_evictions(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -66,14 +46,23 @@ export class Composition {
         return ret;
     }
     /**
-     * Empties the memory tier only: a persistent pack outlives it by design.
+     * @returns {string}
      */
+    get cache_policy() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.composition_cache_policy(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     clear_cache() {
         wasm.composition_clear_cache(this.__wbg_ptr);
     }
-    clear_volatile() {
-        wasm.composition_clear_volatile(this.__wbg_ptr);
-    }
     /**
      * @param {string} path
      * @param {string} text
@@ -85,13 +74,6 @@ export class Composition {
         const len1 = WASM_VECTOR_LEN;
         wasm.composition_insert(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     }
-    /**
-     * @returns {boolean}
-     */
-    get persistent() {
-        const ret = wasm.composition_is_persistent(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @param {string | null} [name]
      */
@@ -104,101 +86,116 @@ export class Composition {
         return this;
     }
     /**
-     * `name` labels the composition as `new` does; renders persist under `cache` in a dedicated
-     * worker's private file system, and anywhere none opens, or `cache` is held, memory-only.
-     * @param {string | null | undefined} name
-     * @param {string} cache
-     * @param {number | null} [max_bytes]
+     * Over the store in `dir`, an origin-private file system directory, or memory alone
+     * where there is none.
+     * @param {string | null} [name]
+     * @param {FileSystemDirectoryHandle | null} [dir]
      * @returns {Promise<Composition>}
      */
-    static persistent(name, cache, max_bytes) {
+    static open(name, dir) {
         var ptr0 = isLikeNone(name) ? 0 : passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(cache, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.composition_persistent(ptr0, len0, ptr1, len1, !isLikeNone(max_bytes), isLikeNone(max_bytes) ? 0 : max_bytes);
+        const ret = wasm.composition_open(ptr0, len0, isLikeNone(dir) ? 0 : addToExternrefTable0(dir));
         return ret;
     }
     /**
-     * Zero on a memory-only composition, as `persistent_max_bytes` is.
-     * @returns {number}
+     * The only write to the directory `open` was handed: every value computed since the last.
+     * @returns {Promise<number>}
      */
-    get persistent_bytes() {
-        const ret = wasm.composition_persistent_bytes(this.__wbg_ptr);
+    persist() {
+        const ret = wasm.composition_persist(this.__wbg_ptr);
         return ret;
     }
     /**
-     * @returns {number}
+     * `"oldest"` evicts what the latest render neither stored nor read, `"forks"` every value
+     * fewer than two nodes read.
+     * @param {string} policy
      */
-    get persistent_max_bytes() {
-        const ret = wasm.composition_persistent_max_bytes(this.__wbg_ptr);
-        return ret;
+    prune(policy) {
+        const ptr0 = passStringToWasm0(policy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composition_prune(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * Unset, `target` is `master`; `until` is the horizon in seconds, or `"silent"` to end
-     * where every later sample is provably under `2^-bits` (default the profile's own), by
-     * `max_secs` at the latest. `rate` is the observation rate. What reads a `volatile`
-     * parameter is kept in a slot, never in either store.
-     * @param {string | null | undefined} target
-     * @param {number | null | undefined} rate
-     * @param {any} until
-     * @param {string[] | null} [volatile]
-     * @param {number | null} [bits]
-     * @param {number | null} [max_secs]
-     * @returns {Rendering}
+     * @returns {string}
      */
-    render(target, rate, until, volatile, bits, max_secs) {
-        var ptr0 = isLikeNone(target) ? 0 : passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(volatile) ? 0 : passArrayJsValueToWasm0(volatile, wasm.__wbindgen_malloc);
-        var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.composition_render(this.__wbg_ptr, ptr0, len0, isLikeNone(rate) ? Number.MAX_SAFE_INTEGER : (rate) >>> 0, until, ptr1, len1, isLikeNone(bits) ? Number.MAX_SAFE_INTEGER : (bits) >>> 0, !isLikeNone(max_secs), isLikeNone(max_secs) ? 0 : max_secs);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    get prune_policy() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.composition_prune_policy(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
-        return Rendering.__wrap(ret[0]);
+    }
+    /**
+     * `target` as `sva-cli render` takes it, `@piano([0, 2b], f0=C4)`; `representations`
+     * what `representations()` answers, `samples` where unset, each a call as
+     * `--representation` writes it. `options` sets `rate`, `bits`, `flop_budget`, `until`,
+     * `volatile` and `cache`.
+     * @param {string} target
+     * @param {string[] | null | undefined} representations
+     * @param {any} options
+     * @returns {Promise<Rendering>}
+     */
+    render(target, representations, options) {
+        const ptr0 = passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(representations) ? 0 : passArrayJsValueToWasm0(representations, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.composition_render(this.__wbg_ptr, ptr0, len0, ptr1, len1, options);
+        return ret;
     }
     /**
      * @param {number} max_bytes
      */
-    set volatile_max_bytes(max_bytes) {
-        wasm.composition_set_volatile_max_bytes(this.__wbg_ptr, max_bytes);
+    set cache_max_bytes(max_bytes) {
+        wasm.composition_set_cache_max_bytes(this.__wbg_ptr, max_bytes);
     }
     /**
-     * A stream of `target` (`master` unset) at `rate`, `block` samples a block, each key of
-     * `bindings` a named argument on the target. `until: "silent"` ends it at the first block
-     * whose end proves every later sample under `2^-bits`, throwing past `max_secs`.
-     * @param {string | null | undefined} target
-     * @param {number | null | undefined} rate
-     * @param {number} block
-     * @param {any} bindings
-     * @param {any} until
-     * @param {number | null} [bits]
-     * @param {number | null} [max_secs]
-     * @returns {Stream}
+     * @param {string} policy
      */
-    stream(target, rate, block, bindings, until, bits, max_secs) {
-        var ptr0 = isLikeNone(target) ? 0 : passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.composition_stream(this.__wbg_ptr, ptr0, len0, isLikeNone(rate) ? Number.MAX_SAFE_INTEGER : (rate) >>> 0, block, bindings, until, isLikeNone(bits) ? Number.MAX_SAFE_INTEGER : (bits) >>> 0, !isLikeNone(max_secs), isLikeNone(max_secs) ? 0 : max_secs);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    set_cache_policy(policy) {
+        const ptr0 = passStringToWasm0(policy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composition_set_cache_policy(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
         }
-        return Stream.__wrap(ret[0]);
     }
     /**
-     * @returns {number}
+     * @param {string} policy
      */
-    get volatile_bytes() {
-        const ret = wasm.composition_volatile_bytes(this.__wbg_ptr);
-        return ret;
+    set_prune_policy(policy) {
+        const ptr0 = passStringToWasm0(policy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composition_set_prune_policy(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * @returns {number}
+     * `target` block by block, through this store. `options`: `rate`, `bits`, `until`, `cache`,
+     * `live`.
+     * @param {string} target
+     * @param {number} block
+     * @param {any} options
+     * @returns {Stream}
      */
-    get volatile_max_bytes() {
-        const ret = wasm.composition_volatile_max_bytes(this.__wbg_ptr);
-        return ret;
+    stream(target, block, options) {
+        const ptr0 = passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composition_stream(this.__wbg_ptr, ptr0, len0, block, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Stream.__wrap(ret[0]);
     }
 }
 if (Symbol.dispose) Composition.prototype[Symbol.dispose] = Composition.prototype.free;
@@ -235,16 +232,12 @@ export class Rendering {
         return ret;
     }
     /**
-     * The object `sva-cli render --as <name>` puts under `data`, arrays capped as it caps.
-     * @param {string} representation
-     * @param {number | null} [from_secs]
-     * @param {number | null} [to_secs]
+     * The object `sva-cli render` puts under `data`, one reading per representation asked,
+     * arrays capped as it caps.
      * @returns {any}
      */
-    query(representation, from_secs, to_secs) {
-        const ptr0 = passStringToWasm0(representation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.rendering_query(this.__wbg_ptr, ptr0, len0, !isLikeNone(from_secs), isLikeNone(from_secs) ? 0 : from_secs, !isLikeNone(to_secs), isLikeNone(to_secs) ? 0 : to_secs);
+    representations() {
+        const ret = wasm.rendering_representations(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -259,12 +252,10 @@ export class Rendering {
     }
     /**
      * @param {number} channel
-     * @param {number | null} [from_secs]
-     * @param {number | null} [to_secs]
      * @returns {Float32Array}
      */
-    samples(channel, from_secs, to_secs) {
-        const ret = wasm.rendering_samples(this.__wbg_ptr, channel, !isLikeNone(from_secs), isLikeNone(from_secs) ? 0 : from_secs, !isLikeNone(to_secs), isLikeNone(to_secs) ? 0 : to_secs);
+    samples(channel) {
+        const ret = wasm.rendering_samples(this.__wbg_ptr, channel);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -273,7 +264,14 @@ export class Rendering {
         return v1;
     }
     /**
-     * The object `sva-cli render` puts under `data.cache.stats`.
+     * @returns {number}
+     */
+    get start_secs() {
+        const ret = wasm.rendering_start_secs(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Every lookup this render made of the composition's store, and what each came to.
      * @returns {any}
      */
     stats() {
@@ -312,7 +310,9 @@ export class Rendering {
 if (Symbol.dispose) Rendering.prototype[Symbol.dispose] = Rendering.prototype.free;
 
 /**
- * A target block by block, for a player that cannot know how long a note is held.
+ * A target block by block, reading `@notes` as the sum of its terms, as `@hall(t, x=@notes)`.
+ * A key-up replaces a term with one whose release is a number. A term leaves with its handle
+ * once its node ends, bar the last.
  */
 export class Stream {
     static __wrap(ptr) {
@@ -331,6 +331,20 @@ export class Stream {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_stream_free(ptr, 0);
     }
+    /**
+     * `term` summed into `@notes`.
+     * @param {string} term
+     * @returns {number}
+     */
+    add(term) {
+        const ptr0 = passStringToWasm0(term, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.stream_add(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * @returns {number}
      */
@@ -346,11 +360,16 @@ export class Stream {
         return ret >>> 0;
     }
     /**
-     * @returns {Checkpoint}
+     * `expr` in place of the target.
+     * @param {string} expr
      */
-    checkpoint() {
-        const ret = wasm.stream_checkpoint(this.__wbg_ptr);
-        return Checkpoint.__wrap(ret);
+    edit(expr) {
+        const ptr0 = passStringToWasm0(expr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.stream_edit(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
      * @returns {number | undefined}
@@ -359,6 +378,13 @@ export class Stream {
         const ret = wasm.stream_end(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : ret[1];
     }
+    /**
+     * @returns {number}
+     */
+    get held_bytes() {
+        const ret = wasm.stream_held_bytes(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Writes the next block into `out`, component `c` from `c * block`, and returns the
      * samples each component took: `block`, fewer where silence ends inside it, `0` after.
@@ -382,21 +408,30 @@ export class Stream {
         return ret;
     }
     /**
-     * `until` as `stream` takes it, `max_secs` counted from the checkpoint.
-     * @param {Checkpoint} checkpoint
-     * @param {any} bindings
-     * @param {any} until
-     * @param {number | null} [bits]
-     * @param {number | null} [max_secs]
-     * @returns {Stream}
+     * @param {number} handle
+     * @returns {boolean}
      */
-    resume(checkpoint, bindings, until, bits, max_secs) {
-        _assertClass(checkpoint, Checkpoint);
-        const ret = wasm.stream_resume(this.__wbg_ptr, checkpoint.__wbg_ptr, bindings, until, isLikeNone(bits) ? Number.MAX_SAFE_INTEGER : (bits) >>> 0, !isLikeNone(max_secs), isLikeNone(max_secs) ? 0 : max_secs);
+    remove(handle) {
+        const ret = wasm.stream_remove(this.__wbg_ptr, handle);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return Stream.__wrap(ret[0]);
+        return ret[0] !== 0;
+    }
+    /**
+     * False where the stream no longer holds `handle`.
+     * @param {number} handle
+     * @param {string} term
+     * @returns {boolean}
+     */
+    replace(handle, term) {
+        const ptr0 = passStringToWasm0(term, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.stream_replace(this.__wbg_ptr, handle, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
     }
     /**
      * @returns {number}
@@ -406,7 +441,17 @@ export class Stream {
         return ret >>> 0;
     }
     /**
-     * `{ samples, proofs, priced_flops, waves }` since it opened or resumed.
+     * @returns {any}
+     */
+    stats() {
+        const ret = wasm.stream_stats(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * `{ samples, priced_flops, waves }` since it opened.
      * @returns {any}
      */
     work() {
@@ -447,9 +492,21 @@ export function outline(text) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_boolean_get_7a12af2b3f899c5a: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
         __wbg___wbindgen_copy_to_typed_array_cccd104be8cf0b8d: function(arg0, arg1, arg2) {
             new Uint8Array(arg2.buffer, arg2.byteOffset, arg2.byteLength).set(getArrayU8FromWasm0(arg0, arg1));
         },
+        __wbg___wbindgen_debug_string_0e68cf47c9cbd9b0: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_is_falsy_4502df4d571fca70: function(arg0) {
             const ret = !arg0;
             return ret;
@@ -486,48 +543,50 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_997e73d32238e655: function(arg0) {
             arg0._wbg_cb_unref();
         },
+        __wbg_arrayBuffer_303605bfdb02dbaa: function(arg0) {
+            const ret = arg0.arrayBuffer();
+            return ret;
+        },
+        __wbg_call_269c5566fbede3eb: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
         __wbg_call_6bcf8d3e20937e46: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_close_1d55410e47fc11c8: function(arg0) {
-            arg0.close();
+        __wbg_close_c91cbb2cddb6f7aa: function(arg0) {
+            const ret = arg0.close();
+            return ret;
         },
         __wbg_composition_new: function(arg0) {
             const ret = Composition.__wrap(arg0);
             return ret;
         },
-        __wbg_createSyncAccessHandle_f2f0452f71047cd7: function(arg0) {
-            const ret = arg0.createSyncAccessHandle();
+        __wbg_createWritable_dcac2d262cf50ae7: function(arg0) {
+            const ret = arg0.createWritable();
             return ret;
         },
         __wbg_entries_972a87586902cf87: function(arg0) {
             const ret = Object.entries(arg0);
             return ret;
         },
-        __wbg_flush_91458c8278aae724: function() { return handleError(function (arg0) {
-            arg0.flush();
-        }, arguments); },
         __wbg_from_a39669ce566077da: function(arg0) {
             const ret = Array.from(arg0);
             return ret;
         },
-        __wbg_getDirectoryHandle_df6fb6f1fc6240ed: function(arg0, arg1, arg2, arg3) {
+        __wbg_getDirectoryHandle_6ba4491be2862323: function(arg0, arg1, arg2, arg3) {
             const ret = arg0.getDirectoryHandle(getStringFromWasm0(arg1, arg2), arg3);
             return ret;
         },
-        __wbg_getDirectory_31689baa30c0e94c: function(arg0) {
-            const ret = arg0.getDirectory();
-            return ret;
-        },
-        __wbg_getFileHandle_fbeae17e3423535f: function(arg0, arg1, arg2, arg3) {
+        __wbg_getFileHandle_9709cc764716faf0: function(arg0, arg1, arg2, arg3) {
             const ret = arg0.getFileHandle(getStringFromWasm0(arg1, arg2), arg3);
             return ret;
         },
-        __wbg_getSize_479486b8ac438f8e: function() { return handleError(function (arg0) {
-            const ret = arg0.getSize();
+        __wbg_getFile_514e6ad2d0b16f74: function(arg0) {
+            const ret = arg0.getFile();
             return ret;
-        }, arguments); },
+        },
         __wbg_get_989d0a1309644f2b: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
@@ -540,26 +599,6 @@ function __wbg_get_imports() {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_instanceof_FileSystemDirectoryHandle_a5c1bdaafba684ca: function(arg0) {
-            let result;
-            try {
-                result = arg0 instanceof FileSystemDirectoryHandle;
-            } catch (_) {
-                result = false;
-            }
-            const ret = result;
-            return ret;
-        },
-        __wbg_instanceof_FileSystemFileHandle_aba527fd4c84a882: function(arg0) {
-            let result;
-            try {
-                result = arg0 instanceof FileSystemFileHandle;
-            } catch (_) {
-                result = false;
-            }
-            const ret = result;
-            return ret;
-        },
         __wbg_instanceof_Object_87732cb922ac2e2c: function(arg0) {
             let result;
             try {
@@ -570,29 +609,31 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_WorkerGlobalScope_0c1a6411473b843f: function(arg0) {
-            let result;
-            try {
-                result = arg0 instanceof WorkerGlobalScope;
-            } catch (_) {
-                result = false;
-            }
-            const ret = result;
+        __wbg_isArray_5674713bb7b79043: function(arg0) {
+            const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_keys_4d3b6ee519555a72: function(arg0) {
+        __wbg_keys_23712aa1a6f4aa5d: function(arg0) {
             const ret = arg0.keys();
             return ret;
         },
+        __wbg_length_31bdaf014f5fbde2: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_length_4e1adc0d42e23620: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_navigator_d25c0f071226f233: function(arg0) {
-            const ret = arg0.navigator;
+        __wbg_move_2019b378ef90cf6c: function(arg0, arg1, arg2, arg3) {
+            const ret = arg0.move(arg1, getStringFromWasm0(arg2, arg3));
+            return ret;
+        },
+        __wbg_new_1da3429bc3c4541c: function(arg0) {
+            const ret = new Uint8Array(arg0);
             return ret;
         },
-        __wbg_new_27e74e58f1461a9c: function(arg0, arg1) {
+        __wbg_new_30145d082ba9492c: function(arg0, arg1) {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -618,6 +659,10 @@ function __wbg_get_imports() {
             const ret = new Object();
             return ret;
         },
+        __wbg_new_from_slice_4ee02165f9de919e: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_new_typed_6f8b0d724fe26c07: function(arg0, arg1) {
             try {
                 var state0 = {a: arg0, b: arg1};
@@ -636,14 +681,21 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_next_a128c458fd40a0a5: function() { return handleError(function (arg0) {
+        __wbg_next_30e6632b4218cb09: function(arg0) {
             const ret = arg0.next();
             return ret;
-        }, arguments); },
-        __wbg_parse_74b31fef7234e333: function() { return handleError(function (arg0, arg1) {
+        },
+        __wbg_parse_a1c86daae8e336bd: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
+        __wbg_prototypesetcall_ae9f5e7459250748: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_query_259d928d723fff72: function(arg0) {
+            const ret = arg0.query();
+            return ret;
+        },
         __wbg_queueMicrotask_85c90f6987555d65: function(arg0) {
             const ret = arg0.queueMicrotask;
             return ret;
@@ -651,37 +703,44 @@ function __wbg_get_imports() {
         __wbg_queueMicrotask_f6a1fa10b81d1fc0: function(arg0) {
             queueMicrotask(arg0);
         },
-        __wbg_read_259baab664b5f318: function() { return handleError(function (arg0, arg1, arg2, arg3) {
-            const ret = arg0.read(getArrayU8FromWasm0(arg1, arg2), arg3);
+        __wbg_random_7bce4e9e78e2e0d0: function() {
+            const ret = Math.random();
             return ret;
-        }, arguments); },
-        __wbg_removeEntry_c72a6de718a4679d: function(arg0, arg1, arg2) {
+        },
+        __wbg_removeEntry_526b61f67204248f: function(arg0, arg1, arg2) {
             const ret = arg0.removeEntry(getStringFromWasm0(arg1, arg2));
             return ret;
         },
-        __wbg_resolve_35ec7e0c6af4c82c: function(arg0) {
-            const ret = Promise.resolve(arg0);
+        __wbg_removeEntry_73524952fdb64743: function(arg0, arg1, arg2, arg3) {
+            const ret = arg0.removeEntry(getStringFromWasm0(arg1, arg2), arg3);
             return ret;
         },
-        __wbg_setTimeout_68c2cba08a966520: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = arg0.setTimeout(arg1, arg2);
+        __wbg_rendering_new: function(arg0) {
+            const ret = Rendering.__wrap(arg0);
             return ret;
-        }, arguments); },
-        __wbg_set_at_40af7269bbcce291: function(arg0, arg1) {
-            arg0.at = arg1;
         },
-        __wbg_set_create_389985224a53c83d: function(arg0, arg1) {
-            arg0.create = arg1 !== 0;
+        __wbg_request_eda21e880c785d71: function(arg0, arg1, arg2, arg3) {
+            const ret = arg0.request(getStringFromWasm0(arg1, arg2), arg3);
+            return ret;
         },
-        __wbg_set_create_8c556c6febf6436c: function(arg0, arg1) {
-            arg0.create = arg1 !== 0;
+        __wbg_resolve_35ec7e0c6af4c82c: function(arg0) {
+            const ret = Promise.resolve(arg0);
+            return ret;
         },
-        __wbg_set_name_fb6171210e935eeb: function(arg0, arg1, arg2) {
+        __wbg_set_a377297433dfea63: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_set_name_67f69e636c52b8b8: function(arg0, arg1, arg2) {
             arg0.name = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_refusal_a80f0d1c079e712a: function(arg0, arg1) {
+        __wbg_set_refusal_67dcb641bf92d6bd: function(arg0, arg1) {
             arg0.refusal = arg1;
         },
+        __wbg_size_a827722774ab6a64: function(arg0) {
+            const ret = arg0.size;
+            return ret;
+        },
         __wbg_static_accessor_GLOBAL_8eb4cd83130a11a0: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -706,19 +765,26 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_truncate_2ed7d68b99bcc8f6: function() { return handleError(function (arg0, arg1) {
-            arg0.truncate(arg1);
-        }, arguments); },
-        __wbg_write_3e78f5b3224d701e: function() { return handleError(function (arg0, arg1, arg2, arg3) {
-            const ret = arg0.write(getArrayU8FromWasm0(arg1, arg2), arg3);
+        __wbg_write_b2d191debe961263: function(arg0, arg1) {
+            const ret = arg0.write(arg1);
             return ret;
-        }, arguments); },
+        },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 98, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 491, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hd55bb211d6a08150);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 38, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h2cf8ee606c8af385);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000003: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_generic_0000000000000004: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
@@ -739,6 +805,11 @@ function __wbg_get_imports() {
     };
 }
 
+function wasm_bindgen__convert__closures_____invoke__h2cf8ee606c8af385(arg0, arg1) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h2cf8ee606c8af385(arg0, arg1);
+    return ret;
+}
+
 function wasm_bindgen__convert__closures_____invoke__hd55bb211d6a08150(arg0, arg1, arg2) {
     const ret = wasm.wasm_bindgen__convert__closures_____invoke__hd55bb211d6a08150(arg0, arg1, arg2);
     if (ret[1]) {
@@ -750,9 +821,6 @@ function wasm_bindgen__convert__closures_____invoke__h76bd71bceeca2b95(arg0, arg
     wasm.wasm_bindgen__convert__closures_____invoke__h76bd71bceeca2b95(arg0, arg1, arg2, arg3);
 }
 
-const CheckpointFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_checkpoint_free(ptr, 1));
 const CompositionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_composition_free(ptr, 1));
@@ -769,16 +837,75 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function getArrayF32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);