melonjs 20.3.0 → 20.4.0

package/build/video/canvas/canvas_renderer.d.ts

@@ -16,8 +16,6 @@
 export default class CanvasRenderer extends Renderer {
     cache: TextureCache;
     onGameReset: () => void;
-    _lightCache: WeakMap<object, any> | undefined;
-    _frameTexture: any;
     /**
      * set/change the current projection matrix.
      * In Canvas mode, this applies the ortho projection as a canvas 2D transform
@@ -126,9 +124,6 @@ export default class CanvasRenderer extends Renderer {
      * @param {Mesh} mesh - a Mesh renderable or compatible object
      */
     drawMesh(mesh: Mesh): void;
-    _meshColorCanvas: HTMLCanvasElement | OffscreenCanvas | undefined;
-    _meshColorCtx: RenderingContext | OffscreenCanvasRenderingContext2D | null | undefined;
-    _meshSortBuf: Float64Array<ArrayBuffer> | undefined;
     /**
      * starts a new path by emptying the list of sub-paths. Call this method when you want to create a new path
      * @example
@@ -197,9 +192,9 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} y - The y axis of the coordinate for the rectangle starting point.
      * @param {number} width - The rectangle's width.
      * @param {number} height - The rectangle's height.
-     * @param {number} radius - The corner radius.
+     * @param {number} radii - The corner radius.
      */
-    roundRect(x: number, y: number, width: number, height: number, radii: any): void;
+    roundRect(x: number, y: number, width: number, height: number, radii: number): void;
     /**
      * stroke the given shape or the current defined path
      * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to stroke
@@ -284,8 +279,6 @@ export default class CanvasRenderer extends Renderer {
      * Draw a point at the specified coordinates
      * @param {number} x
      * @param {number} y
-     * @param {number} width
-     * @param {number} height
      */
     fillPoint(x: number, y: number): void;
     /**
@@ -293,10 +286,6 @@ export default class CanvasRenderer extends Renderer {
      * @returns {number} global alpha value
      */
     getGlobalAlpha(): number;
-    /**
-     * @ignore
-     */
-    set lineJoin(value: string);
     /**
      * sets or returns the shape used to join two line segments where they meet.
      * There are three possible values for this property: "round", "bevel", and "miter"
@@ -326,16 +315,6 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} [f] - the f component to multiply the current matrix by; omitted when `a` is a matrix
      */
     transform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
-    /**
-     * A mask limits rendering elements to the shape and position of the given mask object.
-     * If the drawing or rendering area is larger than the mask, only the intersecting part of the renderable will be visible.
-     * (Note Mask are not preserved through renderer context save and restore and need so be manually cleared)
-     * @see CanvasRenderer#clearMask
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - the shape defining the mask to be applied
-     * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
-     */
-    setMask(mask?: Rect | RoundRect | Polygon | Line | Ellipse, invert?: boolean): void;
-    _maskInvertOuterAdded: boolean | undefined;
 }
 import Renderer from "./../renderer.js";
 import TextureCache from "./../texture/cache.js";

package/build/video/canvas/canvas_renderer.d.ts.map

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

package/build/video/canvas_factory.d.ts

@@ -1,25 +1,2 @@
-/**
- * Create and return a new Canvas element (or `OffscreenCanvas` when
- * supported and `returnOffscreenCanvas` is true). The single low-level
- * allocator used by every renderer-side scratch / fallback / render-
- * target canvas in the engine.
- *
- * Lives in its own module (not on `Renderer` directly) to break the
- * circular dependency between `Renderer` and `CanvasRenderTarget` —
- * both can import this helper without referencing each other.
- * `Renderer.createCanvas` re-exposes it as a static method for the
- * public-facing API; internal callers can import it directly.
- *
- * Gates the OffscreenCanvas path on `device.offscreenCanvas` (the
- * vetted capability check — actually instantiates + verifies
- * `getContext("2d")` works inside a try/catch, covering historical
- * Safari quirks).
- * @param {number} width - canvas width in pixels
- * @param {number} height - canvas height in pixels
- * @param {boolean} [returnOffscreenCanvas=false] - return an
- *   `OffscreenCanvas` if the platform supports it
- * @returns {HTMLCanvasElement|OffscreenCanvas} a new canvas of the given size
- * @ignore
- */
-export function createCanvas(width: number, height: number, returnOffscreenCanvas?: boolean): HTMLCanvasElement | OffscreenCanvas;
+
 //# sourceMappingURL=canvas_factory.d.ts.map

