@onda-lang/webaudio 0.7.4 → 0.8.0

package/README.md

@@ -1,13 +1,19 @@
 # Onda Web Audio adapter
 
+See [api.md](api.md) for the complete public Web API shared with the released package.
+
 This optional package hosts a complete wasm32 Onda processor artifact in an `AudioWorklet`. It is a
 reference adapter for the generic Onda processor ABI; Web Audio is not required by the compiler or
 by native and relocatable-WebAssembly object consumers.
 
 ```js
-import { createOndaAudioProcessor } from "@onda-lang/webaudio";
+import {
+  createOndaAudioProcessorInitialized,
+  ONDA_INIT_FULL,
+  ONDA_INIT_PRESERVE_PINNED,
+} from "@onda-lang/webaudio";
 
-const processor = await createOndaAudioProcessor(audioContext, artifact, {
+const processor = await createOndaAudioProcessorInitialized(audioContext, artifact, {
   params: { gain: 0.5 },
   buffers: {},
 });
@@ -15,12 +21,27 @@ processor.node.connect(audioContext.destination);
 await processor.setParam("gain", 0.75);
 await processor.setParamNormalized("cutoff", 0.5);
 const snapshot = await processor.snapshot();
+await processor.init(ONDA_INIT_PRESERVE_PINNED);
+await processor.init(ONDA_INIT_FULL);
 ```
 
 The adapter registers `onda-wasm-processor`, derives Web Audio channel options from artifact
 metadata, marshals declared scalar widths, schedules arbitrary render quanta across Onda compile
 blocks, and provides request/response helpers for parameters, events, buffers, control outputs,
-reset, and portable snapshots.
+initialization, and portable snapshots.
+
+`createOndaAudioProcessor()` is allocation-only. This lets a host configure parameters before the
+first initializer run:
+
+```js
+const processor = await createOndaAudioProcessor(audioContext, artifact);
+await processor.setParam("gain", 0.75);
+await processor.init(ONDA_INIT_FULL);
+```
+
+Until full initialization succeeds, the worklet emits silence and rejects stateful control
+operations. Successful initialization switches it to the initialized process callback, so the
+steady-state audio callback does not retain a lifecycle branch.
 
 ## Parameters
 
@@ -68,6 +89,83 @@ Audio processor must expose at least one audio input or output, because an empty
 does not carry a render-quantum frame count. Control-only artifacts remain usable through the generic
 processor ABI in a non-Web-Audio host.
 
