melonjs 20.7.0 → 20.9.0

package/README.md

@@ -61,14 +61,15 @@ Graphics
     - **2D** — `Light2d` as a first-class `Renderable` (multiple dynamic lights, radial-gradient falloff, illumination-only mode, procedural rendering via `drawLight`), plus optional per-pixel normal-map shading on sprites for 3D-looking dynamic lights
     - **3D** — `Light3d` directional, point, spot and ambient lights, added to the world like `Light2d` (half-Lambert diffuse + ambient fill, quadratic falloff and cone angles on the punctual types, runtime-manipulable for day/night), auto-loaded from a glTF scene's authored suns and lamps
     - up to **32 simultaneous lights** on either path, with light data travelling in a uniform buffer — a static light rig costs zero GPU state changes per frame
-- Ground ("blob") shadows for 3D objects — **on by default** — so characters and props read as standing on the floor instead of hovering. An ellipse matching the caster's own footprint and rotation, shrinking and fading with height above the ground; one extra draw per object, and **one for an entire `InstancedMesh` scatter regardless of instance count**. Controllable per object, per glTF scene (`level.load(name, { castGroundShadow })`) or application-wide. Deliberately not shadow mapping: it answers "where is this standing", which is what a 2.5D scene needs
-- Built-in shader effects (Flash, Outline, Glow, Dissolve, CRT, Hologram, etc.) with multi-pass chaining via `addPostEffect()`, plus custom shader support on both GPU backends: `ShaderEffect` for per-sprite fragment effects (GLSL and/or WGSL bodies) and complete custom mesh shader programs via `mesh.shader` (a dual-language `GLShader`: GLSL pair and/or WGSL module)
+- Ground ("blob") shadows for 3D objects — **on by default** — so characters and props read as standing on the floor instead of hovering. An ellipse matching the caster's own footprint and rotation, shrinking and fading with height above the ground; one extra draw per object, and **one for an entire `InstancedMesh` scatter regardless of instance count**. Shaped by the light rather than always straight down: `shadowLight` points a blob at a `Light3d` and is re-read every draw, so a day/night cycle carries every shadow with it, while `shadowOffset` slides it out from the caster's feet, `shadowStretch` lengthens it for a low sun, `shadowScale` sizes it independently of the object, and `shadowGroundNormal` lays it on a floor that is not level. All of them work on an `InstancedMesh` too, as one value for the whole set. Controllable per object, per glTF scene (`level.load(name, { castGroundShadow, shadowLight, … })`) or application-wide. Deliberately not shadow mapping: it answers "where is this standing", which is what a 2.5D scene needs
+- Built-in shader effects (Flash, Outline, Glow, Bloom, ToneMapping, Dissolve, CRT, Hologram, etc.) with multi-pass chaining via `addPostEffect()`, plus custom shader support on both GPU backends: `ShaderEffect` for per-sprite fragment effects (GLSL and/or WGSL bodies) and complete custom mesh shader programs via `mesh.shader` (a dual-language `GLShader`: GLSL pair and/or WGSL module)
+- Optional HDR rendering (`hdr: true`) — the camera's render targets become half-float, so additive light stops saturating on every write and `BloomEffect` thresholds on genuinely over-bright pixels instead of merely bright ones, with `ToneMappingEffect` and a `toneMapping` setting to compress the result back into display range when your art calls for it. Off by default and additive: nothing is inserted into your effect chain, so turning it on does not restyle a game whose look is built on clipped whites. On WebGPU it goes one step further — `hdrOutput: true` presents the frame in the display's own dynamic range rather than clamping it to SDR at the last step
 - Trail renderable for fading, tapering ribbons behind moving objects (speed lines, sword slashes, magic trails)
 - System & Bitmap Text with built-in typewriter effect
 - Video sprite playback
 
 Sound