package/build/video/canvas_factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvas_factory.d.ts","sourceRoot":"","sources":["../../src/video/canvas_factory.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,oCAPW,MAAM,UACN,MAAM,0BACN,OAAO,GAEL,iBAAiB,GAAC,eAAe,CAsB7C"}
+{"version":3,"file":"canvas_factory.d.ts","sourceRoot":"","sources":["../../src/video/canvas_factory.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oCARW,MAAM,UACN,MAAM,0BACN,OAAO,GAEL,iBAAiB,GAAC,eAAe,CAuB7C"}

package/build/video/effects/blendEffect.d.ts

@@ -1,57 +1,3 @@
 export const wgslFragment: "\nstruct BlendUniforms {\n\tuBlendMode : f32,\n};\n@group(3) @binding(0) var<uniform> fx : BlendUniforms;\n@group(3) @binding(1) var backdrop : texture_2d<f32>;\n@group(3) @binding(2) var backdrop_sampler : sampler;\n\n// HardLight(Cb, Cs) \u2014 also the kernel for Overlay, which the W3C spec\n// defines as HardLight with the arguments swapped\nfn ME_hardLight(b : vec3f, s : vec3f) -> vec3f {\n\tlet lo = 2.0 * b * s;\n\tlet hi = 1.0 - 2.0 * (1.0 - b) * (1.0 - s);\n\treturn mix(lo, hi, step(vec3f(0.5), s));\n}\n\nfn ME_softLight(b : vec3f, s : vec3f) -> vec3f {\n\tlet d = mix(((16.0 * b - 12.0) * b + 4.0) * b, sqrt(b), step(vec3f(0.25), b));\n\tlet lo = b - (1.0 - 2.0 * s) * b * (1.0 - b);\n\tlet hi = b + (2.0 * s - 1.0) * (d - b);\n\treturn mix(lo, hi, step(vec3f(0.5), s));\n}\n\n// Cb == 0 wins over Cs == 1, so it is applied last\nfn ME_colorDodge(b : vec3f, s : vec3f) -> vec3f {\n\tvar r = min(vec3f(1.0), b / max(1.0 - s, vec3f(1e-4)));\n\tr = mix(r, vec3f(1.0), step(vec3f(1.0), s));\n\treturn mix(r, vec3f(0.0), step(b, vec3f(0.0)));\n}\n\n// Cb == 1 wins over Cs == 0, so it is applied last\nfn ME_colorBurn(b : vec3f, s : vec3f) -> vec3f {\n\tvar r = 1.0 - min(vec3f(1.0), (1.0 - b) / max(s, vec3f(1e-4)));\n\tr = mix(r, vec3f(0.0), step(s, vec3f(0.0)));\n\treturn mix(r, vec3f(1.0), step(vec3f(1.0), b));\n}\n\nfn ME_blend(b : vec3f, s : vec3f) -> vec3f {\n\tif (fx.uBlendMode < 0.5) { return abs(b - s); }\n\tif (fx.uBlendMode < 1.5) { return ME_hardLight(s, b); }\n\tif (fx.uBlendMode < 2.5) { return ME_hardLight(b, s); }\n\tif (fx.uBlendMode < 3.5) { return ME_colorDodge(b, s); }\n\tif (fx.uBlendMode < 4.5) { return ME_colorBurn(b, s); }\n\tif (fx.uBlendMode < 5.5) { return ME_softLight(b, s); }\n\tif (fx.uBlendMode < 6.5) { return min(b, s); }\n\treturn max(b, s);\n}\n\nfn apply(color : vec4f, uv : vec2f) -> vec4f {\n\t// sampled BEFORE any branch, so plain textureSampleLevel is safe here\n\tlet Cb = textureSampleLevel(backdrop, backdrop_sampler, screen_uv, 0.0).rgb;\n\tlet a = color.a;\n\tlet Cs = color.rgb / max(a, 1e-4);\n\tlet B = clamp(ME_blend(Cb, Cs), vec3f(0.0), vec3f(1.0));\n\treturn vec4f(a * B, a);\n}\n";
-/**
- * The compositing shader behind the six CSS blend modes that fixed-function
- * blending cannot express: `overlay`, `hard-light`, `color-dodge`,
- * `color-burn`, `soft-light` and `difference`.
- *
- * Internal — owned by the renderer, one instance per renderer, never
- * constructed or configured by user code. A game selects a mode the ordinary
- * way (`sprite.blendMode = "overlay"`, or `renderer.setBlendMode("overlay")`)
- * and the renderer drives this effect from there.
- *
- * ### How it composites
- *
- * The renderer captures the destination, renders the draw to an offscreen
- * target, then blits that target through this effect. Everything arriving in
- * `color` is PREMULTIPLIED (the offscreen was drawn source-over into a
- * transparent clear), while the W3C formulas are defined on straight colour —
- * so the body un-premultiplies, blends, and re-premultiplies.
- *
- * Emitting premultiplied and letting ordinary source-over run the composite
- * yields `as*B + (1-as)*Cb` and a correct output alpha for free. It also keeps
- * the premultiplied invariant `rgb <= a` — a texel with `rgb > a` is undefined
- * and diverges across browsers — which is why `B` is clamped even though all
- * six formulas land in `[0,1]` analytically.
- *
- * The backdrop is treated as opaque (`ab = 1`). The GL capture is an RGB
- * texture so that is true by construction there; the WebGPU capture preserves
- * alpha and is deliberately ignored, so the two backends agree.
- *
- * ### Why not the `: screen_texture` builtin
- *
- * That annotation wires the sampler to the renderer's SHARED capture slot,
- * which `drawImage` already refreshes on behalf of any custom shader that
- * samples the screen. A renderable carrying an advanced blend mode AND a
- * screen-sampling {@link ShaderEffect} would then have the two fighting over
- * one texture. This declares a plain sampler instead and the renderer binds
- * its own capture, so the two are independent. Referencing `screen_uv` still
- * activates that varying on its own.
- * @see {@link https://www.w3.org/TR/compositing-1/#blending}
- * @ignore
- */
-export default class BlendEffect extends ShaderEffect {
-    /**
-     * @param {import("../webgl/webgl_renderer.js").default|import("../webgpu/webgpu_renderer.js").default} renderer - the renderer that owns this effect
-     */
-    constructor(renderer: import("../webgl/webgl_renderer.js").default | import("../webgpu/webgpu_renderer.js").default);
-    /**
-     * Select which of the six formulas the shader evaluates.
-     * @param {string} mode - one of the modes in {@link ADVANCED_BLEND_MODES}
-     * @returns {boolean} false when the mode is not an advanced blend mode, in
-     * which case the uniform is left untouched
-     * @ignore
-     */
-    setBlendMode(mode: string): boolean;
-}
 import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=blendEffect.d.ts.map

package/build/video/effects/blendEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blendEffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/blendEffect.js"],"names":[],"mappings":"AAgBA,soEAwDE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IACC;;OAEG;IACH,sBAFW,OAAO,4BAA4B,EAAE,OAAO,GAAC,OAAO,8BAA8B,EAAE,OAAO,EA4DrG;IAED;;;;;;OAMG;IACH,mBALW,MAAM,GACJ,OAAO,CAWnB;CACD;yBAhMwB,mBAAmB"}
+{"version":3,"file":"blendEffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/blendEffect.js"],"names":[],"mappings":"AAgBA,soEAwDE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IACC;;OAEG;IACH,sBAFW,OAAO,4BAA4B,EAAE,OAAO,GAAC,OAAO,8BAA8B,EAAE,OAAO,EA4DrG;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,GACJ,OAAO,CAYnB;CACD;yBAlMwB,mBAAmB"}