+Call `processor.close()` when the adapter is no longer used. Closing is idempotent and terminal: it
+rejects pending requests, removes listeners, and makes subsequent operations fail immediately. The
+wrapped `AudioWorkletNode` and `AudioContext` remain caller-owned.
+
+## Prints
+
+Authored `print(...)` occurrences leave generated execution as bounded typed records. The worklet
+copies those records into a preallocated `SharedArrayBuffer` ring without formatting or allocating
+during audio rendering; the main-side adapter drains the ring and turns them into canonical,
+newline-terminated text:
+
+```js
+const processor = await createOndaAudioProcessorInitialized(context, artifact, {
+  printCapacityBytes: 128 * 1024,
+  // Register during construction to include output from authored init code.
+  onPrint: ({ text, entries, overflowCount, transportDropCount }) => {
+    logView.append(text);
+    if (overflowCount) console.warn(`${overflowCount} generated print records were dropped`);
+    if (transportDropCount) console.warn(`${transportDropCount} print records missed UI transport`);
+  },
+});
+```
+
+`text` is ready to write or display and contains one newline-terminated line per occurrence.
+`entries` retains typed values and source/log-site metadata for source-aware consumers. Generated
+batch overflow and bounded worklet-to-main transport loss are reported separately; loss-only
+notifications are delivered even when no later authored print arrives. Capacity defaults to 64 KiB
+and can be set to zero to suppress host delivery without suppressing argument evaluation. Print
+collection is inactive while no listener is registered, avoiding record packing and transport work
+in the render callback. Listeners added later with `processor.onPrint(...)` receive subsequent
+executions; use the construction option above when initialized-code output must be observed.
+See the internal [print host integration](../../docs/printing.md) reference for scalar formatting,
+source metadata, and the equivalent Rust, C, and raw processor APIs.
+
+## Delegates
+
+Top-level delegates are delivered after generated execution through `onDelegates()`. The worklet
+uses reusable storage allocated during construction; listeners run while the main-side adapter
+drains the shared ring, not as callbacks inside generated DSP code.
+
+```js
+const processor = await createOndaAudioProcessorInitialized(context, artifact, {
+  delegateCapacityBytes: 128 * 1024,
+});
+
+const unsubscribe = processor.onDelegates(({
+  occurrences,
+  overflowCount,
+  transportDropCount,
+}) => {
+  for (const occurrence of occurrences) {
+    console.log(occurrence.name, occurrence.values);
+  }
+  if (overflowCount) console.warn(`${overflowCount} delegate records were dropped`);
+  if (transportDropCount) {
+    console.warn(`${transportDropCount} delegate records were dropped in transport`);
+  }
+});
+```
+
+Capacity defaults to 64 KiB and can be set to zero to disable host collection. It is a host policy,
+not a compiler-computable exact whole-call size: occurrence counts and slice payload lengths may be
+runtime-dependent. The worklet supplies delegate storage to generated code only while at least one
+listener is registered, and decoding happens on the main side. `overflowCount` reports insufficient
+configured capacity; `transportDropCount` separately reports records discarded by the bounded
+worklet-to-main queue. Internal Onda `when` handlers still run in either case. See the internal
+[delegate host integration](../../docs/delegates.md) reference for sizing and lifecycle details.
+
+When print and delegate listeners are both active, the adapter invokes them in authored order for
+each init, event, or process segment. It may split one stream's batch around an occurrence from the
+other stream; ordering intentionally does not span separate generated calls.
+
+Print and delegate delivery requires `SharedArrayBuffer`. Browser deployments must therefore be
+cross-origin isolated, normally with `Cross-Origin-Opener-Policy: same-origin` and
+`Cross-Origin-Embedder-Policy: require-corp` (or `credentialless`). Audio processing remains usable
+without those headers, but registering an output listener fails with a clear error.
+
 ## Real-time behavior
 
 `createOndaAudioProcessor` compiles the processor's `WebAssembly.Module` concurrently with worklet
@@ -78,16 +176,17 @@ compile once and reuse the module:
 ```js
 import {
   compileOndaProcessorModule,
-  createOndaAudioProcessor,
+  createOndaAudioProcessorInitialized,
 } from "@onda-lang/webaudio";
 
 const compiledModule = await compileOndaProcessorModule(artifact);
-const left = await createOndaAudioProcessor(context, artifact, { compiledModule });
-const right = await createOndaAudioProcessor(context, artifact, { compiledModule });
+const left = await createOndaAudioProcessorInitialized(context, artifact, { compiledModule });
+const right = await createOndaAudioProcessorInitialized(context, artifact, { compiledModule });
 ```
 
-After construction, the normal f32 render callback reuses cached Wasm-memory views and performs no
-host-side allocation or memory growth. Full-block f32 inputs and outputs use typed-array bulk copies;
+After construction, the normal f32 render callback reuses cached Wasm and shared-ring views and
+performs no host-side allocation or memory growth, including while transporting print and delegate
+records. Full-block f32 inputs and outputs use typed-array bulk copies;
 segmented callbacks and other ABI scalar widths use preallocated typed views with conversion loops
 (i64 input conversion necessarily creates JavaScript `BigInt` values). External buffers are copied
 into Wasm with typed-array bulk operations during construction. Missing or `null` bindings install
