@tongue-core/ui 0.0.0-stage → 0.1.0-rc.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Backpine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,138 @@
-# Temporary Holding Version
+# @tongue-core/ui
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+What a film's interface is built from: a **player**, a **timeline's state and geometry**, and
+**unstyled React primitives** over the two. [@tongue-core/studio](../studio) is our app built from these
+alone; a client builds theirs from the same pieces and gets the same speed, because the speed lives
+below the UI. [docs/ui.md](../../docs/ui.md) is the design, with the budgets and what was measured.
+
+```bash
+bun add @tongue-core/ui@next react react-dom effect @effect/atom-react   # the last four are peers
+```
+
+The player's worker (`@tongue-core/ui/player/worker`) is a script of its own: bundle it next to your
+app and pass its URL to `createPlayer`.
+
+## Entry points
+
+| Import | Holds | Depends on |
+|---|---|---|
+| `@tongue-core/ui/player` | `createPlayer`: a build played on a canvas, with workers, readiness, the frame cache, video and sound; and its parts (`FilmNeeds`, `AssetLoader`, `FrameCache`, `Transport`, `wantedFrames`) | the engine (in the workers only), `@tongue-core/project` |
+| `@tongue-core/ui/player/worker` | the worker script: bundle it and pass its URL | the engine |
+| `@tongue-core/ui/timeline` | `makeTimeline`: a timeline as Effect Atoms; `connectPlayer`; pure models of the film, the view, the ruler, selection, rows and previews | Effect, `@tongue-core/project/doc` |
+| `@tongue-core/ui/react` | `TimelineProvider`, the `Timeline.*` primitives, `usePlayer`, `useTransport`, `useTimelineKeys`, `useAtomEffect` | React 19 (peer), `@effect/atom-react` |
+
+The entries are boundaries, checked by bundling each alone: `/timeline` carries no engine and no
+React; `/player`'s page code carries no React and no engine (the raster stays in the worker).
+
+## A player
+
+```ts
+import { createPlayer } from "@tongue-core/ui/player";
+
+const player = createPlayer({ canvas, workerUrl: new URL("./worker.js", import.meta.url) });
+await player.load({ build: "https://cdn.example/films/promo/" });   // or "/build/": any folder with build.json
+player.on("frame", ({ frame }) => …);
+player.on("readiness", ({ ranges, progress }) => …);               // what can be drawn, what is loaded
+player.seek(240); player.play(); player.pause();
+player.fit(canvas.clientWidth);                                      // render at the size it is shown
+const bitmap = await player.preview(900, 160);                       // a thumbnail, when the workers are free
+```
+
+The picture keeps the film's shape in whatever box the page gives the canvas: unless the page
+sets its own `object-fit`, the player sets `contain`, so a box of another shape letterboxes the
+frame instead of stretching it.
+
+A build is static files: `build.json`, `film.json`, `scenes/*.js`, `assets/…` (`tongue build`
+writes one). The player fetches them from the build's folder or, given `read` instead of `build`,
+reads them a file at a time from wherever the build is kept (a Git commit, memory, an archive):
+
+```ts
+// Each path as the build gives it: "build.json", "scenes/title.5ebf1e9a05d5.js", "assets/fonts/inter.ttf"…
+await player.load({ read: (path, signal) => commit.bytes(path, signal) });
+```
+
+Either way it reads the manifests and bundles, then the asset files frames need, nearest the
+playhead first, each checked against its hash. **A frame is drawn only once every file it needs
+is there**; until then the last frame stays up. Video plays from the proxy segments import makes
+(H.264, decoded with WebCodecs in a worker), sound from the soundtrack mixed a few seconds at a time.
+Frames, video frames and sound are byte-for-byte what Bun makes from the same build.
+
+Version 2 builds can keep their media outside the build. The player reads each remote file from
+the URL in its manifest, verifies its hash, and bypasses `read` for that file. A Git-backed studio
+therefore needs only code and manifests in Git; originals are never fetched by the browser.
+Remote builds fetch a bounded window of proxy video and segmented audio (15 seconds ahead by
+default). Scenes request their actual video segments when drawn. Old compressed data and decoded
+audio segments are evicted, with stale transfers cancelled after seeks; a queued request the window
+leaves behind is cancelled too, so no decoder waits on a segment nobody will fetch. A video's
+decodes wait for their segments before taking their turn (playback is never held up behind a
+thumbnail on its way), and a jump skips playback's decodes still queued for where it was. `mediaCacheBytes`
+(default 64 MiB) and `mediaAhead` configure the window; files required by active requests remain
+pinned until those requests finish. Decoded video frames have a separate shared byte budget.
+
+```ts
+await player.load({
+  read: (path, signal) => commit.bytes(path, signal),
+  request: (url, signal, headers) => fetch(url, { signal, headers }),
+});
+```
+
+The optional `request` hook supplies authentication or URL refresh. Transient downloads retry
+through the shared media transport. `readiness.failed` reports permanent failures; `player.retry()`
+retries them after the host restores access. `readiness.mediaBytes` reports retained compressed
+data. Failure records also expose `reason`, `status` and `retryable` when known. For streaming
+builds, progress counts describe the current fetch window. Readiness ranges for dynamic scene
+video conservatively report already rendered exact frames, since a scene can choose arbitrary
+source times. Local packaged builds preserve their existing background preloading behavior.
+
+## A timeline
+
+```ts
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { connectPlayer, makeTimeline } from "@tongue-core/ui/timeline";
+
+const registry = AtomRegistry.make();
+const timeline = makeTimeline();
+const part = connectPlayer(registry, timeline, player);   // reports in, commands out
+
+registry.get(timeline.model);                                     // rows, clips, edges: film.json laid out
+registry.set(timeline.commands, { type: "nextEdge" });            // intents; the player carries them out
+registry.set(timeline.view, { type: "zoom", factor: 2, anchor: 300 });
+registry.subscribe(timeline.items("base"), (items) => …);         // what a row draws at this zoom
+```
+
+What depends on what decides what it costs: the model is rebuilt only for a new film.json; what a
+row draws changes only when the view crosses a power-of-two step of frames or of zoom; the playhead
+is a report that nothing heavy reads. Commands are numbered, so a reported playhead never becomes a
+seek. Everything under the atoms is pure and tested on its own (`view.ts`, `ticks.ts`, `items.ts`…).
+
+## React
+
+```tsx
+import { Timeline, TimelineProvider, usePlayer, useTimelineKeys } from "@tongue-core/ui/react";
+
+<TimelineProvider timeline={timeline} registry={registry} previews={player}>
+  <Timeline.Root>
+    <Timeline.Scroller>
+      <Timeline.Ruler />
+      <Timeline.Ready />
+      <Timeline.Rows>{(row) => <Timeline.Row key={row.id} row={row} />}</Timeline.Rows>
+      <Timeline.Playhead />
+    </Timeline.Scroller>
+  </Timeline.Root>
+  <Timeline.Timecode />
+</TimelineProvider>
+```
+
+Unstyled: every element has `data-tl-*` attributes to style by (`[data-tl-clip][data-selected]`,
+`[data-tl-clip][data-kind="video"]`, `[data-tl-run]`…). Positions are frames in CSS variables times
+the zoom (`--tl-ppf`), so zooming and scrolling are the browser's work, not React's; the playhead and
+the timecode write to their own elements, so playing commits nothing. Clips narrower than a few
+pixels join runs, one element each, so an hour of a thousand clips is a few hundred elements zoomed
+out. `useAtomEffect(atom, f)` is the same trick for your own readouts.
+
+## Checks
+
+`bun test` runs the pure parts and the atom graph (in a bare registry). In headless Chrome:
+`tools/ui-bench/player-check.ts` (the player on built projects, local and cross-origin, against the
+budgets), `tools/ui-bench/react-check.ts` (the primitives on an hour of clips) and
+`tools/ui-bench/studio-check.ts` (the studio). The lab pages they drive are in `lab/`.