package/build/video/effects/colorMatrix.d.ts

@@ -22,16 +22,6 @@ export default class ColorMatrixEffect extends ShaderEffect {
     constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         matrix?: ColorMatrix | undefined;
     });
-    /**
-     * the internal color matrix
-     * @ignore
-     */
-    _matrix: ColorMatrix;
-    /**
-     * Push the current matrix values to the GPU.
-     * @ignore
-     */
-    _syncUniform(): void;
     /**
      * Reset the color matrix to identity (no color change).
      * @returns {this} this instance for chaining

package/build/video/effects/colorMatrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../src/video/effects/colorMatrix.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA8B,MAAM;KACtC,EAkBA;IANA;;;OAGG;IACH,qBAAkD;IAInD;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,WAAW,GACT,IAAI,CAMhB;IAED;;;;;OAKG;IACH,mBAHc,MAAM,EAAA,GACP,IAAI,CAMhB;CACD;yBAjKwB,mBAAmB;4BADhB,4BAA4B"}
+{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../src/video/effects/colorMatrix.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA8B,MAAM;KACtC,EAmBA;IAPA;;;;OAIG;IACH,qBAAkD;IAInD;;;;OAIG;IACH,qBAEC;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,WAAW,GACT,IAAI,CAMhB;IAED;;;;;OAKG;IACH,mBAHc,MAAM,EAAA,GACP,IAAI,CAMhB;CACD;yBAnKwB,mBAAmB;4BADhB,4BAA4B"}

package/build/video/effects/glsl_realization.d.ts

@@ -1,18 +1,2 @@
-/**
- * Assemble the complete GLSL program sources for a ShaderEffect fragment
- * body: parse the builtins, build the vertex variant, and wrap the user's
- * `apply()` with the texture-sampling boilerplate.
- * @param {string} fragmentBody - the user body (GLSL, `vec4 apply(vec4, vec2)` convention)
- * @returns {{vertex: string, fragment: string, screenTextures: Array<{name: string, repeat: string}>, noiseUV: boolean}} the assembled sources + builtin usage
- * @ignore
- */
-export function buildGLSLProgram(fragmentBody: string): {
-    vertex: string;
-    fragment: string;
-    screenTextures: Array<{
-        name: string;
-        repeat: string;
-    }>;
-    noiseUV: boolean;
-};
+
 //# sourceMappingURL=glsl_realization.d.ts.map