@@ -98,7 +197,7 @@ nonempty, correctly shaped data.
 Fixed buffer arrays may be supplied under their logical group name. Each slot is independent:
 
 ```js
-const processor = await createOndaAudioProcessor(context, artifact, {
+const processor = await createOndaAudioProcessorInitialized(context, artifact, {
   buffers: {
     impulse: { data: impulseSamples, channels: 1, sampleRate: 48_000 },
     bank: [
@@ -112,19 +211,30 @@ const processor = await createOndaAudioProcessor(context, artifact, {
 
 Hosts may instead pass a flat array in physical descriptor order or key individual physical names
 such as `"bank[1]"`. Logical group metadata determines the contiguous slot range; no sample data is
-copied when Onda selects a slot while processing.
+copied when Onda selects a slot while processing. Initial descriptors are installed before the
+initialized constructor runs full initialization, so authored top-level and proc init code can
+preprocess the supplied samples once before rendering begins.
 
 Artifact descriptors and module exports are validated by the shared, compiler-free
 `@onda-lang/processor-abi` package before anything reaches the rendering thread.
-If generated init, event, or process code returns a nonzero execution status, the adapter reports
-an `onda-error`, latches the failed state, and emits silence without re-entering processing. A
-successful reset clears the latch after reinitializing state.
+If generated init or event code returns a nonzero execution status, the adapter reports the error
+to the caller. A failing process call reports an `onda-error` and emits silence. Any generated-code
+failure invalidates the live state, so later callbacks remain silent and stateful operations are
+rejected until full initialization or snapshot restoration succeeds.
+`init(ONDA_INIT_PRESERVE_PINNED)` reruns generated initialization
+while preserving pinned roots and task continuations; `init(ONDA_INIT_FULL)` initializes the
+complete physical state and is required before processing an instance returned by
+`createOndaAudioProcessor`. The initialized convenience constructor performs full initialization
+during worklet construction. Neither mode allocates on the successful path, and a
+failure returns the processor to its silent pending state until full initialization or snapshot
+restore succeeds. Suspend or disconnect playback before initialization that performs substantial
+work.
 
 Dynamic event storage is also allocated before rendering. Its default capacity is 64 KiB per
 processor with dynamic events and can be changed explicitly:
 
 ```js
