@driftengine/core 4.4.2 → 4.5.0

package/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+ {
+  "version": "4.5.0",
+  "date": "2026-09-29",
+  "entries": [
+   {
+    "kind": "added",
+    "short": "Moving objects stay sharp under reconstruction: name each with createMover() and it no longer leaves a ghost or a doubled edge.",
+    "text": "**A reconstruction can follow what moves, when the draw says what it is.** DriftTR reprojects each pixel by where its surface was last frame, and it knew that only for a draw handed last frame's model matrix. A consumer that passed none, which was every consumer measured, got the camera's motion for everything: right for the world, wrong for anything that moved, so a mover trailed a ghost and a doubled edge.\n\n`createMover()` makes an identity for one moving object, and `drawMesh` takes it where it took last frame's matrix. The renderer keeps that object's last model and, for a skinned draw, its last joint palette, so a bending limb reprojects as well as a sliding body. A matrix works exactly as it did. A mover drawn twice in one frame is two objects wearing one identity: the second draw is warned about once and records no motion.\n\nMeasured on `demo/dev/ghost.html` against a native four-sample frame, trail pixels without and with a mover: a slide 6,602 → 1,150, a spin 8,599 → 3,012, a skinned limb 11,648 → 1,518. **A cut is still the consumer's to say**: call `renderer.cameraCut()` where the view jumps, or the first frames after it blend the old view in. Only a reconstruction reads any of this, and reconstruction is WebGPU's."
+   },
+   {
+    "kind": "added",
+    "short": "Glass: a pane shows what is behind it, blurred as far as it is frosted, keeps its own highlight, and glows with the lights behind it.",
+    "text": "**`TranslucentMeshOptions.glass`: `{ transmission, frost, tint }`.** A pane shows what is behind it by how much it lets through less what Schlick's Fresnel reflects at the view angle, keeps its own lighting and highlight, blurs what it shows by reading the level of the frame copy's mip chain its frost picks, and glows with every light behind it (the sun, lamps, rectangles and DriftLight) in proportion to its frost. It is two-sided and symmetric: seen from behind it passes and glows with the light beyond it as it does from in front. A glass caster writes no depth, so a lantern's own light leaves the lantern.\n\nA model says so three ways. `.drft` 1.19 carries the three fields; the glTF reader maps `KHR_materials_transmission`, `KHR_materials_diffuse_transmission` and `KHR_materials_volume`, rough glass arriving as frosted glass; and `DrftLoaderOptions.surface` can declare a file's opaque pane glass, which lands on `DrftPart.glass`. Both backends agree to a level on a bought courtyard's lantern at night, its panes from 95 to 246."
+   },
+   {
+    "kind": "added",
+    "short": "Light through glass takes the glass's colour: sunlight and lamplight through a stained or frosted pane land tinted, and frost spreads the colour.",
+    "text": "**Coloured shadows, for every light that casts one, on both backends.** Light through a pane takes `transmission × (1 − F) × tint`: the sun's static and moving maps, pooled and live lamps, and rectangles. Each map gains a glass depth layer, the nearest pane, and an RGBA8 tint, every pane on the ray multiplied together with its clarity. A receiver is tinted only behind a pane; its outline comes from depth-tested taps and its colour from taps spread by frost and read at the tint's matching mip level, unmixed from the ground around the pane, so a frosted patch is softer and passes the light a clear one does. Measured on `demo/dev/glassShadow.html`, both backends within 0.4 levels: clear sun patches 149/56 against 149.1/55.6 derived by hand, a lamp's 47.2/30.0 against 47.1/29.8; frost moves the light it passes by 0.1 to 1.4%.\n\n**`RenderQualityOptions.glassShadows`** is `'full'`, `'half'` (the tints at half size) or `'off'`. Nothing is allocated until a glass caster reaches a map; then, at `'full'`, 78 MB for the sun's two maps and 9.8 MB a lamp layer, roughly halved at `'half'`. `'off'` casts nothing through glass and compiles the lookup out of the lit shader, which a world that never casts through glass should say: a lookup that finds no glass still costs the lit pass its registers, 0.27 ms on WebGPU and 0.42 ms on WebGL2 at 720p on a bought courtyard at night. Where glass does cast, that courtyard's lit pass costs 2.3 ms more on either backend, its lamps being enclosed in frosted glass.\n\n**What it gives up**: a pane is thin, so a solid of glass under-darkens and bends light once; DriftLight's summed far field and the probes' bounce are not tinted; frost spreads colour only inside the opaque frame's shadow; and a second copy of a pane's triangles is a second pane, so two-sided glass is declared with `doubleSided`. The core bundle grows 91.6 KB gzipped, nearly all of it the lit shaders' generated WGSL."
+   },
+   {
+    "kind": "added",
+    "short": "The GPU-driven renderer draws glass, and its sunlight through glass takes the glass's colour.",
+    "text": "**`GpuDrivenMaterial.glass` takes the same `{ transmission, frost, tint }`.** A glass material is drawn in the renderer's blended half with the forward renderer's see-through, frost, Fresnel and sun glow, reading a mip chain of the opaque colour, and `GpuDrivenShadowOptions.glass` gives its sun a third light-space cut for glass, drawn into a glass layer and a tint as the forward sun's is. Its arithmetic is checked on the device against the TypeScript reference by `scripts/gpu-parity.mjs`, and its clear patches measure the forward renderer's 149/56. Its glass shadow ignores cutouts, as its opaque shadow does."
+   },
+   {
+    "kind": "changed",
+    "short": "Under reconstruction, glass, captions, particles and other see-through things are drawn at full resolution, sharp and without trails.",
+    "text": "**While reconstructing, every blended draw lands after the upscale, at output resolution.** A translucent pane, a caption, a spark or a plume has no one depth a reprojection can trust, so drawn into the reconstructed picture it trailed and softened with whatever was behind it. Blended meshes, particles, plumes, bolts, lines, film, caustics and world text now draw in a late pass on the output-size frame, unjittered and depth-tested against the upscaled depth; refraction and order-independent panes read the reconstructed picture and land in it. On the ghost page a moving translucent pane's trail went from 5,751 pixels to 20, and particles' from 2,464 to 0.\n\n**Light volumes stay reconstructed**: their march reads render-size depth and is among the most expensive passes in a frame, so they keep the render size. Without a reconstruction nothing changes, and every published scene draws identically, to the pixel on WebGPU."
+   },
+   {
+    "kind": "fixed",
+    "short": "Crowds of instanced objects and meshes rewritten every frame no longer leave a ghost behind them under reconstruction.",
+    "text": "**Two kinds of motion had no way to say where they had been.** An instanced batch carried one placement per instance and no previous one, and a mesh rewritten with `updateMesh` moved its vertices under a draw that looked still, so both were reprojected by the camera's motion alone and ghosted under reconstruction whatever the consumer passed. Each now keeps last frame's state beside this frame's, slot for slot and vertex for vertex, and needs nothing from the caller: the batch and the mesh are their own identity. An instanced crowd's trail on the ghost page went from 8,961 pixels to 1,340."
+   },
+   {
+    "kind": "fixed",
+    "short": "WebGL2: a pane in front of a reflection probe no longer turns the whole frame grey, and a double-sided instanced batch draws both of its sides.",
+    "text": "**Three WebGL2 defects, each reached first by glass.** The copy of the frame that refraction reads rebound the scene's framebuffer on its way out rather than the caller's, so a pane drawn into a reflection probe's face attached the probe's next face to the scene and the whole frame went flat grey. WebGL2 also took that copy inside a probe bake at all, which WebGPU has always refused: the copy is of the frame on screen, not of the face. And an instanced batch never turned culling off for a double-sided material, so its far faces were missing on WebGL2 alone; 28 of one bought courtyard's 53 double-sided materials are instanced."
+   },
+   {
+    "kind": "note",
+    "short": "DrftPart.glass is a new required field: code that builds its own DrftPart adds glass: null.",
+    "text": "**`DrftPart.glass` is required**, `null` for a part that is not glass, so a consumer that constructs a `DrftPart` itself, a test stub for instance, adds `glass: null` or no longer typechecks. Parts the loader makes carry it already.\n\n**And a reconstruction is still softer than native on geometry that never moves.** A mover fixes motion, not that: on the ghost page a still edge at a reconstruction of 1.5 measures about 8 in edge error against a native frame's 3, which is the reconstruction's own resolution rather than anything a consumer passes."
+   }
+  ]
+ },
  {
   "version": "4.4.2",
   "date": "2026-09-28",

package/README.md

@@ -2,7 +2,7 @@
 
 The runtime everything needs: renderer, loop, camera, input, geometry. Collision and dynamics live in [`@driftengine/physics`](../physics/README.md), which this package depends on and re-exports whole, so reaching for them through this barrel works as it always did.
 
-**Cost: 795.8 KB gzipped, importing `createRenderer`.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
+**Cost: 887.4 KB gzipped, importing `createRenderer`.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
 3% — the number is a fact about the build rather than a claim in a document.
 
 Part of [DriftEngine](../../README.md). See [`docs/ARCHITECTURE.md`](../../docs/ARCHITECTURE.md)

package/dist/index.d.ts

@@ -71,6 +71,10 @@ export type { PassAttachmentOptions, PassTarget } from './render/passTarget.ts';
 export { generateMipChain, mipLevelCount, type MipPipelines, } from './render/backend/webgpu/surfaceTexturePass.ts';
 export { createPassAttachment } from './render/passTarget.ts';
 export { jitterClip } from './render/recon/jitter.ts';
+export { resolveGlass } from './render/glass.ts';
+export type { GlassOptions, ResolvedGlass } from './render/glass.ts';
+export { createMover } from './render/recon/mover.ts';
+export type { Mover } from './render/recon/mover.ts';
 export type { FrameResource } from './render/frame/index.ts';
 export type { OcclusionOptions } from './render/occlusion.ts';
 export { OcclusionBuffer } from './render/occlusion.ts';
@@ -193,7 +197,7 @@ export type { PrefilterQuality } from './render/prefilterEnvMap.ts';
  * `ProbeBakeOptions`, which is the whole of the reasoning.
  */
 export type { ProbeBakeOptions } from './render/reflectionProbe.ts';
-export type { DirectionalShadowDepthLayers, OutputTransform, RenderQuality, RenderQualityOptions, ShadowFilterTaps, WaterReflectionFilterTaps, } from './render/renderQuality.ts';
+export type { DirectionalShadowDepthLayers, GlassShadows, OutputTransform, RenderQuality, RenderQualityOptions, ShadowFilterTaps, WaterReflectionFilterTaps, } from './render/renderQuality.ts';
 export { MAX_POINT_LIGHTS, SURFACE_TEXTURE_UNIT } from './render/lightBudget.ts';
 export { MAX_CLUSTERED_LIGHTS } from './render/clusteredLights.ts';
 export { SurfaceTexture } from './render/surfaceTexture.ts';

package/dist/index.js

@@ -86,6 +86,13 @@ export { createPassAttachment } from './render/passTarget.js';
  * resolve finds its geometry where the renderer's own verbs put theirs.
  */
 export { jitterClip } from './render/recon/jitter.js';
+/*
+ * Which object a draw is, for a reconstruction that has to find where it was last frame. See
+ * `RendererApi.drawMesh`.
+ */
+/* Glass: a pane that shows what is behind it, clear or frosted. See `TranslucentMeshOptions.glass`. */
+export { resolveGlass } from './render/glass.js';
+export { createMover } from './render/recon/mover.js';
 export { OcclusionBuffer } from './render/occlusion.js';
 /*
  * `Renderer` above stays exported and is not deprecated. `createRenderer` is the way to get

package/dist/render/backend/api.d.ts

@@ -10,6 +10,7 @@ import type { TextStyle } from '../textLayout.ts';
 import type { SdfFont } from '../sdfFont.ts';
 import type { SdfTextStyle } from '../sdfTextLayout.ts';
 import type { FrameTimer } from './timer.ts';
+import type { Mover } from '../recon/mover.ts';
 /**
  * Geometry on the device, as something a consumer holds and hands back.
  *
@@ -466,18 +467,23 @@ export type RendererApi = Omit<{
     /** Draw a handle this renderer made. Passing one from the other backend is a caller error. */
     drawMesh(mesh: MeshHandle, model: ReadonlyMat4, depthLayer?: number, tint?: Vec3 | null, 
     /**
-     * Where this mesh's surface was last frame, for a reconstruction's motion target.
-     *
-     * **Only a reconstruction reads it**, and only on WebGPU: it is what turns a moving object's
-     * stale history from a smear into a reprojection. A draw that says nothing gets the camera's
-     * motion, derived from the depth, which is exactly right for anything that did not move and
-     * wrong in proportion to how far a mover moved. Null and omitted mean the same thing.
-     *
-     * It is the *model* matrix this mesh was drawn with last frame, not a velocity: the pass
-     * transforms each vertex twice and lets the perspective divide do the rest, so a rotation and a
-     * scale are as correct as a translation.
+     * Where this mesh's surface was last frame, for a reconstruction's motion target: a `Mover`,
+     * or last frame's model matrix.
+     *
+     * **A `Mover` is the ordinary answer.** Make one per moving object with `createMover()` and pass
+     * it with every draw of that object; the renderer keeps last frame's model and, for a skinned
+     * draw, last frame's palette. A matrix still works exactly as it always has: the *model* matrix
+     * this mesh was drawn with last frame, not a velocity, so a rotation and a scale are as correct
+     * as a translation. Null and omitted mean the same thing: the camera's motion, derived from the
+     * depth, which is exactly right for anything that did not move and wrong in proportion to how
+     * far a mover moved.
+     *
+     * **Only a reconstruction reads it**, and only on WebGPU. A mover drawn twice in one frame is
+     * two objects wearing one identity: the second draw is warned about once and records no motion.
+     * Instanced batches and meshes rewritten with `updateMesh` need none — the batch and the mesh
+     * are their own identity.
      */
-    previousModel?: ReadonlyMat4 | null): void;
+    previousModel?: ReadonlyMat4 | Mover | null): void;
     /** Release the geometry behind a handle. */
     disposeMesh(mesh: MeshHandle): void;
     /**

package/dist/render/backend/webgl2/glassTintPrograms.d.ts

@@ -0,0 +1,13 @@
+export interface GlassTintProgram {
+    readonly program: WebGLProgram;
+    readonly uniforms: Record<string, WebGLUniformLocation>;
+}
+export declare class GlassTintPrograms {
+    readonly rigid: GlassTintProgram;
+    readonly instanced: GlassTintProgram;
+    readonly skinned: GlassTintProgram;
+    readonly cutout: GlassTintProgram;
+    readonly instancedCutout: GlassTintProgram;
+    constructor(gl: WebGL2RenderingContext);
+    dispose(gl: WebGL2RenderingContext): void;
+}

package/dist/render/backend/webgl2/glassTintPrograms.js

@@ -0,0 +1,38 @@
+/**
+ * The five programs a pane casts its colour through, one per way a caster is drawn, compiled the
+ * first time glass casts — so a scene with no glass compiles none of them.
+ *
+ * The vertex stages are the depth pass's with the world position handed on (`depth.ts`), so a
+ * pane's colour lands exactly where its depth does; the fragment is `paneTexel` for the device.
+ */
+import { compileProgram, uniformLocations } from '../../shader.js';
+import { GLASS_TINT_CUTOUT_FRAG, GLASS_TINT_CUTOUT_VERT, GLASS_TINT_FRAG, GLASS_TINT_INSTANCED_CUTOUT_VERT, GLASS_TINT_INSTANCED_VERT, GLASS_TINT_SKINNED_VERT, GLASS_TINT_VERT, } from '../../shaders/depth.js';
+export class GlassTintPrograms {
+    rigid;
+    instanced;
+    skinned;
+    cutout;
+    instancedCutout;
+    constructor(gl) {
+        const build = (vert, frag, label) => {
+            const program = compileProgram(gl, vert, frag, label);
+            return { program, uniforms: uniformLocations(gl, program, label) };
+        };
+        this.rigid = build(GLASS_TINT_VERT, GLASS_TINT_FRAG, 'glassTint');
+        this.instanced = build(GLASS_TINT_INSTANCED_VERT, GLASS_TINT_FRAG, 'glassTint.instanced');
+        this.skinned = build(GLASS_TINT_SKINNED_VERT, GLASS_TINT_FRAG, 'glassTint.skinned');
+        this.cutout = build(GLASS_TINT_CUTOUT_VERT, GLASS_TINT_CUTOUT_FRAG, 'glassTint.cutout');
+        this.instancedCutout = build(GLASS_TINT_INSTANCED_CUTOUT_VERT, GLASS_TINT_CUTOUT_FRAG, 'glassTint.instancedCutout');
+    }
+    dispose(gl) {
+        for (const { program } of [
+            this.rigid,
+            this.instanced,
+            this.skinned,
+            this.cutout,
+            this.instancedCutout,
+        ]) {
+            gl.deleteProgram(program);
+        }
+    }
+}