package/build/video/effects/glsl_realization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glsl_realization.js"],"names":[],"mappings":"AAiHA;;;;;;;GAOG;AACH,+CAJW,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CA6BvH"}
+{"version":3,"file":"glsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glsl_realization.js"],"names":[],"mappings":"AAoHA;;;;;;;;GAQG;AACH,+CALW,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CA8BvH"}

package/build/video/effects/radialGradient.d.ts

@@ -85,7 +85,6 @@ export default class RadialGradientEffect extends ShaderEffect {
         color?: Color | undefined;
         intensity?: number | undefined;
     });
-    _colorBuf: Float32Array<ArrayBuffer>;
     /**
      * Set the center color. RGB only — alpha is ignored (the radial
      * falloff supplies the per-pixel alpha).

package/build/video/effects/radialGradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../src/video/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,+CAHG;QAAwB,KAAK;QACJ,SAAS;KACpC,EA2DA;IAZA,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBAtKwB,mBAAmB;2BAIlB,qBAAqB"}
+{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../src/video/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,+CAHG;QAAwB,KAAK;QACJ,SAAS;KACpC,EA+DA;IAhBA;;;OAGG;IACH,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBA1KwB,mBAAmB;2BAIlB,qBAAqB"}

package/build/video/effects/shadereffect.d.ts

@@ -170,55 +170,6 @@ export default class ShaderEffect {
      * @default false
      */
     shared: boolean;
-    /**
-     * the renderer this effect was created for — kept so destroy and
-     * context-loss can release the texture units reserved on its cache
-     * for extra samplers ({@link setTexture}), and so {@link clone} can
-     * compile an independent copy
-     * @ignore
-     */
-    _renderer: any;
-    /**
-     * the construction "recipe" (body + precision), kept VERBATIM so
-     * {@link clone} can compile an independent copy. Stored before the
-     * disabled-stub early return so cloning behaves consistently there too.
-     * @ignore
-     */
-    _fragmentBody: string | {
-        glsl?: string;
-        wgsl?: string;
-    };
-    /** @ignore */
-    _precision: string | undefined;
-    /**
-     * extra texture samplers bound via {@link setTexture}, keyed by the
-     * uniform name → `{ image, repeat, tex }` (`tex` is the uploaded GL
-     * texture, created lazily on first draw; unused on WebGPU, where the
-     * bind group is built lazily instead)
-     * @ignore
-     */
-    _extraTextures: Map<any, any> | undefined;
-    /**
-     * samplers annotated `: screen_texture` — the renderer checks this to
-     * know when to refresh the shared frame capture before the effect draws
-     * @type {Array<{name: string, repeat: string}>}
-     * @ignore
-     */
-    _screenTextureUniforms: Array<{
-        name: string;
-        repeat: string;
-    }>;
-    /** @ignore */
-    _hasNoiseUV: any;
-    /** @ignore */
-    _shader: GLShader | undefined;
-    /** @ignore */
-    wgslRealization: WGSLEffectRealization | undefined;
-    /** @private */
-    private _onContextLost;
-    _enabledBeforeSuspend: boolean | undefined;
-    /** @private */
-    private _onContextRestored;
     /**
      * Set the uniform to the given value
      * @param {string} name - the uniform name
@@ -249,43 +200,6 @@ export default class ShaderEffect {
      * flow.setTime(me.timer.getTime() / 1000);
      */
     setTime(seconds: number): ShaderEffect;
-    /**
-     * Feed the UV y-direction of the space `apply()` is about to run in:
-     * `+1` where `uv.y` grows downward (direct sprite sampling, and every
-     * WebGPU path), `-1` on the WebGL pooled-blit path, whose capture FBOs
-     * are bottom-up — there, y-directional UV arithmetic inside a body
-     * runs vertically mirrored unless compensated. Directional bodies
-     * (DropShadow) declare a `uUVYDir` uniform and multiply their y
-     * offsets with it, so "down" means down on every path of every
-     * backend. A silent no-op for bodies that don't declare the uniform.
-     * @param {number} dir - +1 (uv.y grows downward) or -1 (upward)
-     * @ignore
-     */
-    _setUVYDir(dir: number): void;
-    _uvYDir: any;
-    /**
-     * Feed the `noise_uv` builtin's frame rect for the object about to draw:
-     * the source texture dimensions, the destination (object) dimensions, and
-     * the frame's top-left UV origin. Called by the quad batchers per draw;
-     * a no-op unless this effect's fragment actually uses `noise_uv` (the
-     * `ME_*` uniforms only exist — and are only active — then).
-     * @param {number} sourceWidth - source texture width in pixels
-     * @param {number} sourceHeight - source texture height in pixels
-     * @param {number} objectWidth - destination (object) width in pixels
-     * @param {number} objectHeight - destination (object) height in pixels
-     * @param {number} u0 - the frame's left UV coordinate (flip-normalized)
-     * @param {number} v0 - the frame's top UV coordinate (flip-normalized)
-     * @ignore
-     */
-    _setNoiseUVRect(sourceWidth: number, sourceHeight: number, objectWidth: number, objectHeight: number, u0: number, v0: number): void;
-    /**
-     * Apply the wrap mode a `: screen_texture(<repeat>)` annotation asked for
-     * onto the live capture handle. The unit is force-activated first: the
-     * batcher's bind may have been skipped as redundant while the GL active
-     * unit points elsewhere.
-     * @ignore
-     */
-    _applyCaptureWrap(batcher: any, glTex: any, entry: any): void;
     /**
      * Bind an **extra** texture to a named `sampler2D` uniform in this shader, so
      * a custom effect can read a *second* texture — a noise map, mask, gradient,
@@ -318,17 +232,6 @@ export default class ShaderEffect {
      * water.setTime(me.timer.getTime() / 1000);
      */
     setTexture(name: string, image: Texture2d | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, repeat?: "repeat" | "repeat-x" | "repeat-y" | "no-repeat"): ShaderEffect;