package/dist/budgets.d.ts

@@ -0,0 +1,17 @@
+export interface Budgets {
+    /** From load() to the first frame on screen, warm cache, local build. */
+    readonly firstFrameMs: number;
+    /** A jump anywhere while paused, to the frame on screen (assets already loaded): p95. */
+    readonly seekP95Ms: number;
+    /** Frames shown per second while scrubbing (dragging the playhead). */
+    readonly scrubFps: number;
+    /** Frames dropped per minute of playback at 1080p, 30 fps, render scale 0.5. */
+    readonly droppedPerMinute: number;
+    /** Frame time while panning and zooming a timeline of 1,000 clips: p95. */
+    readonly timelineFrameP95Ms: number;
+    /** React commits per playback frame (the playhead is drawn outside React). */
+    readonly commitsPerPlaybackFrame: number;
+    /** Bytes of rendered frames kept in memory. */
+    readonly frameCacheBytes: number;
+}
+export declare const BUDGETS: Budgets;

package/dist/budgets.js

@@ -0,0 +1,12 @@
+// The performance budgets every layer of the UI is built and measured against. The benchmark
+// harness (tools/ui-bench) runs generated films (an hour with a thousand clips, ten minutes of
+// footage) in headless Chrome and fails when one is exceeded. docs/ui.md explains each.
+export const BUDGETS = {
+    firstFrameMs: 1000,
+    seekP95Ms: 120,
+    scrubFps: 20,
+    droppedPerMinute: 30,
+    timelineFrameP95Ms: 16.7,
+    commitsPerPlaybackFrame: 0,
+    frameCacheBytes: 256 * 1024 * 1024,
+};