package/dist/render/backend/webgl2/renderer.d.ts

@@ -1,4 +1,6 @@
 import { FrameBudget } from '../budget.ts';
+import type { Mover } from '../../recon/mover.ts';
+import type { GlassOptions } from '../../glass.ts';
 import type { ReadonlyMat4 } from 'gl-matrix';
 import type { Camera } from '../../camera.ts';
 import type { PickHit, PickableSource } from '../../pickable.ts';
@@ -521,6 +523,13 @@ export interface TranslucentMeshOptions {
      * clear, and it is the whole difference between this and a flat tint.
      */
     readonly thicknessM?: number;
+    /**
+     * Glass: the pane shows what is behind it, by how much it lets through and how little it reflects
+     * at the view angle, blurred by how frosted it is, tinted, and glowing with the lights behind it.
+     * It keeps its own lighting and highlight, which `refraction` alone replaces. Absent, or letting
+     * nothing through, is not glass. See `glass.ts`; `refraction` still bends what a pane shows.
+     */
+    readonly glass?: GlassOptions;
     /**
      * Whether this draw writes depth. `true`, which is what it has always done, unless a caller
      * says otherwise.
@@ -819,6 +828,8 @@ export declare class WebGL2Renderer implements RendererApi {
     /** Whether a palette is currently chosen. Distinct from whether one was ever uploaded. */
     private skinPaletteSet;
     private readonly emptyTexture2D;
+    /** One glass resolution reused by every draw, so a pane allocates nothing. See `glass.ts`. */
+    private readonly glassScratch;
     /** DriftLight's stand-ins while no field is whole: no brick anywhere, and no light. */
     private readonly emptyDriftIndex;
     private readonly emptyDriftAtlas;
@@ -1008,9 +1019,8 @@ export declare class WebGL2Renderer implements RendererApi {
     private readonly depthInstancedCutoutUniforms;
     private readonly scatterDepthProgram;
     private readonly scatterDepthUniforms;
-    private readonly shadowMap;
-    private readonly peeledShadowMap;
-    private readonly dynamicShadowMap;
+    /** The sun's static, moving and peeled maps, as layers of one array. See `shadowMap.ts`. */
+    private readonly sunShadows;
     private readonly pointShadows;
     /**
      * The layers a world's casting rectangles hold, above the point pool in the same array.
@@ -1181,7 +1191,7 @@ export declare class WebGL2Renderer implements RendererApi {
     /** Non-zero while the drawing buffer is pinned; see `lockDrawingBuffer`. */
     private lockedWidth;
     private lockedHeight;
-    private activeShadowMap;
+    private activeSunLayer;
     private reflectionPassActive;
     private reflectionReadyThisFrame;
     private reflectionAtmosphereY;
@@ -1203,7 +1213,7 @@ export declare class WebGL2Renderer implements RendererApi {
      *
      * **Not whether the map exists.** That was the test here, on the belief that a GL texture is
      * born reading as the far plane; it is born zeroed, and a scene that built the layer and never
-     * peeled it sampled an occluder at the light. `ShadowMap` now clears itself at birth, so an
+     * peeled it sampled an occluder at the light. `SunShadowArray` clears itself at birth, so an
      * unfilled layer would read as lit either way — this is what keeps the two backends one
      * decision, and a frame that does not peel from paying a fetch per tap for nothing.
      */
@@ -1229,6 +1239,21 @@ export declare class WebGL2Renderer implements RendererApi {
      * Built once at construction, arrow properties closing over `this`: a sink created
      * per pass would allocate six objects per light per frame.
      */
+    /** What the sun's light keeps through glass, made the first time glass casts: `sunGlassTint.ts`. */
+    private sunGlassTint;
+    /** The five programs a pane casts its colour through, compiled the first time glass casts. */
+    private glassTintPrograms;
+    /** True while the glass list is replayed into the glass depth layer through `casterSink`. */
+    private drawingGlassDepth;
+    /** How many times a shadow array grew its glass layers: once per family, and never again. */
+    private sunGlassRebuilds;
+    /** The light a tint pass is drawn for, and one pane's colour and clarity: uploaded per entry. */
+    private readonly glassLight;
+    private readonly glassPane;
+    /** The glass the open shadow pass was offered, kept for its own passes: `glassCasters.ts`. */
+    private readonly glassCasters;
+    /** One resolution every glass caster is read through, so recording one allocates nothing. */
+    private readonly glassCasterScratch;
     private readonly casterSink;
     /**
      * What a cutout depth draw needs beyond the plain one: the pass's matrix and peel, the material's
@@ -1236,6 +1261,13 @@ export declare class WebGL2Renderer implements RendererApi {
      */
     private bindCutoutDepth;
     private readonly drawPointShadowFace;
+    /**
+     * A lamp's glass, after each face's opaque depth: `PointShadowMap.bake` asks and binds, this
+     * draws, through the same sinks the sun's glass takes and in the face's own matrix.
+     */
+    private readonly pointGlassDraw;
+    /** The glass hook a bake is handed: none at all when glass shadows are off. */
+    private get pointGlass();
     /**
      * Viewport in CSS pixels rather than device pixels.
      *
@@ -1843,6 +1875,21 @@ export declare class WebGL2Renderer implements RendererApi {
      * consumer's, which is also where the placements are.
      */
     private submitInstanced;
+    /**
+     * Bind what a translucent draw shows through it: the frame's copy, refraction's bend and absorption,
+     * and glass. Returns whether the copy is bound, and so whether `unbindSeeThrough` owes it back.
+     *
+     * **A glass draw takes the copy even when it does not bend**, since a pane shows what is behind it
+     * either way, and asks for the copy's mip chain, which a frosted pane reads blurred. A null copy
+     * leaves both off, so the pane shades as ordinary translucency rather than sampling black.
+     *
+     * **Refused inside a probe's face or a mirror**, as WebGPU's `takeRefractSnapshot` refuses: the
+     * copy is of the frame drawn to the screen, so a pane there would show the wrong picture, and
+     * taking it mid-bake is how a probe's next face came to be attached to the scene's framebuffer.
+     */
+    private bindSeeThrough;
+    /** Put back what `bindSeeThrough` bound: the binding outlives its frame (the 2026-08-27 rule). */
+    private unbindSeeThrough;
     disposeMesh(mesh: Mesh): void;
     /**
      * Release a resource this renderer created, for every kind that needs the context back.
@@ -2329,6 +2376,25 @@ export declare class WebGL2Renderer implements RendererApi {
      */
     drawSceneCasters(casters: ShadowCasters): void;
     drawShadowCasters(casters: ShadowCasters): void;
+    /**
+     * Draw the pass's glass twice: where the nearest pane is, and what the panes let through.
+     *
+     * After the opaque casters, in the pass's own light matrix. A layer that has held glass is
+     * redrawn even when this pass offered none, so glass that has gone takes its colour with it. The
+     * first glass grows the array (`SunShadowArray.growForGlass`) and makes the tint target.
+     */
+    private flushSunGlass;
+    /** The glass list into the glass depth layer: `casterSink` itself, with glass let through. */
+    private readonly glassDepthSink;
+    /** One pane's tint uniforms, and its cutout where it has one. */
+    private bindGlassTint;
+    /**
+     * The glass list into the tint layer, through the tint programs, **culling nothing**: a light
+     * crosses a pane whichever way the pane faces, and a closed glass object has two surfaces on a
+     * ray, so every one counts. What that asks of a model is that a pane be one surface — two-sided
+     * glass says so with `doubleSided`, and a second copy of its triangles is a second pane.
+     */
+    private readonly glassTintSink;
     endShadowPass(): void;
     /**
      * The lit program, built at the largest light budget this device will actually link.
@@ -2586,6 +2652,10 @@ export declare class WebGL2Renderer implements RendererApi {
      *
      * What it gives up is one frame of history: the frame after a cut has no blur and no temporal
      * blend, as the first frame of a session has none. Nothing else is reset.
+     *
+     * **A reconstructing renderer depends on it**: its history is the last shot's, and without this
+     * call a cut blends that shot into the first frames of the next. Nothing detects a cut on the
+     * caller's behalf, deliberately — a fast pan and a cut look alike from here.
      */
     cameraCut(): void;
     /**
@@ -3050,13 +3120,14 @@ export declare class WebGL2Renderer implements RendererApi {
      */
     tint?: Vec3 | null, 
     /**
-     * Where the mesh was last frame, which this backend takes and ignores.
+     * Where the mesh was last frame — a `Mover` or a matrix — which this backend takes and ignores.
      *
      * Accepted rather than absent so that one scene draws through both renderers unchanged — the
      * parity rule this repository is built on. Reconstruction is WebGPU's, having no compute stage
-     * here, so there is no motion target for this to be written into.
+     * here, so there is no motion target for this to be written into, and a mover passed here is
+     * neither read nor advanced.
      */
-    _previousModel?: ReadonlyMat4 | null): void;
+    _previousModel?: ReadonlyMat4 | Mover | null): void;
     /**
      * Draw a mesh you can see through, in the same material as everything else by default.
      *