-    /**
-     * (Re)bind this effect's extra textures ({@link setTexture}) to reserved GL
-     * texture units and point their sampler uniforms at them. Called by the
-     * renderer right after this effect's shader is bound — for both the
-     * post-effect blit and the single-effect `customShader` sprite path — so the
-     * bindings survive the batcher's rotating color-texture pool.
-     * @param {object} batcher - the active batcher (owns the GL texture units)
-     * @ignore
-     */
-    _prepareTextures(batcher: object): void;
-    _textureOverflowWarned: boolean | undefined;
     /**
      * Create an independent copy of this effect, compiled as its own GL
      * program. Use it when several renderables need the same effect with
@@ -355,22 +258,6 @@ export default class ShaderEffect {
      * bossFlash.setUniform("uIntensity", 0.9);
      */
     clone(): ShaderEffect;
-    /** @ignore */
-    bind(): void;
-    /** @ignore */
-    getAttribLocation(name: any): number;
-    /** @ignore */
-    setVertexAttributes(gl: any, attributes: any, stride: any): void;
-    /** @ignore */
-    get program(): WebGLProgram | null;
-    /** @ignore */
-    get vertex(): any;
-    /** @ignore */
-    get fragment(): any;
-    /** @ignore */
-    get attributes(): {};
-    /** @ignore */
-    get uniforms(): object;
     /**
      * destroy this shader effect. Idempotent — calling destroy twice
      * is safe. Unsubscribes from the renderer's context-lost / restored

package/build/video/effects/shadereffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH;IAiCC;;;;;;;;;;;OAWG;IACH,sBAXW,aAAa,GAAC,cAAc,GAAC,cAAc,QAC3C,MAAM,GAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,cAQrC,MAAM,EAqHhB;IA/JD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAed;;;;;;OAMG;IACH,eAAyB;IAEzB;;;;;OAKG;IACH;eA1ByB,MAAM;eAAS,MAAM;MA0BrB;IACzB,cAAc;IACd,+BAA2B;IAoB3B;;;;;;OAMG;IACH,0CAA+B;IAQ9B;;;;;OAKG;IACH,wBAHU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAGK;IACpD,cAAc;IACd,iBAAkC;IAElC,cAAc;IACd,8BAKC;IAyBD,cAAc;IACd,mDAAkC;IAsBpC,eAAe;IACf,uBAkBC;IAbA,2CAAyC;IAe1C,eAAe;IACf,2BAQC;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,GAAC,YAAY,QAmB7B;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CAuCxB;IAED;;;;;;;;;;;OAWG;IACH,gBAHW,MAAM,QAqBhB;IATC,aAAkB;IAWpB;;;;;;;;;;;;;OAaG;IACH,6BARW,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,MACN,MAAM,MACN,MAAM,QAoDhB;IAED;;;;;;OAMG;IACH,8DAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAnBW,MAAM,SACN,SAAS,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,WACxE,QAAQ,GAAC,UAAU,GAAC,UAAU,GAAC,WAAW,GACxC,YAAY,CA0GxB;IAED;;;;;;;;OAQG;IACH,0BAHW,MAAM,QA2FhB;IA3DI,4CAAkC;IA6DvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SATa,YAAY,CAsDxB;IAKD,cAAc;IACd,aAIC;IAED,cAAc;IACd,qCAIC;IAED,cAAc;IACd,iEAIC;IAED,cAAc;IACd,mCAEC;IAED,cAAc;IACd,kBAEC;IAED,cAAc;IACd,oBAEC;IAED,cAAc;IACd,qBAEC;IAED,cAAc;IACd,uBAEC;IAED;;;;OAIG;IACH,gBAyCC;CACD;qBA74BoB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}
+{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH;IAiCC;;;;;;;;;;;OAWG;IACH,sBAXW,aAAa,GAAC,cAAc,GAAC,cAAc,QAC3C,MAAM,GAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,cAQrC,MAAM,EAqIhB;IA/KD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAed;;;;;;;OAOG;IACH,eAAyB;IAEzB;;;;;;OAMG;IACH;eA5ByB,MAAM;eAAS,MAAM;MA4BrB;IACzB;;;OAGG;IACH,+BAA2B;IAoB3B;;;;;;;OAOG;IACH,0CAA+B;IAQ9B;;;;;;OAMG;IACH,wBAJU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAIK;IACpD;;;OAGG;IACH,iBAAkC;IAElC;;;OAGG;IACH,8BAKC;IAyBD;;;OAGG;IACH,mDAAkC;IAsBpC;;;;OAIG;IACH,uBAsBC;IAjBA;;;OAGG;IACH,2CAAyC;IAe1C;;;;OAIG;IACH,2BAQC;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,GAAC,YAAY,QAmB7B;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CAuCxB;IAED;;;;;;;;;;;;OAYG;IACH,gBAJW,MAAM,QA0BhB;IAbC;;;OAGG;IACH,aAAkB;IAWpB;;;;;;;;;;;;;;OAcG;IACH,6BATW,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,MACN,MAAM,MACN,MAAM,QAqDhB;IAED;;;;;;;OAOG;IACH,8DAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAnBW,MAAM,SACN,SAAS,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,WACxE,QAAQ,GAAC,UAAU,GAAC,UAAU,GAAC,WAAW,GACxC,YAAY,CA0GxB;IAED;;;;;;;;;OASG;IACH,0BAJW,MAAM,QAgGhB;IA/DI;;;OAGG;IACH,4CAAkC;IA6DvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SATa,YAAY,CAsDxB;IAKD;;;OAGG;IACH,aAIC;IAED;;;OAGG;IACH,qCAIC;IAED;;;OAGG;IACH,iEAIC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,kBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAyCC;CACD;qBA78BoB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}

package/build/video/effects/wgsl/layout.d.ts

@@ -1,28 +1,2 @@
-/**
- * normalize the `vecN<f32>` / `matCxR<f32>` spellings onto the short forms
- * used as TYPE_LAYOUT keys
- * @param {string} type - a WGSL type token
- * @returns {string} the canonical spelling
- * @ignore
- */
-export function normalizeWGSLType(type: string): string;
-/**
- * Compute the uniform-buffer layout for a parsed struct member list.
- * @param {Array<{name: string, type: string}>} members - struct members in declaration order
- * @returns {{map: Map<string, {offset: number, size: number, type: string}>, size: number}|null}
- *   the name → placement map and the total (16-byte-rounded) struct size,
- *   or `null` when a member type is unsupported
- * @ignore
- */
-export function computeUniformLayout(members: Array<{
-    name: string;
-    type: string;
-}>): {
-    map: Map<string, {
-        offset: number;
-        size: number;
-        type: string;
-    }>;
-    size: number;
-} | null;
+
 //# sourceMappingURL=layout.d.ts.map