package/dist/player/assets.d.ts

@@ -0,0 +1,75 @@
+import { MediaFailure } from "@tongue-core/project/media";
+export interface AssetFailureInfo {
+    readonly message: string;
+    readonly reason?: MediaFailure["reason"];
+    readonly status?: number;
+    readonly retryable?: boolean;
+}
+export interface AssetFileInfo {
+    readonly url?: string;
+    /** Relative to the build's assets folder: fonts/inter.ttf. */
+    readonly path: string;
+    /** Its size, when the build says (0 when unknown). */
+    readonly bytes: number;
+    /** SHA-256, hex, when the build says. */
+    readonly hash: string | null;
+}
+export type AssetStatus = "waiting" | "loading" | "ready" | "failed";
+export interface AssetProgress {
+    /** Counts describe the current fetch window when streaming. */
+    readonly streaming?: boolean;
+    readonly files: number;
+    readonly ready: number;
+    readonly failed: number;
+    /** Bytes of every file, and of those ready (sizes the build gives). */
+    readonly bytes: number;
+    readonly bytesReady: number;
+}
+export type FetchBytes = (path: string, signal: AbortSignal) => Promise<Uint8Array>;
+export declare class AssetLoader {
+    private readonly fetchBytes;
+    private readonly concurrency;
+    private readonly maxBytes;
+    private readonly entries;
+    private readonly listeners;
+    private readonly abort;
+    private active;
+    private clock;
+    private readonly retained;
+    onEvict: (path: string) => void;
+    /** A request for `path` was withdrawn before it was answered — its transfer stopped, or it never
+     *  started — so whoever waits for the file hears it won't come (and asks again if it still wants it). */
+    onCancel: (path: string) => void;
+    constructor(files: ReadonlyArray<AssetFileInfo>, fetchBytes: FetchBytes, concurrency?: number, maxBytes?: number);
+    /** Asks for files at a priority: lower is sooner. Files the build doesn't list are ignored. */
+    want(paths: Iterable<string>, priority: number): void;
+    status(path: string): AssetStatus | null;
+    readonly isReady: (path: string) => boolean;
+    /** A ready file's bytes. */
+    data(path: string): Uint8Array | null;
+    /** Changes the fetch window. Requests outside it are withdrawn, under way or still queued; old data
+     *  is evicted under the byte budget. */
+    retain(paths: Iterable<string>): void;
+    get heldBytes(): number;
+    private evict;
+    /** Why a file failed. */
+    error(path: string): string | null;
+    failure(path: string): AssetFailureInfo;
+    failMissing(path: string): void;
+    failures(): ReadonlyArray<{
+        readonly path: string;
+    } & AssetFailureInfo>;
+    progress(windowOnly?: boolean): AssetProgress;
+    /** Takes over files another loader (the last build's) already has, where the hashes match: a
+     *  rebuild fetches only what changed. Returns the paths taken over. */
+    carryOver(previous: AssetLoader): ReadonlyArray<string>;
+    /** Files that failed go back in the queue. */
+    retry(): void;
+    onChange(listener: (path: string) => void): () => void;
+    dispose(): void;
+    private changed;
+    /** The most urgent file asked for and not started. */
+    private next;
+    private pump;
+    private load;
+}