-- Web Audio support with 3D spatial audio and stereo panning based on [Howler](https://howlerjs.com)
+- Web Audio support with 3D spatial audio and stereo panning, plus a procedural tone/noise API. The playback backend began as [howler.js](https://howlerjs.com) and is now a customized derivative vendored into the engine, so this is **not** a runtime dependency (see `src/audio/backend/LICENSE`)
 - Built-in procedural audio primitives (envelope-shaped oscillators, white/pink/brown noise) for SFX without sample assets
 - Direct `AudioContext` / master-gain accessors for custom WebAudio graphs that mix with the engine's master volume / mute
 
@@ -191,6 +192,9 @@ Examples
 * [3D Mesh](https://melonjs.github.io/melonJS/examples/#/mesh-3d) ([source](https://github.com/melonjs/melonJS/tree/master/packages/examples/src/examples/mesh3d))
 * [3D Mesh Material](https://melonjs.github.io/melonJS/examples/#/mesh-3d-material) ([source](https://github.com/melonjs/melonJS/tree/master/packages/examples/src/examples/mesh3dMaterial))
 * [AfterBurner Clone](https://melonjs.github.io/melonJS/examples/#/after-burner) ([source](https://github.com/melonjs/melonJS/tree/master/packages/examples/src/examples/afterBurner)) — `Camera3d` + 3D Mesh arcade shooter
+* [Earth Defender](https://melonjs.github.io/melonJS/examples/#/earth-defender) ([source](https://github.com/melonjs/melonJS/tree/master/packages/examples/src/examples/earthDefender)) — a Stardust tribute: a `Camera3d` posed from the player's own surface point, blob shadows lying on a sphere through `shadowGroundPoint`, mesh-hosted `ShaderEffect` shields, spatial audio and HDR bloom
+* [Ground Shadows](https://melonjs.github.io/melonJS/examples/#/ground-shadows) ([source](https://github.com/melonjs/melonJS/tree/master/packages/examples/src/examples/groundShadows)) — every blob-shadow setting side by side under an orbiting sun, including blobs lying on a slope and a 70-instance scatter that costs one extra draw
+* [Jungle Rabbit](https://melonjs.github.io/melonJS/examples/#/jungle-rabbit) ([source](https://github.com/melonjs/melonJS/tree/master/packages/examples/src/examples/jungleRabbit)) — a low-poly river endless runner: Blender-modelled props through `InstancedMesh`, a rigged paddling boat, a procedural valley and shadows laid on its banks
 * [glTF Scene](https://melonjs.github.io/melonJS/examples/#/gltf) ([source](https://github.com/melonjs/melonJS/tree/master/packages/examples/src/examples/gltf)) — a Blender-authored, lit 3D scene loaded with `level.load`
 * [glTF Animated Model](https://melonjs.github.io/melonJS/examples/#/gltf-character) ([source](https://github.com/melonjs/melonJS/tree/master/packages/examples/src/examples/gltf)) — a rigged character (Kenney Blocky Characters) with node animation, driven by the Sprite-aligned `setCurrentAnimation` / `play` / `pause` / `stop` API
 * [Trail](https://melonjs.github.io/melonJS/examples/#/trail) ([source](https://github.com/melonjs/melonJS/tree/master/packages/examples/src/examples/trail))

package/build/application/application.d.ts

@@ -46,7 +46,39 @@ export default class Application {
      */
     renderer: Renderer;
     /**
-     * the active stage "default" camera
+     * The "default" camera of the stage that is currently active.
+     *
+     * It MIRRORS the active stage, so it changes with every `state.change()`,
+     * and its concrete class is whatever that stage resolved to: an explicit
+     * `cameras` entry on the stage, then the stage's own `cameraClass`, then
+     * the application's `cameraClass`, then a shared {@link Camera2d}.
+     *
+     * **Typed as the base class on purpose.** A stage overrides the
+     * application, and built-in stages do: the loading screen pins a
+     * {@link Camera2d} whatever `cameraClass` the application was given. So
+     * there is no type this property could carry that a stage could not
+     * contradict, and a 3D application would be told it has a
+     * {@link Camera3d} here while the loader is up.
+     *
+     * A 3D game therefore has two sound options, and neither of them is a
+     * cast. OWN the camera, which is the better one, because the type is
+     * never lost in the first place:
+     * @example
+     * class GameStage extends Stage {
+     *     readonly camera: Camera3d;
+     *
+     *     constructor(app) {
+     *         const camera = new Camera3d(0, 0, app.renderer.width, app.renderer.height);
+     *         super({ cameras: [camera] });
+     *         // kept with its real type; nothing downstream has to narrow
+     *         this.camera = camera;
+     *     }
+     * }
+     * @example
+     * // or narrow where you read it, which the language already verifies
+     * if (app.viewport instanceof Camera3d) {
+     *     app.viewport.setBasis(right, up, forward);
+     * }
      */
     viewport: Camera2d;
     /**
@@ -216,21 +248,47 @@ export default class Application {
      * into — see {@link Application#getParentElement}), so the canvas and
      * any sibling HUD / overlay markup inside that container go fullscreen
      * together.
+     * Must be called from a USER GESTURE, a click or a key press. Browsers
+     * refuse it otherwise: the returned promise rejects, this logs the
+     * rejection and nothing happens on screen. That is why the example below
+     * hangs the call off a key rather than calling it at startup, and why a
+     * game offering fullscreen puts it behind a button or a menu entry.
+     *
+     * Does nothing when the browser has no fullscreen support, or when the
+     * application is already fullscreen.
      * @param element - optional element to fullscreen instead of `this.parentElement`
      * @example
-     * // bind F to toggle fullscreen
-     * me.input.bindKey(me.input.KEY.F, "toggleFullscreen");
-     * me.event.on(me.event.KEYDOWN, (action) => {
-     *   if (action === "toggleFullscreen") {
-     *     if (!app.isFullscreen()) app.requestFullscreen();
-     *     else app.exitFullscreen();
-     *   }
+     * import { event, input } from "melonjs";
+     *
+     * // F toggles fullscreen, from anywhere in the game
+     * input.bindKey(input.KEY.F, "fullscreen");
+     * event.on(event.KEYDOWN, (action, keyCode, edge) => {
+     *     // `edge` only: a held key auto-repeats, and a repeat would toggle
+     *     // straight back out of what it just turned on
+     *     if (action !== "fullscreen" || !edge) {
+     *         return;
+     *     }
+     *     if (app.isFullscreen()) {
+     *         app.exitFullscreen();
+     *     } else {
+     *         app.requestFullscreen();
+     *     }
      * });
      * @category Application
      */
     requestFullscreen(element?: Element): void;
     /**
      * Exit fullscreen mode for this application.
+     *
+     * Does nothing when the browser has no fullscreen support, or when the
+     * application is not fullscreen, so it is safe to call blind. Unlike
+     * {@link Application#requestFullscreen} it needs no user gesture: a page
+     * is always allowed to give fullscreen back.
+     *
+     * Note that the user can leave fullscreen without this being called, with
+     * Escape or the browser's own control, so a UI showing the current state
+     * should read {@link Application#isFullscreen} back rather than remember
+     * what it last asked for.
      * @category Application
      */
     exitFullscreen(): void;

package/build/application/application.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../src/application/application.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../src/application/application.ts"],"names":[],"mappings":"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"}

package/build/application/defaultApplicationSettings.d.ts

@@ -5,6 +5,11 @@ export declare const defaultApplicationSettings: {
     powerPreference: "default";
     transparent: false;
     antiAlias: false;
+    hdr: false;
+    hdrOutput: false;
+    toneMapping: "none";
+    toneMappingExposure: number;
+    toneMappingWhite: number;
     prewarm: true;
     textureFilter: "auto";
     maxTextures: "auto";
@@ -15,6 +20,7 @@ export declare const defaultApplicationSettings: {
     gpuTilemap: true;
     failIfMajorPerformanceCaveat: true;
     highPrecisionShader: true;
+    scaleRounding: "fractional";
     subPixel: false;
     verbose: false;
     backgroundColor: string;

package/build/application/defaultApplicationSettings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultApplicationSettings.d.ts","sourceRoot":"","sources":["../../src/application/defaultApplicationSettings.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;CAoBC,CAAC"}
+{"version":3,"file":"defaultApplicationSettings.d.ts","sourceRoot":"","sources":["../../src/application/defaultApplicationSettings.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BC,CAAC"}

package/build/application/header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../src/application/header.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAEhD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CA0BpD"}
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../src/application/header.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAEhD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CA+CpD"}

package/build/application/resize.d.ts

@@ -1,4 +1,29 @@
 import type Application from "./application.ts";
+/**
+ * The largest scale at or below `scale` that covers each source pixel with a
+ * WHOLE number of device pixels.
+ *
+ * Rounded down, and rounded in DEVICE pixels rather than CSS ones. That
+ * distinction is the whole of it: the canvas is given a CSS size and the
+ * browser multiplies by `devicePixelRatio` on the way to real pixels, so
+ * flooring the CSS factor lets the fraction come straight back. A factor of
+ * 2 at a ratio of 1.25 is 2.5 device pixels per source pixel, which is the
+ * unevenness the setting exists to remove.
+ *
+ * Worked through at a ratio of 2, fitting a 480 wide design into 1280: the
+ * raw factor is 2.667 CSS, which is 5.333 device pixels. Flooring here gives
+ * 5 device pixels, so a CSS factor of 2.5. Flooring the CSS factor instead
+ * would give 2, which is 4 device pixels: also whole, and a whole device
+ * pixel smaller than the container could have afforded.
+ *
+ * Never returns less than one device pixel per source pixel. A container
+ * smaller than the design resolution has no whole factor to give, and a
+ * scale of zero does not draw at all.
+ * @param scale - the unconstrained factor, in CSS pixels
+ * @param ratio - `devicePixelRatio`
+ * @returns the constrained factor, still in CSS pixels
+ */
+export declare function integerDeviceScale(scale: number, ratio: number): number;
 /**
  * callback for window resize event
  * @param game - the game application instance triggering the resize

package/build/application/resize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resize.d.ts","sourceRoot":"","sources":["../../src/application/resize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAkChD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAyGhD"}
+{"version":3,"file":"resize.d.ts","sourceRoot":"","sources":["../../src/application/resize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAkChD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CA4GhD"}

package/build/application/scaleMethods.d.ts

@@ -1,11 +1,21 @@
 export declare const ScaleMethods: {
     /**
-     * Manual; no scaling is performed
-     * <img src="images/scale-fit.png"/>
+     * Manual; no automatic scaling is performed. The canvas keeps the size it
+     * was given and nothing is measured.
+     *
+     * No illustration: there is nothing to show. The one that used to sit
+     * here was `Fit`'s.
      */
     readonly Manual: "manual";
     /**
-     * Letterboxed; content is scaled to design aspect ratio
+     * Letterboxed; the DESIGN RESOLUTION is kept and the whole frame is scaled
+     * to the largest factor that fits, leaving the rest as margin.
+     *
+     * The one mode where the game always sees exactly the world it was
+     * authored for: every other mode resizes the renderer, so the viewport
+     * grows or shrinks with the window. It is also the only mode
+     * `scaleRounding` applies to, since it is the only one with a fixed
+     * factor to round.
      * <img src="images/scale-fit.png"/>
      */
     readonly Fit: "fit";

package/build/application/scaleMethods.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaleMethods.d.ts","sourceRoot":"","sources":["../../src/application/scaleMethods.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;IACxB;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;CAEM,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC"}
+{"version":3,"file":"scaleMethods.d.ts","sourceRoot":"","sources":["../../src/application/scaleMethods.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;IACxB;;;;;;OAMG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;CAEM,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC"}

package/build/application/settings.d.ts

@@ -52,17 +52,51 @@ export type ApplicationSettings = {
      */
     renderer: RendererType | Renderer;
     /**
-     * enable scaling of the canvas ('auto' for automatic scaling)
+     * how the canvas is scaled to the page. A number is a fixed multiplier applied to the design resolution and nothing is measured; `"auto"` scales to the available space every time the window changes, using {@link ApplicationSettings.scaleMethod} to decide how and {@link ApplicationSettings.scaleTarget} to decide what is measured.
+     *
+     * `scaleMethod`, `scaleTarget` and {@link ApplicationSettings.scaleRounding} apply to `"auto"` only. With a fixed number they are ignored.
      * @default 1
+     * @see ApplicationSettings.scaleMethod
+     * @see ApplicationSettings.scaleTarget
+     * @see ApplicationSettings.scaleRounding
      */
     scale: number | "auto";
     /**
-     * screen scaling modes
+     * how automatic scaling uses the space available to it. Applies when {@link ApplicationSettings.scale} is `"auto"`.
+     *
+     * The distinction that decides which to pick is whether the DESIGN RESOLUTION moves. `"fit"` keeps it and scales the whole frame to the largest factor that fits, leaving the rest as margin, so the game always sees exactly the world it was authored for. Every other mode calls `renderer.resize()`, so the design resolution follows the container and the game sees MORE or LESS of the world on a different window: `"fill-min"` / `"fill-max"` keep the aspect ratio while doing so, `"flex"` / `"flex-width"` / `"flex-height"` resize one or both axes, and `"stretch"` scales each axis independently so the aspect ratio is not preserved. `"manual"` does nothing automatic.
+     *
+     * A game whose layout assumes a known frame wants `"fit"`. A game that should reveal more world on a larger window wants one of the others, and has to cope with a viewport whose size it did not choose.
      * @default "manual"
+     * @see ApplicationSettings.scale
      */
     scaleMethod: ScaleMethod;
     /**
-     * the HTML Element to be used as the reference target when using automatic scaling (by default melonJS will use the parent container of the div element containing the canvas)
+     * whether the automatically computed scale factor may be fractional, or must be a whole number of device pixels. `"fractional"` (the default) lets the canvas fill its container exactly, at the cost of source pixels landing on uneven numbers of device pixels: at a 2.667 factor some are 3 device pixels wide and some are 2, which browsers resolve differently and which pixel art shows as shimmering or uneven stems. `"integer"` rounds the factor DOWN so every source pixel covers the same whole number of device pixels, and letterboxes with whatever space is left over.
+     *
+     * Only `scaleMethod: "fit"` is affected: every other method resizes the renderer to the container, so the design resolution changes and there is no fixed factor to round. The rounding is applied in DEVICE pixels, so `devicePixelRatio` cannot reintroduce a fraction.
+     *
+     * **What it costs depends on the container, and on `devicePixelRatio`, far more than it looks.** A higher ratio has more device pixels to round among, so it lands closer to the factor it wanted. For a 480x270 design, which is exactly a quarter of 1920x1080:
+     *
+     * | container | ratio | fit | integer | presented | area lost |
+     * |---|---|---|---|---|---|
+     * | 1920x1080 | 1 or 2 | 4.000 | 4 / 8 | 1920x1080 | none |
+     * | 1440x810 | 1 | 3.000 | 3 | 1440x810 | none |
+     * | 1280x720 | 2 | 2.667 | 5 | 1200x675 | 12% |
+     * | 1280x720 | 1 | 2.667 | 2 | 960x540 | 44% |
+     * | 1366x768 | 1 | 2.844 | 2 | 960x540 | 51% |
+     *
+     * A design resolution that divides the sizes you expect costs nothing at all; one that does not can give up half the screen on a 1x display. Choose the design resolution with this in mind rather than reaching for the setting afterwards.
+     * @default "fractional"
+     */
+    scaleRounding: "fractional" | "integer";
+    /**
+     * the element automatic scaling measures to decide how much space it has. By default it is the PARENT of the container the canvas was mounted in, which is one level further out than most callers expect and is the usual cause of a canvas that does not fit its box.
+     *
+     * The case to watch for: a container that is `position: fixed` or `absolute` contributes no height to its parent, so that parent measures only whatever else it holds. If it measures `<body>`, the window size is used instead, and the canvas comes out larger than the box it lives in, cropped by whatever sits above it, by exactly the height of that other content on every resize.
+     *
+     * Name the element here when the default does not land on the box you meant, or give the canvas container a parent whose box IS that area.
+     * @see ApplicationSettings.scale
      */
     scaleTarget: HTMLElement;
     /**
@@ -83,7 +117,9 @@ export type ApplicationSettings = {
      */
     powerPreference: PowerPreference;
     /**
-     * whether to allow transparent pixels in the front buffer (screen).
+     * whether the canvas composites with the page behind it. `false`, the default, makes the front buffer opaque: the clear alpha is 1, WebGPU is configured `alphaMode: "opaque"`, and the canvas renderer clears rather than erases.
+     *
+     * Turn it on only when the page is meant to show through, since an opaque surface is the cheaper one to composite and is what a game filling its container wants. With it on the clear alpha becomes 0 and WebGPU switches to `"premultiplied"`, so anything drawn at partial alpha blends with the page rather than with a known background.
      * @default false
      */
     transparent: boolean;
@@ -100,6 +136,104 @@ export type ApplicationSettings = {
      * @default false
      */
     antiAlias: boolean;
+    /**
+     * Let the post-effect chain carry color values above 1 instead of
+     * clamping at every write.
+     *
+     * Render targets become half-float rather than 8 bits per channel, which
+     * is what gives {@link BloomEffect} genuinely over-bright pixels to
+     * threshold on and {@link ToneMappingEffect} a range to compress. Off by
+     * default, for the same reasons `antiAlias` is: it costs GPU memory, and
+     * a game gets a different pipeline depending on the driver underneath.
+     *
+     * The cost is narrow. Render targets exist only while something is
+     * actually running a multi-pass effect chain, and only the CAMERA pair
+     * takes the half-float format, at 8 bytes per pixel instead of 4. Sprite
+     * chains and the advanced-blend target stay 8-bit whatever this says. A
+     * game with no camera post-effects allocates nothing either way.
+     *
+     * **Not HDR output on its own.** This is headroom THROUGH the chain:
+     * the frame is presented in SDR, so anything still above 1 at the end
+     * clamps on the blit, exactly as it did before this setting existed. See
+     * `hdrOutput` to remove that last clamp as well, on the backends that
+     * can. Nothing is added to your effect
+     * chain, so turning this on does not restyle your game. Add a
+     * `ToneMappingEffect` to the camera if you want a curve rather than that
+     * clamp, bearing in mind that every curve maps 1 to less than 1, so a
+     * look built on clipped whites will change.
+     *
+     * Ignored where it cannot be honoured: the Canvas renderer has no render
+     * targets, and a WebGL2 driver missing either half-float extension warns
+     * once, naming which half, and stays at 8 bits. Read
+     * {@link Renderer#supportsHDR} for what you actually got, and branch a
+     * grade on that rather than on this, which is only the request.
+     * @default false
+     */
+    hdr: boolean;
+    /**
+     * Tone curve applied to the camera at the very end of its effect chain,
+     * or `"none"` to leave the frame alone.
+     *
+     * `"none"` by default, and that default is deliberate. Every curve maps 1
+     * to less than 1, so a 2D look built on clipped whites and saturated
+     * colour goes matte the moment one is applied, at any exposure. Turn it
+     * on when your art is authored in linear light and you want the
+     * highlights rolled off, not as a companion to `hdr`.
+     *
+     * Independent of `hdr`: a curve without headroom is a grade on an
+     * already-clamped frame, which is a legitimate thing to want, and
+     * headroom without a curve is the additive-accumulation win on its own.
+     * @default "none"
+     */
+    /**
+     * Present the frame in the display's full dynamic range, instead of
+     * clamping it to SDR on the way to the screen.
+     *
+     * `hdr` gives the effect chain headroom and then clamps at the very last
+     * step, because the surface the browser presents is 8 bits per channel.
+     * This changes that surface: values above 1 reach the compositor and, on
+     * a display that has the range, are actually shown brighter.
+     *
+     * **Requires `hdr`, and changes how your game looks on an HDR display.**
+     * A 2D look built on clipped whites relies on that final clamp; remove it
+     * and everything you drove above 1 gets brighter rather than saturating.
+     * That is the point, and it is why this is a separate opt-in rather than
+     * part of `hdr`.
+     *
+     * **WebGPU only.** The WebGL2 equivalent is an unapproved specification
+     * change that no browser implements, so that backend reports `false` and
+     * presents in SDR as it always has. Query
+     * {@link Renderer#supportsHDROutput} for what was granted, and expect it
+     * to differ per backend on the same machine.
+     * @default false
+     */
+    hdrOutput: boolean;
+    /**
+     * the tone curve applied at the end of the camera's chain, or `"none"` for no curve. `"aces"` is the filmic one, `"reinhard"` the gentlest, `"exponential"` the simplest.
+     *
+     * **A curve is a look decision, not a companion to {@link ApplicationSettings.hdr}.** Every curve maps 1 to less than 1, so switching one on changes a game whose art was authored against a clamp: the clipped white goes matte and the picture flattens. Turn it on for art authored in linear light, or when a deliberate grade is wanted.
+     *
+     * Changing the mode rebuilds one shader, since the curve is baked into it; {@link ApplicationSettings.toneMappingExposure} and {@link ApplicationSettings.toneMappingWhite} are uniform writes and can be driven per frame, which is what makes a settings screen or a hit flash cheap. `renderer.setToneMapping()` is the runtime entry point.
+     * @default "none"
+     * @see ApplicationSettings.toneMappingExposure
+     * @see ApplicationSettings.toneMappingWhite
+     */
+    toneMapping: "none" | "aces" | "reinhard" | "exponential";
+    /**
+     * Multiplier applied before the tone curve. Above `1` lifts the image
+     * into the curve's shoulder; below `1` pulls it down. Ignored while
+     * `toneMapping` is `"none"`.
+     * @default 1
+     */
+    toneMappingExposure: number;
+    /**
+     * The post-exposure value the tone curve should map to display white, or
+     * `0` to leave the curve its own shoulder. This is what a "brightness" or
+     * "peak" slider in a settings screen drives. Ignored while `toneMapping`
+     * is `"none"`.
+     * @default 0
+     */
+    toneMappingWhite: number;
     /**
      * Warm the renderer up during `loader.preload()`, behind the loading
      * screen, instead of paying for it on the frame that first draws (GPU
@@ -311,8 +445,13 @@ export type ApplicationSettings = {
      */
     highPrecisionShader: boolean;
     /**
-     * whether to enable sub-pixel rendering (avoid sprite flickering when using transforms)
+     * whether a renderable may sit on a fractional position WITHIN the frame. `false`, the default, snaps each translation to whole pixels, which is what stops a slowly moving or transformed sprite shimmering along its edges.
+     *
+     * The snap TRUNCATES rather than rounds, and truncates toward zero, so a value that should swing symmetrically about the origin does not: an offset travelling between -3 and +3 lands on -2 and +2, and sits at each extreme a little longer than it should. Something animating over a short distance is where this shows.
+     *
+     * It says nothing about how the frame reaches the screen. A game that snaps positions here and is then presented at a fractional scale has undone the work at the last step; {@link ApplicationSettings.scaleRounding} is what addresses that half.
      * @default false
+     * @see ApplicationSettings.scaleRounding
      */
     subPixel: boolean;
     /**

package/build/application/settings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/application/settings.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/application/settings.ts"],"names":[],"mappings":"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"}

package/build/audio/audio.d.ts

@@ -9,6 +9,9 @@
  *   `pause`, `resume`, `stop`, `fade`, `seek`, `rate`, `stereo`,
  *   `position`, `orientation`, `panner`).
  * - {@link ./procedural.ts} — procedural primitives (`tone`, `noise`).
+ * - {@link ./spatial.ts} — the world-space layer: a movable listener,
+ *   sounds that follow a renderable, and the pixel-shaped defaults.
+ * - {@link ./autopause.ts} — silencing the mix while the window is away.
  * - {@link ./types.ts} — public TypeScript shapes.
  *
  * This file owns the remaining lifecycle / track / mix / unload
@@ -16,6 +19,7 @@
  */
 export { duration, fade, load, orientation, panner, pause, play, playing, position, rate, resume, seek, state, stereo, stop, } from "./playback.ts";
 export { noise, tone } from "./procedural.ts";
+export { getSpatialDefaults, listener, listenerOrientation, setListener, setSpatialDefaults, unfollow, } from "./spatial.ts";
 export { getAudioContext, getMasterGain, setStopOnAudioError, stopOnAudioError, } from "./state.ts";
 export type { LoadSettings, NoiseFilter, NoiseOptions, PannerAttributes, SoundAsset, ToneOptions, } from "./types.ts";
 /**
@@ -65,20 +69,40 @@ export declare function enable(): void;
  */
 export declare function disable(): void;
 /**
- * Play the specified audio track. Automatically loops the clip and
- * tracks it as the current track for {@link stopTrack} / {@link pauseTrack}
- * / {@link resumeTrack}.
+ * Play the specified audio track, **replacing** whatever track was playing.
+ *
+ * The clip loops, and its name becomes the current track for
+ * {@link stopTrack} / {@link pauseTrack} / {@link resumeTrack} /
+ * {@link getCurrentTrack}. The previous track is stopped first, so only one
+ * track is ever playing: there is a single current-track slot, and a track
+ * left running after the slot had moved on could no longer be reached by any
+ * of those four.
+ *
+ * Calling it with the name already playing restarts that track from the
+ * beginning, the same as {@link play} on any other clip. Scene code that
+ * wants the bed to carry on across a screen change should not call this
+ * again, rather than rely on it doing nothing.
+ *
+ * Use {@link play} for sound effects: they are meant to overlap, and nothing
+ * here applies to them.
  * @param sound_name - Audio track name (case-sensitive).
  * @param volume - Playback volume, `0.0..1.0`. Defaults to the current
  *   global volume.
  * @returns The sound instance ID.
+ * @throws {Error} when no clip of that name is loaded, raised before anything
+ *   is stopped, so a mistyped name cannot silence the music already playing.
  * @example
- * me.audio.playTrack("awesome_music");
+ * me.audio.playTrack("menu_theme");
+ * me.audio.playTrack("battle_theme");  // the menu theme stops
  * @category Audio
  */
 export declare function playTrack(sound_name: string, volume?: number): number;
 /**
- * Stop the current audio track.
+ * Stop the current audio track, and leave no current track behind.
+ *
+ * Only needed where nothing else follows, since {@link playTrack} stops the
+ * track it replaces: a scene whose successor has no music of its own, or a
+ * game going quiet. A no-op when no track is playing.
  * @see {@link playTrack}
  * @example
  * me.audio.playTrack("awesome_music");

package/build/audio/audio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../src/audio/audio.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAcH,OAAO,EACN,QAAQ,EACR,IAAI,EACJ,IAAI,EACJ,WAAW,EACX,MAAM,EACN,KAAK,EACL,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,KAAK,EACL,MAAM,EACN,IAAI,GACJ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EACN,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,gBAAgB,GAChB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACX,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,WAAW,GACX,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,MAAM,GAAE,MAAc,GAAG,OAAO,CAGpD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,IAAI,OAAO,CAElC;AAED;;;;GAIG;AACH,wBAAgB,MAAM,IAAI,IAAI,CAE7B;AAED;;;GAGG;AACH,wBAAgB,OAAO,IAAI,IAAI,CAE9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAKhC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAIjC;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAIlC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CACnB,UAAU,EAAE,MAAM,EAClB,EAAE,CAAC,EAAE,MAAM,EACX,UAAU,GAAE,OAAc,GACxB,IAAI,CAEN;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAE5D;AAED;;;GAGG;AACH,wBAAgB,OAAO,IAAI,IAAI,CAE9B;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAEhC;AAED;;;;GAIG;AACH,wBAAgB,KAAK,IAAI,OAAO,CAE/B;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAoBlD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAMhC"}
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../src/audio/audio.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAeH,OAAO,EACN,QAAQ,EACR,IAAI,EACJ,IAAI,EACJ,WAAW,EACX,MAAM,EACN,KAAK,EACL,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,KAAK,EACL,MAAM,EACN,IAAI,GACJ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EACN,kBAAkB,EAClB,QAAQ,EACR,mBAAmB,EACnB,WAAW,EACX,kBAAkB,EAClB,QAAQ,GACR,MAAM,cAAc,CAAC;AAEtB,OAAO,EACN,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,gBAAgB,GAChB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACX,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,WAAW,GACX,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,MAAM,GAAE,MAAc,GAAG,OAAO,CAGpD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,IAAI,OAAO,CAElC;AAED;;;;GAIG;AACH,wBAAgB,MAAM,IAAI,IAAI,CAE7B;AAED;;;GAGG;AACH,wBAAgB,OAAO,IAAI,IAAI,CAE9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAsBrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAMhC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAIjC;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAIlC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CACnB,UAAU,EAAE,MAAM,EAClB,EAAE,CAAC,EAAE,MAAM,EACX,UAAU,GAAE,OAAc,GACxB,IAAI,CAEN;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAE5D;AAED;;;GAGG;AACH,wBAAgB,OAAO,IAAI,IAAI,CAE9B;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAEhC;AAED;;;;GAIG;AACH,wBAAgB,KAAK,IAAI,OAAO,CAE/B;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAsBlD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAOhC"}

package/build/audio/autopause.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Silence the game's sound effects while the window does not have focus.
+ *
+ * `Application` pauses the game on blur and resumes it on focus (its
+ * `pauseOnBlur` / `resumeOnFocus` settings, both on by default), and
+ * `state.pause()` already pauses the MUSIC TRACK. Nothing ever silenced the
+ * sound effects, so a looping one — an engine hum, an alarm, ambience — kept
+ * playing over whatever the player switched to.
+ *
+ * Driven from `Application#_onBlur` / `_onFocus` rather than from
+ * `STATE_PAUSE`, deliberately. A state pause is not always a focus loss:
+ * `state.freeze()` forwards its `music` flag into `state.pause()` for a
+ * hit-stop measured in tens of milliseconds, and muting there would punch a
+ * hole in the very impact sound the freeze exists to emphasise. A game's own
+ * pause menu is the same story, and would lose its UI clicks. Focus loss is
+ * the case where silence is unambiguously right.
+ *
+ * Driving it from the application also means the existing `stopOnBlur` /
+ * `pauseOnBlur` / `resumeOnFocus` settings gate it, instead of a fourth
+ * setting that says almost the same thing. A game that opted out of pausing
+ * in the background is a game that wants to keep running there, audio
+ * included.
+ *
+ * MUTED rather than stopped or paused:
+ *
+ * - stopping discards playback ids, and an id is the handle a game holds to
+ *   reposition or fade a sound, so a loop could never be resumed in place;
+ * - per-voice pausing would have to be taught about every source in turn, and
+ *   would miss the procedural `tone` / `noise` primitives and anything a game
+ *   hangs off `getMasterGain()`;
+ * - muting zeroes the master gain, which everything routes through, and it
+ *   lets a short one-shot finish silently instead of queueing up to fire the
+ *   moment the player comes back.
+ */
+export {};
+//# sourceMappingURL=autopause.d.ts.map

package/build/audio/autopause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autopause.d.ts","sourceRoot":"","sources":["../../src/audio/autopause.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG"}

package/build/audio/backend/engine.d.ts

@@ -1,5 +1,5 @@
+import { AudioContextOwner } from "../context.ts";
 import type { Sound } from "./sound.ts";
-import { type HTMLAudioElementWithUnlocked } from "./types.ts";
 export declare class AudioEngine {
     html5PoolSize: number;
     sounds: Sound[];
@@ -10,6 +10,15 @@ export declare class AudioEngine {
     ctx: AudioContext | null;
     autoUnlock: boolean;
     state: string;
+    /**
+     * The single owner of the context: see `../context.ts`.
+     *
+     * The engine no longer creates listeners for keeping the context alive,
+     * nor decides when a stop should be reverted. It answers the owner's two
+     * questions and does the reviving, which is the part only it can do
+     * because only it has the voices waiting on the result.
+     */
+    readonly contextOwner: AudioContextOwner;
     constructor();
     volume(vol?: number): number | this;
     mute(muted: boolean): this;

package/build/audio/backend/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/audio/backend/engine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EACN,KAAK,4BAA4B,EAGjC,MAAM,YAAY,CAAC;AAEpB,qBAAa,WAAW;IAWvB,aAAa,EAAE,MAAM,CAAM;IAM3B,MAAM,EAAE,KAAK,EAAE,CAAM;IAqBrB,UAAU,EAAE,QAAQ,GAAG,IAAI,CAAQ;IACnC,OAAO,EAAE,OAAO,CAAS;IACzB,aAAa,EAAE,OAAO,CAAQ;IAC9B,WAAW,EAAE,OAAO,CAAQ;IAC5B,GAAG,EAAE,YAAY,GAAG,IAAI,CAAQ;IAChC,UAAU,EAAE,OAAO,CAAQ;IAC3B,KAAK,EAAE,MAAM,CAAe;;IAqD5B,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAoCnC,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IA2B1B,IAAI,IAAI,IAAI;IAQZ,MAAM,IAAI,IAAI;IAkBd,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B;;;;;;;;;;;;;OAaG;IACH,aAAa,IAAI,YAAY,GAAG,IAAI;IAmCpC,MAAM,IAAI,IAAI;IAmCd,YAAY,IAAI,IAAI;IAqEpB,YAAY,IAAI,IAAI;IAiGpB,iBAAiB,IAAI,4BAA4B;IAoCjD,kBAAkB,CAAC,KAAK,EAAE,4BAA4B,GAAG,IAAI;IAQ7D,YAAY,IAAI,IAAI;IA6CpB,WAAW,IAAI,IAAI;CAsDnB"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/audio/backend/engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EACN,KAAK,4BAA4B,EAGjC,MAAM,YAAY,CAAC;AAEpB,qBAAa,WAAW;IAWvB,aAAa,EAAE,MAAM,CAAM;IAM3B,MAAM,EAAE,KAAK,EAAE,CAAM;IAqBrB,UAAU,EAAE,QAAQ,GAAG,IAAI,CAAQ;IACnC,OAAO,EAAE,OAAO,CAAS;IACzB,aAAa,EAAE,OAAO,CAAQ;IAC9B,WAAW,EAAE,OAAO,CAAQ;IAC5B,GAAG,EAAE,YAAY,GAAG,IAAI,CAAQ;IAChC,UAAU,EAAE,OAAO,CAAQ;IAC3B,KAAK,EAAE,MAAM,CAAe;IAM5B;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAKrC;;IA2CH,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAoCnC,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IA2B1B,IAAI,IAAI,IAAI;IAQZ,MAAM,IAAI,IAAI;IAmBd,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B;;;;;;;;;;;;;OAaG;IACH,aAAa,IAAI,YAAY,GAAG,IAAI;IAoCpC,MAAM,IAAI,IAAI;IAmCd,YAAY,IAAI,IAAI;IAqEpB,YAAY,IAAI,IAAI;IAmGpB,iBAAiB,IAAI,4BAA4B;IAoCjD,kBAAkB,CAAC,KAAK,EAAE,4BAA4B,GAAG,IAAI;IAQ7D,YAAY,IAAI,IAAI;IAwCpB,WAAW,IAAI,IAAI;CAyEnB"}

package/build/audio/backend/sound.d.ts

@@ -1,5 +1,4 @@
 import { type HTMLAudioElementWithUnlocked, type SoundOptions } from "./types.ts";
-import { Voice } from "./voice.ts";
 declare class Sound {
     constructor(o: SoundOptions);
     init(o: SoundOptions): this;

package/build/audio/backend/sound.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sound.d.ts","sourceRoot":"","sources":["../../../src/audio/backend/sound.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sound.d.ts","sourceRoot":"","sources":["../../../src/audio/backend/sound.ts"],"names":[],"mappings":"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"}