package/build/video/effects/wgsl/layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/layout.js"],"names":[],"mappings":"AAqCA;;;;;;GAMG;AACH,wCAJW,MAAM,GACJ,MAAM,CAQlB;AAUD;;;;;;;GAOG;AACH,8CANW,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,GACjC;IAAC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAC,IAAI,CAuB/F"}
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/layout.js"],"names":[],"mappings":"AAuCA;;;;;;;GAOG;AACH,wCALW,MAAM,GACJ,MAAM,CASlB;AAWD;;;;;;;;GAQG;AACH,8CAPW,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,GACjC;IAAC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAC,IAAI,CAwB/F"}

package/build/video/effects/wgsl/parse.d.ts

@@ -1,9 +1,2 @@
-/**
- * Parse a WGSL effect body's declarations.
- * @param {string} body - the user WGSL body
- * @returns {object} `{ok: true, layout, structSize, uniformVar, textures, builtins, maxUserBinding}`
- *   or `{ok: false, error}`
- * @ignore
- */
-export function parseWGSLBody(body: string): object;
+
 //# sourceMappingURL=parse.d.ts.map

package/build/video/effects/wgsl/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/parse.js"],"names":[],"mappings":"AAoHA;;;;;;GAMG;AACH,oCALW,MAAM,GACJ,MAAM,CAqKlB"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/parse.js"],"names":[],"mappings":"AAwHA;;;;;;;GAOG;AACH,oCANW,MAAM,GACJ,MAAM,CAsKlB"}

package/build/video/effects/wgsl/scaffold.d.ts