package/dist/player/assets.js

@@ -0,0 +1,213 @@
+// The player's one fetcher of imported asset files. Files are fetched most urgent first (a lower
+// priority number is sooner; a file keeps the most urgent priority anyone asked it at), a few at a
+// time, each checked against the hash its build gives it. Every file has a status, and the loader
+// says when one changes: that is what readiness, progress bars and "can this frame be drawn
+// exactly" are made of. Nothing here knows about frames.
+import { MediaFailure } from "@tongue-core/project/media";
+async function sha256(bytes) {
+    const copy = new Uint8Array(bytes.length);
+    copy.set(bytes);
+    const digest = await crypto.subtle.digest("SHA-256", copy);
+    return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+export class AssetLoader {
+    fetchBytes;
+    concurrency;
+    maxBytes;
+    entries = new Map();
+    listeners = new Set();
+    abort = new AbortController();
+    active = 0;
+    clock = 0;
+    retained = new Set();
+    onEvict = () => { };
+    /** A request for `path` was withdrawn before it was answered — its transfer stopped, or it never
+     *  started — so whoever waits for the file hears it won't come (and asks again if it still wants it). */
+    onCancel = () => { };
+    constructor(files, fetchBytes, concurrency = 6, maxBytes = Infinity) {
+        this.fetchBytes = fetchBytes;
+        this.concurrency = concurrency;
+        this.maxBytes = maxBytes;
+        for (const info of files)
+            this.entries.set(info.path, { info, status: "waiting", priority: Number.POSITIVE_INFINITY, data: null, error: null, abort: null, used: 0, failure: null });
+    }
+    /** Asks for files at a priority: lower is sooner. Files the build doesn't list are ignored. */
+    want(paths, priority) {
+        for (const path of paths) {
+            const e = this.entries.get(path);
+            if (e)
+                e.used = ++this.clock;
+            if (e && priority < e.priority)
+                e.priority = priority;
+        }
+        this.pump();
+    }
+    status(path) {
+        return this.entries.get(path)?.status ?? null;
+    }
+    isReady = (path) => this.entries.get(path)?.status === "ready";
+    /** A ready file's bytes. */
+    data(path) {
+        const entry = this.entries.get(path);
+        if (entry)
+            entry.used = ++this.clock;
+        return entry?.data ?? null;
+    }
+    /** Changes the fetch window. Requests outside it are withdrawn, under way or still queued; old data
+     *  is evicted under the byte budget. */
+    retain(paths) {
+        this.retained.clear();
+        for (const path of paths)
+            this.retained.add(path);
+        for (const [path, entry] of this.entries) {
+            if (this.retained.has(path))
+                continue;
+            const queued = entry.status === "waiting" && entry.priority < Number.POSITIVE_INFINITY;
+            const transfer = entry.abort !== null && !entry.abort.signal.aborted ? entry.abort : null;
+            entry.priority = Number.POSITIVE_INFINITY;
+            transfer?.abort();
+            if (queued || transfer)
+                this.onCancel(path);
+        }
+        this.evict();
+    }
+    get heldBytes() { let bytes = 0; for (const entry of this.entries.values())
+        bytes += entry.data?.length ?? 0; return bytes; }
+    evict() {
+        let bytes = this.heldBytes;
+        const candidates = [...this.entries.values()].filter((entry) => entry.data && !this.retained.has(entry.info.path)).sort((a, b) => a.used - b.used);
+        for (const entry of candidates) {
+            if (bytes <= this.maxBytes)
+                break;
+            bytes -= entry.data?.length ?? 0;
+            entry.data = null;
+            entry.status = "waiting";
+            entry.priority = Infinity;
+            this.onEvict(entry.info.path);
+            this.changed(entry.info.path);
+        }
+    }
+    /** Why a file failed. */
+    error(path) {
+        return this.entries.get(path)?.error ?? null;
+    }
+    failure(path) {
+        const entry = this.entries.get(path), failure = entry?.failure;
+        return { message: entry?.error ?? "failed", ...(failure ? { reason: failure.reason, retryable: failure.retryable, ...(failure.status === undefined ? {} : { status: failure.status }) } : {}) };
+    }
+    failMissing(path) {
+        const failure = new MediaFailure({ asset: path, source: "build.json", reason: "invalid", retryable: false, message: `The build does not list required preview file ${path}. Rebuild or repair its prepared-media manifest.` });
+        this.entries.set(path, { info: { path, bytes: 0, hash: null }, status: "failed", priority: Infinity, data: null, error: failure.message, abort: null, used: ++this.clock, failure });
+        this.changed(path);
+    }
+    failures() {
+        return [...this.entries.values()].filter((entry) => entry.status === "failed").map((entry) => ({ path: entry.info.path, ...this.failure(entry.info.path) }));
+    }
+    progress(windowOnly = false) {
+        let ready = 0, failed = 0, bytes = 0, bytesReady = 0, files = 0;
+        for (const e of this.entries.values()) {
+            if (windowOnly && !this.retained.has(e.info.path))
+                continue;
+            files++;
+            bytes += e.info.bytes;
+            if (e.status === "ready") {
+                ready++;
+                bytesReady += e.info.bytes;
+            }
+            if (e.status === "failed")
+                failed++;
+        }
+        return { files, ready, failed, bytes, bytesReady, ...(windowOnly ? { streaming: true } : {}) };
+    }
+    /** Takes over files another loader (the last build's) already has, where the hashes match: a
+     *  rebuild fetches only what changed. Returns the paths taken over. */
+    carryOver(previous) {
+        const taken = [];
+        for (const [path, e] of this.entries) {
+            const old = previous.entries.get(path);
+            if (!old || old.status !== "ready" || old.data === null || e.info.hash === null || old.info.hash !== e.info.hash)
+                continue;
+            e.data = old.data;
+            e.status = "ready";
+            taken.push(path);
+        }
+        return taken;
+    }
+    /** Files that failed go back in the queue. */
+    retry() {
+        for (const e of this.entries.values())
+            if (e.status === "failed" && e.failure?.reason !== "invalid") {
+                e.status = "waiting";
+                e.error = null;
+                e.failure = null;
+            }
+        this.pump();
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    dispose() {
+        this.abort.abort();
+        for (const entry of this.entries.values())
+            entry.abort?.abort();
+        this.listeners.clear();
+    }
+    changed(path) {
+        for (const listener of this.listeners)
+            listener(path);
+    }
+    /** The most urgent file asked for and not started. */
+    next() {
+        let best = null;
+        for (const e of this.entries.values()) {
+            if (e.status === "waiting" && e.priority < Number.POSITIVE_INFINITY && (!best || e.priority < best.priority))
+                best = e;
+        }
+        return best;
+    }
+    pump() {
+        while (this.active < this.concurrency && !this.abort.signal.aborted) {
+            const e = this.next();
+            if (!e)
+                return;
+            this.active++;
+            e.status = "loading";
+            this.changed(e.info.path);
+            void this.load(e).finally(() => {
+                this.active--;
+                this.pump();
+            });
+        }
+    }
+    async load(e) {
+        const abort = new AbortController();
+        e.abort = abort;
+        try {
+            const data = await this.fetchBytes(e.info.path, AbortSignal.any([this.abort.signal, abort.signal]));
+            const integrity = (message) => new MediaFailure({ asset: e.info.path, source: e.info.url ?? e.info.path, reason: "integrity", retryable: false, message });
+            if (e.info.bytes > 0 && data.length !== e.info.bytes)
+                throw integrity(`its size differs from the build (${data.length} bytes, expected ${e.info.bytes})`);
+            if (e.info.hash !== null && (await sha256(data)) !== e.info.hash)
+                throw integrity("its contents don't match the build (the hash differs)");
+            e.data = data;
+            e.status = "ready";
+        }
+        catch (error) {
+            if (this.abort.signal.aborted)
+                return;
+            if (abort.signal.aborted) {
+                e.status = "waiting";
+                return;
+            }
+            e.status = "failed";
+            e.failure = error instanceof MediaFailure ? error : null;
+            e.error = error instanceof Error ? error.message : String(error);
+        }
+        finally {
+            e.abort = null;
+        }
+        this.changed(e.info.path);
+        this.evict();
+    }
+}

package/dist/player/audio.d.ts

@@ -0,0 +1,72 @@
+import type { MixResult } from "./pool.js";
+export interface SoundtrackOptions {
+    readonly fps: number;
+    /** The film's length in frames. */
+    readonly length: number;
+    /** Mixes frames [from, to). */
+    readonly mix: (from: number, to: number, signal: AbortSignal) => Promise<MixResult>;
+    /** Frames per chunk (default 5 seconds). */
+    readonly chunk?: number;
+    /** Chunks kept mixed ahead of the playhead (default 3). */
+    readonly ahead?: number;
+}
+/** A chunk to put on the audio clock: when it starts, and how far into it (the chunk playback started in starts part way). */
+export interface DueChunk {
+    readonly chunk: number;
+    readonly when: number;
+    readonly offset: number;
+}
+export interface DueOptions {
+    /** The first chunk not yet on the clock. */
+    readonly next: number;
+    /** Frames per chunk, frames a second, and the film's length in frames. */
+    readonly size: number;
+    readonly fps: number;
+    readonly length: number;
+    /** Playback started at this frame, at this time on the audio clock. */
+    readonly startFrame: number;
+    readonly startTime: number;
+    /** The audio clock now, and how far ahead of it (seconds) sound may be put. */
+    readonly now: number;
+    readonly horizon: number;
+    readonly mixed: (chunk: number) => boolean;
+}
+/**
+ * The chunks to put on the audio clock now, in order from `next`: each one mixed, starting no further
+ * than `horizon` seconds ahead of the clock. It stops at the first chunk still being mixed (it is on
+ * its way) or too far ahead (a later tick takes it), and at the end of the film. Pure.
+ */
+export declare function dueChunks(o: DueOptions): ReadonlyArray<DueChunk>;
+export declare class Soundtrack {
+    private readonly options;
+    private context;
+    private readonly chunks;
+    private readonly mixing;
+    private readonly controllers;
+    private playing;
+    private readonly size;
+    private readonly ahead;
+    private volume;
+    private gain;
+    private generation;
+    constructor(options: SoundtrackOptions);
+    /** The audio clock in seconds, when it is running (it runs only after a user gesture). */
+    clock(): number | null;
+    /** Creates or resumes the audio context; call it from a click or key press. */
+    wake(): void;
+    setVolume(volume: number): void;
+    /** Whether the chunk under `frame` is mixed (playback waits for it when there is a clock). */
+    ready(frame: number): boolean;
+    /** Mixes the chunks from `frame` on that aren't mixed yet. */
+    prepare(frame: number): void;
+    /** Starts sound at `frame`, at audio time `time` (from clock()). */
+    start(frame: number, time: number): void;
+    /** Schedules the chunks that are mixed and due (`dueChunks`); call it every tick while playing. */
+    schedule(): void;
+    stop(): void;
+    /** The film changed: forget every chunk. */
+    reset(): void;
+    dispose(): void;
+    private chunkOf;
+    private load;
+}