-const processor = await createOndaAudioProcessor(context, artifact, {
+const processor = await createOndaAudioProcessorInitialized(context, artifact, {
   eventPayloadCapacityBytes: 256 * 1024,
 });
 ```

package/api.md

@@ -0,0 +1,407 @@
+<!-- Generated from docs/web-api.md; do not edit this packaged copy. -->
+
+# Web API reference
+
+Onda publishes four ECMAScript-module packages for browsers and Node.js:
+
+| Package | Purpose |
+| --- | --- |
+| `@onda-lang/wasm-compiler` | Compile Onda source, workspaces, and project images to complete WebAssembly processor artifacts. |
+| `@onda-lang/processor-abi` | Validate artifacts, inspect metadata, prepare parameter controls, and decode raw delegate and print output. |
+| `@onda-lang/binaryen-web` | Lower trusted, version-matched Onda MIR directly to a processor artifact. |
+| `@onda-lang/webaudio` | Host a complete processor artifact in an `AudioWorklet`. |
+
+All packages are ESM-only. `@onda-lang/wasm-compiler` and `@onda-lang/binaryen-web` support modern
+browsers and Node.js 20 or newer. Web Audio construction requires a browser environment with
+`AudioWorklet`; the metadata and parameter helpers re-exported by `@onda-lang/webaudio` are ordinary
+synchronous JavaScript.
+
+Each published package contains this reference as `api.md`. TypeScript declarations are included
+at every exported module path.
+
+## Compile source and start audio
+
+```js
+import { createCompiler } from "@onda-lang/wasm-compiler";
+import {
+  createOndaAudioProcessorInitialized,
+} from "@onda-lang/webaudio";
+
+const compiler = await createCompiler();
+const { artifact } = await compiler.compileSource(source, {
+  sampleRate: audioContext.sampleRate,
+  blockSize: 128,
+});
+
+const print = ({ text }) => console.debug(text);
+const processor = await createOndaAudioProcessorInitialized(
+  audioContext,
+  artifact,
+  {
+    params: { gain: 0.5 },
+    // A construction-time listener also receives prints emitted by init.
+    onPrint: print,
+  },
+);
+processor.node.connect(audioContext.destination);
+
+const stopDelegates = processor.onDelegates(({ occurrences }) => {
+  for (const occurrence of occurrences) {
+    console.log(occurrence.name, occurrence.values);
+  }
+});
+```
+
+Compilation is an offline operation and may allocate. Constructing the adapter compiles or accepts
+a reusable `WebAssembly.Module` before the audio node starts. Normal rendering uses preallocated
+storage. Delegate and print callbacks run on the main side after bounded worklet transport; they do
+not call JavaScript from generated DSP execution.
+
+## `@onda-lang/wasm-compiler`
+
+### `createCompiler(options?)`
+
+Creates an `OndaCompilerInstance`. With no options, compilation runs directly on the calling
+JavaScript thread. Pass `{ worker: true }` to run the frontend and backend in a module worker;
+`workerUrl`, `frontendWasm`, and a custom `Worker` constructor are optional integration hooks.
+
+The returned instance provides:
+
+- `compileSource(source, options?)` and `inspectSourceConstants(source, options?)`.
+- `compileWorkspace(workspace, options?)` and `inspectWorkspaceConstants(workspace, options?)`.
+- `compileProjectImage(bytes, options?)` and `inspectProjectImageConstants(bytes, options?)`.
+- `createProjectImage(sourceGraph, buffers?)`, `inspectProjectImage(bytes)`,
+  `loadProjectFiles(files, projectFilePath?)`, and `materializeProjectImage(bytes, names?)`.
+- `encodeBufferAsset(binding)`, `decodeBufferAsset(bytes)`, and `decodeBufferFile(bytes, path?)`.
+- `projectCapabilities()` for supported image, buffer, and standard-library versions.
+- `sendLspMessage(message)` and `setLspAnalysisOptions(options?)` for the embedded language server.
+- `dispose()`, an idempotent terminal release of compiler and worker resources.
+
+Compile options accept `sampleRate`, `blockSize`, typed compile-constant overrides, and `codegen`.
+Code generation can select optimization level `0..4`, shrink level `0..2`, strict or fast math,
+SIMD, loop-containing inlining, and optional WAT emission. A successful compilation returns an
+`OndaCompilationResult` containing the artifact, resolved source paths, and the exact source graph
+when one is available.
+
+Configuration and lifecycle failures throw `OndaCompilerError`. Authored-source, project, MIR, and
+code-generation failures throw `OndaCompileError`, whose `diagnostics`, `sourceFiles`, and
+`unresolvedSourceFiles` fields support editors and file watchers. `OndaBinaryenError` identifies a
+failure in the MIR-to-Wasm backend.
+
+`MIR_SCHEMA_VERSION` is the schema accepted by the bundled backend. `ONDA_VERSION` is the compiler
+version. `createDefaultImports()` returns the imports required by current generated modules; it is
+currently an empty object because artifacts are self-contained.
+
+The `@onda-lang/wasm-compiler/artifact` subpath re-exports the complete
+`@onda-lang/processor-abi` surface without loading the compiler. The
+`@onda-lang/wasm-compiler/worker` subpath is a side-effect-only module-worker entry and has no
+named exports.
+
+## `@onda-lang/processor-abi`
+
+An `OndaProcessorArtifact` contains WebAssembly bytes, an `OndaProcessorMetadata` descriptor, and
+optional WAT. Treat the bytes and descriptor as one integrity-associated pair.
+
+### Validation and files
+
+- `validateProcessorMetadata(metadata, expectedKind?)` validates and returns the current descriptor.
+- `validateProcessorArtifact(artifact, options?)` normalizes bytes and optionally inspects the module.
+- `validateProcessorModule(module, metadata)` verifies a precompiled module against its descriptor.
+- `parseProcessorMetadata(input, expectedKind?)` parses JSON or validates an object.
+- `serializeProcessorMetadata(metadata, space?)` validates before producing newline-terminated JSON.
+- `createProcessorArtifactFiles(artifact, options?)` creates associated `.wasm` and `.onda.json`
+  records, including integrity metadata.
+- `loadProcessorArtifactFiles(wasm, metadata)` validates a loaded pair and its integrity association.
+
+Failures throw `OndaArtifactError`. Hosts must reject unsupported artifact-format, ABI, and snapshot
+versions rather than guessing layout compatibility.
+
+### Parameter controls
+
+`createParamControl(metadata)` validates one scalar parameter descriptor and returns a reusable
+`OndaPreparedParamControl`. `createParamDomain(domain)` does the same from already-decoded values.
+Prepared controls expose `constrainPlain`, `normalizedToPlain`, and `plainToNormalized` methods.
+
+The one-shot `constrainParamPlain`, `paramNormalizedToPlain`, and `paramPlainToNormalized`
+functions provide the same behavior. Preparing once is preferable for frequently updated UI:
+validation and decimal descriptor decoding stay off the interaction path. Mappings preserve exact
+endpoints, apply linear, logarithmic, or curved scale, and clamp and snap to the declared grid.
+
+### Delegates and print output
+
+Complete wasm32 processor exports receive an optional execution-output descriptor containing
+independently nullable delegate and print batches. Allocate all descriptors and storage before
+real-time execution.
+
+`writeDelegateBatch` and `writePrintBatch` initialize reusable batch descriptors.
+`writeExecutionOutput` connects their addresses. Call `resetExecutionOutput` immediately before
+every generated init, process, or event entry. After a successful generated call,
+`readDelegateBatch` or `readPrintBatch` validates the result counters.
+`decodeDelegateRecords` converts delegate payloads using `metadata.delegates`.
+`decodePrintRecords` preserves primitive types and source sites; `formatPrintRecords` and
+`formatPrintBatch` add canonical text formatting. Both decoded record types expose a `sequence` from
+the host-reset call-local counter; merge that call's two arrays by this field when presenting one
+chronological output stream.
+
+Batch capacity is host policy. `overflowCount` reports whole records that did not fit; it is not a
+byte count. Consume the returned storage before reusing it for another init, process, or event call.
+See the [language guide](https://onda-lang.org/docs/language/#delegates) for authored semantics and
+the [processor API](https://onda-lang.org/docs/processor-api/#call-scoped-execution-output) for
+physical record layout.
+
+The metadata interfaces expose target facts, storage sizes, ports, parameters, states, events,
+delegates, print sites, buffers, and integration profiles. Scalar `i64` values decoded from records
+use `bigint`; booleans use `boolean`; fixed arrays and slices become JavaScript arrays.
+
+## `@onda-lang/binaryen-web`
+
+### `compileTrustedMir(mir, options?)`
+
+Lowers MIR emitted by the matching Onda semantic frontend. Input may be compact MessagePack, JSON,
+or an already-decoded object. The function is synchronous and returns an
+`OndaProcessorArtifact`. It is intentionally not a validator for untrusted or hand-authored MIR;
+the producer owns semantic, type, bounds, and resource proofs.
+
+`OndaBinaryenOptions` controls the same backend policies exposed through compiler `codegen`.
+`SUPPORTED_MIR_SCHEMA_VERSION` identifies the required producer schema. `createDefaultImports()`
+returns an empty object for current self-contained artifacts. Backend failures throw
+`OndaBinaryenError`.
+
+The package root re-exports the common artifact validation and file helpers. The
+`@onda-lang/binaryen-web/artifact` subpath re-exports the complete
+`@onda-lang/processor-abi` module without loading Binaryen.
+
+## `@onda-lang/webaudio`
+
+### Construction
+
+- `registerOndaAudioWorklet(context, workletUrl?)` registers the processor once per context.
+- `compileOndaProcessorModule(artifact)` validates and compiles a reusable module off the render thread.
+- `ondaAudioWorkletNodeOptions(artifact, options?)` builds low-level node options.
+- `createOndaAudioProcessor(context, artifact, options?)` allocates an uninitialized adapter.
+- `createOndaAudioProcessorInitialized(context, artifact, options?)` allocates and fully initializes it.
+- `flattenedAudioChannelCount(ports?)` totals declared physical channels with validation.
+
+`OndaAudioProcessorOptions` accepts initial plain parameter values, external buffers, event,
+delegate, and print capacities, an optional construction-time `onPrint` listener, a precompiled
+module, custom node options, and an `AudioWorkletNode` constructor. Pass `onPrint` when using the
+initialized constructor if initialization output must be observed; registering a listener after
+construction cannot replay output from an execution that has already completed. The artifact sample
+rate must equal the context sample rate and it must expose at least one audio input or output.
+Print and delegate delivery uses a bounded `SharedArrayBuffer` ring and requires cross-origin
+isolation in browsers; ordinary audio processing remains available when shared memory is absent.
+Low-level callers that manually pair the returned node options with `OndaAudioProcessor` must pass
+`processorOptions.executionOutputRing` as the adapter constructor's fourth argument.
+
+### `OndaAudioProcessor`
+
+The adapter exposes its `node` and validated `metadata`, plus these operations:
+
+- `setParam(nameOrIndex, plain)` and `setParamNormalized(nameOrIndex, normalized)`.
+- `trigger(nameOrIndex, values?)` for input events.
+- `onDelegates(listener)` and `onPrint(listener)`, each returning an unsubscribe function.
+- `init(mode)`, `snapshot()`, and `restoreSnapshot(bytes)`.
+- `readControlOutputs()` and `readBuffer(nameOrIndex)`.
+- `request(type, fields?, transfer?)` for adapter protocol extensions.
+- `close(reason?)`, an idempotent terminal release of adapter-side resources.
+
+Delegate and print batches report `overflowCount` for generated-storage loss and
+`transportDropCount` for bounded worklet-to-main queue loss. Loss-only notifications can arrive
+without occurrences. Collection is enabled only while the corresponding listener set is nonempty;
+setting the capacity to zero disables host delivery even with listeners while preserving language
+evaluation semantics.
+
+With both listener types active, the adapter invokes them in call-local sequence order and may split
+a same-stream batch around an intervening occurrence from the other stream. Ordering resets for
+each init, event, or process segment.
+
+`ONDA_INIT_FULL` clears and initializes all physical state. `ONDA_INIT_PRESERVE_PINNED` retains
+pinned state according to the processor ABI. The package also re-exports the prepared and one-shot
+parameter conversion helpers.
+
+`@onda-lang/webaudio/worklet` is the side-effect-only AudioWorklet registration module and has no
+named exports.
+
+## Complete exported surface
+
+The following indexes include runtime values and TypeScript-only types from each package root.
+They are checked against the shipped declarations so additions cannot silently escape this
+reference. Artifact subpaths are complete processor-ABI re-exports; worker and worklet subpaths are
+side-effect-only as described above.
+
+### `@onda-lang/processor-abi`
+
+<!-- BEGIN WEB API onda_processor_abi -->
+DELEGATE_BATCH_SIZE_BYTES
+DELEGATE_RECORD_HEADER_SIZE_BYTES
+EXECUTION_OUTPUT_SIZE_BYTES
+OndaArtifactError
+OndaArtifactKind
+OndaBufferArrayMetadata
+OndaBufferMetadata
+OndaDelegateBatch
+OndaDelegateMetadata
+OndaDelegateOccurrence
+OndaDelegateParamMetadata
+OndaEventMetadata
+OndaEventParamMetadata
+OndaIntegrationProfile
+OndaIoMetadata
+OndaLogSiteMetadata
+OndaParamControlMetadata
+OndaParamDomain
+OndaPreparedParamControl
+OndaPrintBatch
+OndaPrintEntry
+OndaProcessorArtifact
+OndaProcessorInitMode
+OndaProcessorMetadata
+OndaScalarType
+OndaStateMetadata
+OndaTargetInfo
+PRINT_BATCH_SIZE_BYTES
+PRINT_RECORD_HEADER_SIZE_BYTES
+PROCESSOR_ABI_VERSION
+PROCESSOR_ARTIFACT_FORMAT
+PROCESSOR_ARTIFACT_FORMAT_VERSION
+PROCESSOR_EXECUTION_OK
+PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE
+PROCESSOR_INIT_FULL
+PROCESSOR_INIT_PRESERVE_PINNED
+PROCESSOR_SNAPSHOT_FORMAT_VERSION
+constrainParamPlain
+createParamControl
+createParamDomain
+createProcessorArtifactFiles
+decodeDelegateRecords
+decodePrintRecords
+formatPrintBatch
+formatPrintRecords
+loadProcessorArtifactFiles
+paramNormalizedToPlain
+paramPlainToNormalized
+parseProcessorMetadata
+readDelegateBatch
+readPrintBatch
+resetExecutionOutput
+serializeProcessorMetadata
+validateProcessorArtifact
+validateProcessorMetadata
+validateProcessorModule
+writeDelegateBatch
+writeExecutionOutput
+writePrintBatch
+<!-- END WEB API onda_processor_abi -->
+
+### `@onda-lang/binaryen-web`
+
+<!-- BEGIN WEB API onda_binaryen_web -->
+OndaArtifactError
+OndaBinaryenError
+OndaBinaryenOptions
+OndaProcessorArtifact
+OndaProcessorMetadata
+PROCESSOR_ABI_VERSION
+PROCESSOR_ARTIFACT_FORMAT
+PROCESSOR_ARTIFACT_FORMAT_VERSION
+PROCESSOR_EXECUTION_OK
+PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE
+PROCESSOR_SNAPSHOT_FORMAT_VERSION
+SUPPORTED_MIR_SCHEMA_VERSION
+compileTrustedMir
+createDefaultImports
+createProcessorArtifactFiles
+loadProcessorArtifactFiles
+parseProcessorMetadata
+serializeProcessorMetadata
+validateProcessorArtifact
+validateProcessorMetadata
+validateProcessorModule
+<!-- END WEB API onda_binaryen_web -->
+
+### `@onda-lang/wasm-compiler`
+
+<!-- BEGIN WEB API onda_wasm_compiler -->
+DirectCompilerOptions
+MIR_SCHEMA_VERSION
+ONDA_VERSION
+OndaArtifactError
+OndaBinaryenError
+OndaBufferAssetBinding
+OndaBufferData
+OndaBufferElement
+OndaCodegenOptions
+OndaCompilationResult
+OndaCompileConstDescriptor
+OndaCompileConstElement
+OndaCompileConstInspectionOptions
+OndaCompileConstKind
+OndaCompileConstValue
+OndaCompileError
+OndaCompileOptions
+OndaCompilerDiagnostic
+OndaCompilerError
+OndaCompilerInstance
+OndaLspAnalysisOptions
+OndaLspMessage
+OndaMaterializedProjectFile
+OndaProcessorArtifact
+OndaProcessorMetadata
+OndaProjectBufferInfo
+OndaProjectCapabilities
+OndaProjectImageInfo
+OndaProjectMaterialization
+OndaResolvedCompileConstValue
+OndaSerializedProjectImage
+OndaSourceDocument
+OndaSourceGraph
+OndaSourceReferenceKind
+OndaSourceResolution
+OndaSourceWorkspace
+OndaWorkerConstructor
+OndaWorkerLike
+PROCESSOR_ABI_VERSION
+PROCESSOR_ARTIFACT_FORMAT
+PROCESSOR_ARTIFACT_FORMAT_VERSION
+PROCESSOR_EXECUTION_OK
+PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE
+PROCESSOR_SNAPSHOT_FORMAT_VERSION
+WorkerCompilerOptions
+createCompiler
+createDefaultImports
+createProcessorArtifactFiles
+loadProcessorArtifactFiles
+parseProcessorMetadata
+serializeProcessorMetadata
+validateProcessorArtifact
+validateProcessorMetadata
+validateProcessorModule
+<!-- END WEB API onda_wasm_compiler -->
+
+### `@onda-lang/webaudio`
+
+<!-- BEGIN WEB API onda_webaudio -->
+ONDA_AUDIO_WORKLET_PROCESSOR_NAME
+ONDA_INIT_FULL
+ONDA_INIT_PRESERVE_PINNED
+OndaAudioProcessor
+OndaAudioProcessorOptions
+OndaAudioPrintBatch
+OndaAudioPrintListener
+OndaInitMode
+OndaParamDomain
+OndaPreparedParamControl
+OndaProcessorArtifact
+OndaProcessorMetadata
+compileOndaProcessorModule
+constrainParamPlain
+createOndaAudioProcessor
+createOndaAudioProcessorInitialized
+createParamControl
+createParamDomain
+flattenedAudioChannelCount
+ondaAudioWorkletNodeOptions
+paramNormalizedToPlain
+paramPlainToNormalized
+registerOndaAudioWorklet
+<!-- END WEB API onda_webaudio -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onda-lang/webaudio",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "type": "module",
   "description": "Optional Web Audio adapter for Onda processor WebAssembly artifacts",
   "license": "MIT",
@@ -25,14 +25,16 @@
   },
   "files": [
     "src",
+    "api.md",
     "LICENSE",
     "README.md"
   ],
   "scripts": {
-    "test": "node --test"
+    "test": "node --test",
+    "prepack": "node ../../scripts/stage-web-api-docs.mjs"
   },
   "dependencies": {
-    "@onda-lang/processor-abi": "0.7.4"
+    "@onda-lang/processor-abi": "0.8.0"
   },
   "publishConfig": {
     "access": "public"