@@ -1,43 +1,2 @@
-/**
- * WGSL module assembly for a ShaderEffect body — the WGSL counterpart of
- * `glsl_realization.js`'s source templating. The user body is embedded
- * VERBATIM (WGSL module-scope declarations are order-independent); the
- * scaffold contributes the vertex/fragment entry points over the frozen
- * 28-byte quad layout, the frame-globals and material groups, and the
- * builtin declarations the parser detected.
- *
- * Frozen conventions carried over from the core quad shader:
- * - clip-z remap `(z + w) * 0.5` (GL-convention [-w, w] → WebGPU [0, w])
- * - packed-ARGB attribute read as (B,G,R,A) → `.bgr * .a` premultiply
- * - `screen_uv` is y-down (`0.5 - ndc.y * 0.5`): WebGPU texture row 0 is
- *   the top, so the capture is sampled without any flip
- * @ignore
- */
-/**
- * builtin group-3 bindings are assigned ABOVE the highest user binding so
- * they can never collide: ME uniform first, then the capture texture and
- * its sampler variants
- * @param {object} parsed - the parseWGSLBody result
- * @returns {{me: number, screenTexture: number, screenSamplerClamp: number, screenSamplerRepeat: number}}
- *   assigned binding indices (-1 when the builtin is unused)
- * @ignore
- */
-export function assignBuiltinBindings(parsed: object): {
-    me: number;
-    screenTexture: number;
-    screenSamplerClamp: number;
-    screenSamplerRepeat: number;
-};
-/**
- * Assemble the complete WGSL module for an effect body.
- * @param {string} body - the user WGSL body (embedded verbatim)
- * @param {object} parsed - the parseWGSLBody result
- * @returns {{code: string, bindings: object}} the module text and the
- *   builtin binding assignment (consumed when building the bind group)
- * @ignore
- */
-export function buildWGSLModule(body: string, parsed: object): {
-    code: string;
-    bindings: object;
-};
+
 //# sourceMappingURL=scaffold.d.ts.map

package/build/video/effects/wgsl/scaffold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/scaffold.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;GAQG;AACH,8CALW,MAAM,GACJ;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAA;CAAC,CA0BxG;AAED;;;;;;;GAOG;AACH,sCANW,MAAM,UACN,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAyG5C"}
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/scaffold.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;GASG;AACH,8CANW,MAAM,GACJ;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAA;CAAC,CA2BxG;AAED;;;;;;;;GAQG;AACH,sCAPW,MAAM,UACN,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA0G5C"}

package/build/video/effects/wgsl_realization.d.ts

@@ -1,83 +1,2 @@
-/**
- * The WGSL realization of a ShaderEffect — the WebGPU counterpart of the
- * GLShader the GLSL branch compiles.
- *
- * WebGPU has no uniform reflection, so this object carries everything the
- * backend needs to drive the effect: the parsed uniform layout (name →
- * byte placement), a CPU-side mirror of the uniform block that
- * `setUniform` writes into, the texture binding table, and the assembled
- * module text. GPU objects (shader module, bind group layout, bind group)
- * are built lazily by the renderer's effect path — uniform VALUES are
- * snapshotted from the mirror into a per-frame arena at every bind, so a
- * shared effect bound twice in a frame with different values stays
- * correct under WebGPU's queue-write-before-draws ordering.
- * @ignore
- */
-export default class WGSLEffectRealization {
-    /**
-     * Parse + assemble; on any parse failure `valid` is false and `error`
-     * carries the reason (the effect then warns and stays disabled).
-     * @param {string} body - the user WGSL body
-     */
-    constructor(body: string);
-    /**
-     * whether the body parsed into a realizable shape
-     * @type {boolean}
-     */
-    valid: boolean;
-    /** @type {string|null} */
-    error: string | null;
-    /** name → {offset, size, type} placement in the uniform block */
-    layout: any;
-    /** total uniform block byte size (0 = no uniform struct) */
-    structSize: any;
-    /** user texture/sampler pairs (binding table) */
-    textures: any;
-    /** builtin usage flags */
-    builtins: any;
-    /** the complete assembled WGSL module text */
-    code: string | undefined;
-    /** builtin binding assignment (ME / capture texture / samplers) */
-    builtinBindings: object | undefined;
-    cpu: ArrayBuffer | undefined;
-    f32: Float32Array<ArrayBuffer> | undefined;
-    i32: Int32Array<ArrayBuffer> | undefined;
-    u32: Uint32Array<ArrayBuffer> | undefined;
-    meMirror: Float32Array<ArrayBuffer> | undefined;
-    /**
-     * last user-set value per uniform name — the clone-replay source
-     * (exact values, not mirror read-back)
-     * @type {Map<string, number|number[]>}
-     */
-    values: Map<string, number | number[]>;
-    warned: Set<any> | undefined;
-    /**
-     * device-scoped GPU state, built lazily by the renderer's effect
-     * path and invalidated via the pipeline-cache epoch (device loss)
-     * @type {object|null}
-     */
-    gpu: object | null;
-    /**
-     * Write a uniform value into the CPU mirror.
-     * @param {string} name - a struct member name of the body's uniform block
-     * @param {number|number[]|Float32Array|{val: Float32Array}} value - the value
-     *   (objects exposing `.val` — Matrix2d/3d, ColorMatrix — are unwrapped)
-     * @returns {boolean} true when the name exists and the value was written
-     */
-    setUniform(name: string, value: number | number[] | Float32Array | {
-        val: Float32Array;
-    }): boolean;
-    /**
-     * whether the uniform block declares the given member (the WGSL
-     * counterpart of the GLSL active-uniform check `setTime` relies on)
-     * @param {string} name - member name
-     * @returns {boolean} true when present
-     */
-    hasUniform(name: string): boolean;
-    /**
-     * drop device-scoped state (device loss / destroy) — the CPU mirror
-     * and values survive, so nothing needs replaying on restore
-     */
-    releaseGPU(): void;
-}
+
 //# sourceMappingURL=wgsl_realization.d.ts.map

