onda-engine 0.1.0 → 0.1.1

package/README.md

@@ -1,15 +1,38 @@
-# onda-engine
+<div align="center">
 
-**Author motion graphics in React. Render them natively on the GPU — no headless browser, no Chromium.**
+<img src="https://raw.githubusercontent.com/onda-engine/onda-engine/main/assets/brand/readme-hero.svg" alt="ONDA Engine — motion graphics at GPU speed, no browser" width="100%" />
+
+<br/>
+
+### Motion graphics at GPU speed. No browser. No Chromium.
+
+**Author video in React → compile it to a scene graph → render it natively on the GPU.**
+One `npm install` for the entire engine.
 
 [![npm](https://img.shields.io/npm/v/onda-engine?style=flat-square&labelColor=0e0e12&color=d96b82)](https://www.npmjs.com/package/onda-engine)
-[![License](https://img.shields.io/badge/license-FSL--1.1--Apache--2.0-d96b82?style=flat-square&labelColor=0e0e12)](#license)
+[![license: FSL-1.1-Apache-2.0](https://img.shields.io/badge/license-FSL--1.1--Apache--2.0-d96b82?style=flat-square&labelColor=0e0e12)](#license--read-this-first)
+[![types: included](https://img.shields.io/badge/types-included-d96b82?style=flat-square&labelColor=0e0e12)](#whats-in-the-box)
+[![renderer: Vello GPU](https://img.shields.io/badge/renderer-Vello_GPU-d96b82?style=flat-square&labelColor=0e0e12)](#why-onda)
+
+[Why ONDA](#why-onda) &nbsp;·&nbsp; [Install](#install) &nbsp;·&nbsp; [What's in the box](#whats-in-the-box) &nbsp;·&nbsp; [Onda Studio](#onda-studio) &nbsp;·&nbsp; [License](#license--read-this-first) &nbsp;·&nbsp; [onda.video](https://onda.video)
+
+</div>
+
+---
 
-ONDA turns a **React composition** into a renderer-agnostic **scene graph**, then rasterizes it with a native GPU renderer ([Vello](https://github.com/linebender/vello)) — or a deterministic CPU reference renderer, or a WASM path for live in-browser preview. It's the engine behind **[Onda Studio](https://studio.onda.video)**, but it stands on its own as a programmatic-video toolkit.
+**ONDA turns a React composition into a renderer-agnostic _scene graph_, then rasterizes it with a native GPU renderer ([Vello](https://github.com/linebender/vello))** — or a deterministic CPU reference renderer, or a WebAssembly path for live in-browser preview. No DOM. No headless browser. No screenshot round-trip. Just a scene graph, straight to the GPU.
 
-This is the **all-in-one** package: the React renderer, the motion-language components, the interactive player, the headless renderer, and the WASM core — one install, one version.
+`onda-engine` is the **all-in-one** package — the React renderer, the motion-language component library, the interactive player, the headless renderer, and the WASM cores — bundled into a single install, one version.
 
-> **Pre-1.0.** The Rust + WASM core powers a production studio, but the public API isn't frozen — expect breaking changes before 1.0.
+> **Pre-1.0.** The Rust + WASM core already powers a production studio, but the public API isn't frozen — expect breaking changes before `1.0`.
+
+## Why ONDA
+
+Programmatic video today (e.g. Remotion) renders by driving a **headless browser**: correct, but heavy — a Chromium process per render, slow cold starts, high memory, painful to scale. ONDA keeps the **React authoring model** you already know, but compiles it to a scene graph and renders it **natively**. There is no browser anywhere in the pipeline.
+
+> **It's faster because it does less.** Measured on an Apple M4 Pro (1080p, Remotion's best case): **~4.5× faster per thread** and **~9.3× higher machine throughput** than Remotion — and the gap *widens* with scene complexity, GPU acceleration, and cold-start / memory pressure.
+
+The scene graph is the universal language; the renderer is the platform. **One composition** drives them all — live browser preview (WebGPU / WASM), native GPU export, or a deterministic CPU reference render.
 
 ## Install
 
@@ -17,23 +40,19 @@ This is the **all-in-one** package: the React renderer, the motion-language comp
 npm install onda-engine react
 ```
 
-`react` (v19) is a peer dependency — you provide it. Everything else, including the ~11 MB of WASM, ships in the box; there's no runtime download and no extra registry to configure.
-
-> The engine is developed as granular [`@onda-engine/*`](https://github.com/onda-engine/onda-engine) workspace packages; `onda-engine` bundles them into a single public install (one package, one version) — this is the package you install.
+`react` (v19) is a peer dependency you provide. Everything else — including the ~11 MB of WASM cores — ships in the box. No runtime downloads, no extra registry to configure, no Rust toolchain on your machine.
 
-## What's inside
+## What's in the box
 
 | Import | What it is |
 | --- | --- |
 | `onda-engine` | The Onda **motion language** — choreography + component library (the main authoring surface) |
 | `onda-engine/react` | The React → scene-graph renderer (`renderToScene`, primitives, hooks) |
-| `onda-engine/player` | Interactive `<Player>` — real-time canvas/WebGPU preview |
-| `onda-engine/render` | **Node-only** headless render to video/still (no Chromium) |
+| `onda-engine/player` | Interactive `<Player>` — real-time canvas / WebGPU preview |
+| `onda-engine/render` | **Node-only** headless render to video / still (no Chromium) |
 | `onda-engine/cinema` | Render a timeline composition payload to an engine element |
 | `onda-engine/components/manifest` | Per-component prop manifest (semantic roles) |
-| `onda-engine/wasm` | The renderer compiled to WebAssembly (text metrics, CPU render) |
-| `onda-engine/wasm-audio` | Audio decode + FFT (audio-reactive visuals) |
-| `onda-engine/wasm-vello` | The Vello GPU renderer over WebGPU |
+| `onda-engine/wasm` · `/wasm-audio` · `/wasm-vello` | The renderer, audio FFT, and Vello GPU cores, compiled to WebAssembly |
 
 ## Usage
 
@@ -41,44 +60,46 @@ npm install onda-engine react
 import { TitleCard } from 'onda-engine'
 import { renderToScene } from 'onda-engine/react'
 
-const scene = renderToScene(<TitleCard title="Hello" />)
+const scene = renderToScene(<TitleCard title="Hello, motion" />)
 ```
 
-### WASM (browser)
-
-Under a bundler that supports the `new URL(..., import.meta.url)` asset convention (Vite, modern webpack), the WASM **loads itself** — each `.wasm` ships next to its glue and is fetched automatically. Nothing to wire up:
+**The WASM loads itself.** Under a bundler that supports the `new URL(..., import.meta.url)` asset convention (Vite, modern webpack), each `.wasm` ships next to its glue and is fetched automatically — nothing to wire up:
 
 ```ts
 import { preloadTextMetrics, measureText } from 'onda-engine'
 
-await preloadTextMetrics()      // locates + instantiates the wasm core
-measureText('Hello', 48)        // real shaped metrics
+await preloadTextMetrics()   // locates + instantiates the wasm core
+measureText('Hello', 48)     // real shaped glyph metrics
 ```
 
-If you'd rather pass the binary URL explicitly (e.g. to control caching), the assets are addressable too:
-
-```ts
-import wasmUrl from 'onda-engine/wasm/pkg/onda_wasm_bg.wasm?url'
-import init, { OndaEngine } from 'onda-engine/wasm'
+> **`onda-engine/render` is Node-only** — it uses `fs`, `child_process`, and ffmpeg. Don't import it into browser code; use it from a server or CLI.
 
-await init(wasmUrl)
-const engine = new OndaEngine()
-```
+## Onda Studio
 
-### `onda-engine/render` is Node-only
+ONDA is the **engine**; **[Onda Studio](https://studio.onda.video)** is the **director**.
 
-The headless renderer uses `fs`, `child_process`, and ffmpeg — **do not import it into browser code** (your bundler will try to externalize Node built-ins and fail). Use it from a server/CLI:
-
-```ts
-import { renderToFile } from 'onda-engine/render'
-```
+Studio is an AI motion-graphics studio — *"Lovable for video."* Describe a scene in plain language and an agent composes, renders, and ships it — frame-accurate, on this exact engine. The engine stands on its own as a programmatic-video toolkit; Studio is what it makes possible.
 
 ## Requirements
 
 - **React 19** (peer dependency)
-- A bundler that handles `.wasm` assets for browser use (Vite recommended), or Node ≥ 20 for server-side use
-- WebGPU for the GPU (`wasm-vello`) path; the CPU path (`wasm`) is the fallback
+- A bundler that handles `.wasm` assets for browser use (**Vite** recommended), or **Node ≥ 20** for server-side rendering
+- **WebGPU** for the GPU (`wasm-vello`) path; the CPU core (`wasm`) is the always-available fallback
+
+## License — read this first
+
+**Source-available — _not_ open source.** `onda-engine` is licensed under the **[Functional Source License](https://raw.githubusercontent.com/onda-engine/onda-engine/main/LICENSE)** (`FSL-1.1-Apache-2.0`):
+
+- ✅ **You may** read, run, self-host, modify, and build **non-competing** products with it — freely, no fee.
+- 🚫 **You may not** use it to make a product that **competes** with ONDA.
+- ⏳ **It turns into Apache-2.0:** each release automatically converts to full [Apache-2.0](https://raw.githubusercontent.com/onda-engine/onda-engine/main/LICENSE-APACHE) **two years** after it ships.
+
+If you need terms beyond the FSL grant, get in touch via [onda.video](https://onda.video).
 
-## License
+---
 
-[FSL-1.1-Apache-2.0](./LICENSE) — source-available, converting to Apache-2.0 over time. © Rodrigo Botelho.
+<div align="center">
+  <img src="https://raw.githubusercontent.com/onda-engine/onda-engine/main/assets/brand/onda-mark.svg" alt="ONDA" width="34" />
+  <br/><br/>
+  <sub><b>ONDA</b> &nbsp;·&nbsp; Motion graphics at GPU speed &nbsp;·&nbsp; <a href="https://onda.video">onda.video</a></sub>
+</div>

package/dist/wasm/pkg/onda_wasm.d.ts

@@ -0,0 +1,195 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Font-level vertical metrics exposed to JS — distances in pixels at the
+ * measured font size. Returned by [`OndaEngine::font_metrics`].
+ */
+export class FontMetricsJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Distance from node's `y` to the baseline (same as `TextMetrics.ascent`, px).
+     */
+    readonly ascent: number;
+    /**
+     * Height of capital letters (top of caps to baseline, px).
+     */
+    readonly cap_height: number;
+    /**
+     * Distance from the node's `y` to the top of capital letters (px).
+     */
+    readonly cap_top: number;
+    /**
+     * Baseline to bottom of the line box (px).
+     */
+    readonly descent: number;
+    /**
+     * Baseline-to-baseline line height (px).
+     */
+    readonly lineHeight: number;
+    /**
+     * x-height in px (top of 'x' to baseline).
+     */
+    readonly x_height: number;
+    /**
+     * Distance from the node's `y` to the top of lowercase x (px).
+     */
+    readonly x_top: number;
+}
+
+/**
+ * The engine: holds a renderer (with the bundled default font) and rasterizes
+ * scene-graph JSON to frames. Construct once and reuse across frames.
+ */
+export class OndaEngine {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Font-level vertical metrics for `font_size` + optional family/weight/italic.
+     * Derived by rasterizing 'H' (cap height) and 'x' (x-height) — pixel-accurate
+     * for the actual rendered font. Call once per (size, family, weight) combo, not
+     * per frame. Use the returned `capTop`/`capHeight` to vertically center text
+     * without empirical guesswork.
+     */
+    fontMetrics(font_size: number, family?: string | null, weight?: number | null, italic?: boolean | null): FontMetricsJs;
+    /**
+     * Kerning-aware glyph layout for `content` at `font_size`. Returns a
+     * `Float32Array` with 4 floats per cluster: `[start_byte, end_byte, x, advance]`.
+     * Unlike calling `measureText` per character, `advance` includes kern pairs.
+     * Slice with stride 4; the total advance sum equals the shaped line width.
+     */
+    glyphLayout(content: string, font_size: number, family?: string | null, weight?: number | null, italic?: boolean | null, letter_spacing?: number | null): Float32Array;
+    /**
+     * Load an additional font (`.ttf`/`.otf` bytes) so text can select it by
+     * family (e.g. a brand display face for kinetic typography). Returns the
+     * family name(s) it provides, newline-joined. Loaded into BOTH the renderer
+     * (which draws the glyphs) and the layout/measurement font context, so
+     * author-time `measureText`/`glyphLayout`/`fontMetrics` — and therefore
+     * `<TextAnimator>`/`KineticText` glyph placement — match what the engine
+     * draws. This is the custom-font parity guarantee: same bytes, same shaping,
+     * for measure and render. Mirrors `VelloEngine::load_font`.
+     */
+    loadFont(data: Uint8Array): string;
+    /**
+     * Measure `content` at `font_size` (px) with optional family / weight /
+     * italic, returning its [`TextMetricsJs`]. The same shaping the engine draws,
+     * so a component can size underlines/pills/carets to the real text — in both
+     * the browser preview and (warmed once) the Node export path.
+     */
+    measureText(content: string, font_size: number, family?: string | null, weight?: number | null, italic?: boolean | null, letter_spacing?: number | null): TextMetricsJs;
+    constructor();
+    /**
+     * Render a scene-graph JSON document (onda-scene format) to a frame.
+     * Resolves `data:` images and flex layout first (the same pre-passes the
+     * CLI runs), so an in-browser preview matches `onda export`.
+     */
+    render(scene_json: string): RenderedFrame;
+}
+
+/**
+ * A rendered frame: RGBA8 pixels plus dimensions.
+ */
+export class RenderedFrame {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly height: number;
+    /**
+     * Straight-alpha RGBA8 bytes (`width * height * 4`), ready for an
+     * `ImageData` and `putImageData`.
+     */
+    readonly pixels: Uint8Array;
+    readonly width: number;
+}
+
+/**
+ * Rendered text dimensions ([`onda_renderer::TextMetrics`]) for JS — what a
+ * component needs to size things to the *actual* text (proportional advance,
+ * ascent/descent) instead of a glyph-count guess. Pixels at the measured size.
+ */
+export class TextMetricsJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Top of the line box to the baseline.
+     */
+    readonly ascent: number;
+    /**
+     * Baseline to the bottom of the line box.
+     */
+    readonly descent: number;
+    /**
+     * Total laid-out height (line height × line count).
+     */
+    readonly height: number;
+    /**
+     * Baseline-to-baseline line height.
+     */
+    readonly lineHeight: number;
+    /**
+     * Shaped advance width — the true rendered width of the string.
+     */
+    readonly width: number;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_fontmetricsjs_free: (a: number, b: number) => void;
+    readonly __wbg_ondaengine_free: (a: number, b: number) => void;
+    readonly __wbg_renderedframe_free: (a: number, b: number) => void;
+    readonly __wbg_textmetricsjs_free: (a: number, b: number) => void;
+    readonly fontmetricsjs_ascent: (a: number) => number;
+    readonly fontmetricsjs_cap_height: (a: number) => number;
+    readonly fontmetricsjs_cap_top: (a: number) => number;
+    readonly fontmetricsjs_descent: (a: number) => number;
+    readonly fontmetricsjs_lineHeight: (a: number) => number;
+    readonly fontmetricsjs_x_height: (a: number) => number;
+    readonly fontmetricsjs_x_top: (a: number) => number;
+    readonly ondaengine_fontMetrics: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly ondaengine_glyphLayout: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
+    readonly ondaengine_loadFont: (a: number, b: number, c: number) => [number, number];
+    readonly ondaengine_measureText: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+    readonly ondaengine_new: () => number;
+    readonly ondaengine_render: (a: number, b: number, c: number) => [number, number, number];
+    readonly renderedframe_height: (a: number) => number;
+    readonly renderedframe_pixels: (a: number) => [number, number];
+    readonly renderedframe_width: (a: number) => number;
+    readonly textmetricsjs_ascent: (a: number) => number;
+    readonly textmetricsjs_descent: (a: number) => number;
+    readonly textmetricsjs_height: (a: number) => number;
+    readonly textmetricsjs_lineHeight: (a: number) => number;
+    readonly textmetricsjs_width: (a: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dist/wasm/pkg/onda_wasm_bg.wasm.d.ts

@@ -0,0 +1,34 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_fontmetricsjs_free: (a: number, b: number) => void;
+export const __wbg_ondaengine_free: (a: number, b: number) => void;
+export const __wbg_renderedframe_free: (a: number, b: number) => void;
+export const __wbg_textmetricsjs_free: (a: number, b: number) => void;
+export const fontmetricsjs_ascent: (a: number) => number;
+export const fontmetricsjs_cap_height: (a: number) => number;
+export const fontmetricsjs_cap_top: (a: number) => number;
+export const fontmetricsjs_descent: (a: number) => number;
+export const fontmetricsjs_lineHeight: (a: number) => number;
+export const fontmetricsjs_x_height: (a: number) => number;
+export const fontmetricsjs_x_top: (a: number) => number;
+export const ondaengine_fontMetrics: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const ondaengine_glyphLayout: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
+export const ondaengine_loadFont: (a: number, b: number, c: number) => [number, number];
+export const ondaengine_measureText: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+export const ondaengine_new: () => number;
+export const ondaengine_render: (a: number, b: number, c: number) => [number, number, number];
+export const renderedframe_height: (a: number) => number;
+export const renderedframe_pixels: (a: number) => [number, number];
+export const renderedframe_width: (a: number) => number;
+export const textmetricsjs_ascent: (a: number) => number;
+export const textmetricsjs_descent: (a: number) => number;
+export const textmetricsjs_height: (a: number) => number;
+export const textmetricsjs_lineHeight: (a: number) => number;
+export const textmetricsjs_width: (a: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/dist/wasm-audio/pkg/onda_wasm_audio.d.ts

@@ -0,0 +1,106 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A decoded audio clip you can sample a per-frame spectrum from.
+ */
+export class AudioAnalyzer {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * BEAT / onset / tempo analysis over `frame_count` frames at `fps`, for syncing
+     * motion to the music. Deterministic — identical to the native export.
+     */
+    beats(fps: number, frame_count: number): Beats;
+    /**
+     * Clip duration in seconds.
+     */
+    duration_secs(): number;
+    /**
+     * Decode audio `bytes` (a fetched file / `Uint8Array`). `ext_hint` is the
+     * file extension (`"mp3"`, `"wav"`, …) to aid format detection — `""` is fine
+     * (content probing still runs). Throws if the bytes aren't decodable audio.
+     */
+    constructor(bytes: Uint8Array, ext_hint: string);
+    /**
+     * Decoded sample rate (Hz).
+     */
+    sample_rate(): number;
+    /**
+     * Per-frame spectrum: a flat, frame-major `Float32Array` of length
+     * `frame_count * bands`, each value `0..1` (low→high). `fps` maps a frame
+     * index to its time. Deterministic — identical to the native export.
+     */
+    spectrogram(fps: number, frame_count: number, bands: number): Float32Array;
+}
+
+/**
+ * Beat / onset / tempo analysis of a clip, all in VIDEO-FRAME units. Returned by
+ * [`AudioAnalyzer::beats`]; read `tempo` + the typed arrays from JS.
+ */
+export class Beats {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Frame indices on the beat grid (`Uint32Array`).
+     */
+    readonly beats: Uint32Array;
+    /**
+     * Per-frame onset strength `0..1`, one value per frame (`Float32Array`).
+     */
+    readonly onsetEnv: Float32Array;
+    /**
+     * Frame indices of picked onsets — any transient (`Uint32Array`).
+     */
+    readonly onsets: Uint32Array;
+    /**
+     * Estimated tempo in beats per minute (0 if undetectable).
+     */
+    readonly tempo: number;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_audioanalyzer_free: (a: number, b: number) => void;
+    readonly __wbg_beats_free: (a: number, b: number) => void;
+    readonly audioanalyzer_beats: (a: number, b: number, c: number) => number;
+    readonly audioanalyzer_duration_secs: (a: number) => number;
+    readonly audioanalyzer_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly audioanalyzer_sample_rate: (a: number) => number;
+    readonly audioanalyzer_spectrogram: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly beats_beats: (a: number) => [number, number];
+    readonly beats_onsetEnv: (a: number) => [number, number];
+    readonly beats_onsets: (a: number) => [number, number];
+    readonly beats_tempo: (a: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dist/wasm-audio/pkg/onda_wasm_audio_bg.wasm.d.ts

@@ -0,0 +1,20 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_audioanalyzer_free: (a: number, b: number) => void;
+export const __wbg_beats_free: (a: number, b: number) => void;
+export const audioanalyzer_beats: (a: number, b: number, c: number) => number;
+export const audioanalyzer_duration_secs: (a: number) => number;
+export const audioanalyzer_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const audioanalyzer_sample_rate: (a: number) => number;
+export const audioanalyzer_spectrogram: (a: number, b: number, c: number, d: number) => [number, number];
+export const beats_beats: (a: number) => [number, number];
+export const beats_onsetEnv: (a: number) => [number, number];
+export const beats_onsets: (a: number) => [number, number];
+export const beats_tempo: (a: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/dist/wasm-vello/index.d.ts

@@ -0,0 +1 @@
+export { default, initSync, VelloEngine, RenderedFrame } from './pkg/onda_wasm_vello.js'

package/dist/wasm-vello/pkg/onda_wasm_vello.d.ts

@@ -0,0 +1,96 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A rendered frame: straight-alpha RGBA8 pixels (`width * height * 4`) plus
+ * dimensions — ready for an `ImageData` + `putImageData`.
+ */
+export class RenderedFrame {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly height: number;
+    readonly pixels: Uint8Array;
+    readonly width: number;
+}
+
+/**
+ * The GPU engine: holds a Vello renderer bound to a WebGPU device. Build it
+ * once with [`VelloEngine::create`] (async — it acquires the GPU), then reuse
+ * it across frames.
+ */
+export class VelloEngine {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Acquire a WebGPU device and build the renderer. Async (returns a JS
+     * `Promise`); rejects when WebGPU is unavailable so the caller can fall
+     * back to the CPU engine or Canvas2D.
+     */
+    static create(): Promise<VelloEngine>;
+    /**
+     * Load an additional font (`.ttf`/`.otf` bytes) so text can select it by
+     * family (e.g. a premium display face for Apple-tier type). Returns the
+     * family name(s) it provides, newline-joined. Loaded into BOTH the renderer
+     * (which draws the glyphs) and the layout/measurement font context, so the
+     * in-browser preview's text metrics match what it draws.
+     */
+    load_font(data: Uint8Array): string;
+    /**
+     * Render a scene-graph JSON document (onda-scene format) to a frame.
+     * Resolves `data:` images and flex layout first (the same pre-passes the
+     * CLI runs), so an in-browser preview matches `onda export`. Async: the GPU
+     * readback awaits the buffer map rather than blocking.
+     */
+    render(scene_json: string): Promise<RenderedFrame>;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_renderedframe_free: (a: number, b: number) => void;
+    readonly __wbg_velloengine_free: (a: number, b: number) => void;
+    readonly renderedframe_height: (a: number) => number;
+    readonly renderedframe_pixels: (a: number) => [number, number];
+    readonly renderedframe_width: (a: number) => number;
+    readonly velloengine_create: () => any;
+    readonly velloengine_load_font: (a: number, b: number, c: number) => [number, number];
+    readonly velloengine_render: (a: number, b: number, c: number) => any;
+    readonly wasm_bindgen__convert__closures_____invoke__hb7a70be5e517e2b6: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h4a9e248cef8c86eb: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hc31f91f73c930b42: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hc31f91f73c930b42_2: (a: number, b: number, c: any) => void;
+    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;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dist/wasm-vello/pkg/onda_wasm_vello_bg.wasm.d.ts

@@ -0,0 +1,24 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_renderedframe_free: (a: number, b: number) => void;
+export const __wbg_velloengine_free: (a: number, b: number) => void;
+export const renderedframe_height: (a: number) => number;
+export const renderedframe_pixels: (a: number) => [number, number];
+export const renderedframe_width: (a: number) => number;
+export const velloengine_create: () => any;
+export const velloengine_load_font: (a: number, b: number, c: number) => [number, number];
+export const velloengine_render: (a: number, b: number, c: number) => any;
+export const wasm_bindgen__convert__closures_____invoke__hb7a70be5e517e2b6: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h4a9e248cef8c86eb: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__hc31f91f73c930b42: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__hc31f91f73c930b42_2: (a: number, b: number, c: any) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_destroy_closure: (a: number, b: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onda-engine",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "The source-available motion graphics engine — GPU-native, scene-graph-first, framework-agnostic. One install for the whole engine: React renderer, motion-language components, player, renderer, and the wasm core.",
   "keywords": [
     "onda",
@@ -93,20 +93,20 @@
     "@types/react-reconciler": "^0.33.0",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
+    "@onda-engine/cinema": "0.1.3",
+    "@onda-engine/components": "0.3.0",
     "@onda-engine/player": "0.1.1",
     "@onda-engine/react": "0.1.1",
-    "@onda-engine/components": "0.3.0",
     "@onda-engine/render": "0.1.1",
-    "@onda-engine/cinema": "0.1.3",
     "@onda-engine/wasm-audio": "0.1.1",
-    "@onda-engine/wasm-vello": "0.1.1",
-    "@onda-engine/wasm": "0.1.1"
+    "@onda-engine/wasm": "0.1.1",
+    "@onda-engine/wasm-vello": "0.1.1"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node scripts/copy-wasm.mjs",
     "clean": "rm -rf dist"
   }
 }