package/build/video/effects/wgsl_realization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wgsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/wgsl_realization.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,kBAFW,MAAM,EA2DhB;IAtDA;;;OAGG;IACH,OAFU,OAAO,CAEc;IAC/B,0BAA0B;IAC1B,OADW,MAAM,GAAC,IAAI,CAC+B;IAMrD,iEAAiE;IACjE,YAA2B;IAC3B,4DAA4D;IAC5D,gBAAmC;IACnC,iDAAiD;IACjD,cAA+B;IAC/B,0BAA0B;IAC1B,cAA+B;IAG/B,8CAA8C;IAC9C,yBAAuB;IACvB,mEAAmE;IACnE,oCAAsC;IAGtC,6BAAwD;IACxD,2CAAqC;IACrC,yCAAmC;IACnC,0CAAoC;IAIpC,gDAAmC;IAEnC;;;;OAIG;IACH,QAFU,GAAG,CAAC,MAAM,EAAE,MAAM,GAAC,MAAM,EAAE,CAAC,CAEf;IAIvB,6BAAuB;IAEvB;;;;OAIG;IACH,KAFU,MAAM,GAAC,IAAI,CAEN;IAGhB;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC;QAAC,GAAG,EAAE,YAAY,CAAA;KAAC,GAE9C,OAAO,CAwDnB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;CACD"}
+{"version":3,"file":"wgsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/wgsl_realization.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;OAIG;IACH,kBAFW,MAAM,EA2DhB;IAtDA;;;OAGG;IACH,OAFU,OAAO,CAEc;IAC/B,0BAA0B;IAC1B,OADW,MAAM,GAAC,IAAI,CAC+B;IAMrD,iEAAiE;IACjE,YAA2B;IAC3B,4DAA4D;IAC5D,gBAAmC;IACnC,iDAAiD;IACjD,cAA+B;IAC/B,0BAA0B;IAC1B,cAA+B;IAG/B,8CAA8C;IAC9C,yBAAuB;IACvB,mEAAmE;IACnE,oCAAsC;IAGtC,6BAAwD;IACxD,2CAAqC;IACrC,yCAAmC;IACnC,0CAAoC;IAIpC,gDAAmC;IAEnC;;;;OAIG;IACH,QAFU,GAAG,CAAC,MAAM,EAAE,MAAM,GAAC,MAAM,EAAE,CAAC,CAEf;IAIvB,6BAAuB;IAEvB;;;;OAIG;IACH,KAFU,MAAM,GAAC,IAAI,CAEN;IAGhB;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC;QAAC,GAAG,EAAE,YAAY,CAAA;KAAC,GAE9C,OAAO,CAwDnB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;CACD"}

package/build/video/gpu/batcher.d.ts

@@ -1,16 +1,4 @@
-/**
- * additional import for TypeScript
- * @import Renderer from "../renderer.js";
- */
-/**
- * Default maximum number of vertices per batch.
- * At 4096 vertices (1024 quads), the vertex buffer is ~80 KB (5 floats × 4 bytes × 4096),
- * which balances draw call reduction with safe buffer upload sizes on mobile tile-based GPUs.
- * Within the Uint16 index limit (65,535) — a deliberate capacity choice
- * (smaller index uploads), not an API constraint.
- * @ignore
- */
-export const DEFAULT_MAX_VERTICES: 4096;
+
 /**
  * Backend-neutral base class for renderer batchers.
  *

package/build/video/gpu/batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/batcher.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AACH,mCAAoC,IAAI,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAMC;;;;;;OAMG;IACH,eAFW,QAAQ,QAQlB;IALA;;;OAGG;IACH,+BAAwB;IAGzB;;OAEG;IACH,aAAS;IAET;;OAEG;IACH,eAAW;IAEX;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,gBAAY;CACZ;;0BA9EwB,gBAAgB"}
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/batcher.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AACH,mCAAoC,IAAI,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAMC;;;;;;OAMG;IACH,eAFW,QAAQ,QAQlB;IALA;;;OAGG;IACH,+BAAwB;IAGzB;;OAEG;IACH,aAAS;IAET;;OAEG;IACH,eAAW;IAEX;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,gBAAY;CACZ;;0BA/EwB,gBAAgB"}