@driftengine/core 4.4.1 → 4.5.0

package/CHANGELOG.json

@@ -1,4 +1,76 @@
 [
+ {
+  "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",
+  "entries": [
+   {
+    "kind": "fixed",
+    "short": "A reconstructed frame no longer flickers or softens along the edges of still objects: the far side of every silhouette keeps its history.",
+    "text": "**The disocclusion test compared two different surfaces at every edge.** The reconstruction reprojects each output pixel by the nearest of its nine samples, the usual dilation, and then asked whether last frame held the same surface by reading last frame's depth under the output pixel rather than where the dilated sample had stood. At a silhouette those are the object and what is behind it, so the far side of every edge, every surface turned away from the eye and every part thinner than a sample dropped its history on a still frame: a paused picture flashed white along its outlines and read softer than a single frame of it.\n\nThe test now searches last frame's three by three around where the dilated sample stood, allows for how steeply the surface recedes, and weights the normal test by how planar the surface really is, so a thin rod no longer fails it. Measured on a consumer reconstructing at 1.5: a paused frame went from 3,269 flickering pixels to 338, and a still panel from up to 1,787 to 7, with no added ghosting in motion. The cost is 0.065 ms of GPU time at 2280 by 1291."
+   },
+   {
+    "kind": "fixed",
+    "short": "Temporal antialiasing no longer flashes on detail finer than a pixel while the camera is still: a paused grille, lace or crack of light holds steady.",
+    "text": "**A still pixel's neighbourhood now widens by its own proven flicker.** A thread finer than a pixel is caught by the jitter in some phases and missed in others, and in a phase that misses it the nine taps round the pixel miss it too: the box collapses onto the background, the settled history is clipped away, and a paused frame flashed at every fine edge. A still camera over a still scene samples every pixel the same way in every period of the jitter, so each pixel now keeps a small record of its own samples, and once two periods running have repeated, its box widens by the spread it has shown and it keeps more of its history. A surface that moves, a flame, or anything arriving breaks the repetition, and a sample beyond what the pixel has shown disqualifies the frame it lands in.\n\nMeasured on a scene of fine ironwork and fabric: a held frame went from 839 flickering pixels to 3 on WebGPU and from 1,802 to 14 on WebGL2, and the device check's edge figures are unchanged. It costs two half-float record targets beside the history. A moving camera is resolved exactly as before, and so is WebGL2 without float colour targets."
+   },
+   {
+    "kind": "fixed",
+    "short": "A point light's shadow no longer shows a straight-edged patch of wrong shadow while its map is redrawn: a map being sampled is re-baked whole or not at all.",
+    "text": "**A re-bake spread across frames was sampled half done.** Faces land in the layer the shader reads as they are drawn, and the origin they were drawn from is published only with the last one, so a map re-baked two faces a frame was read from its old origin with part of it drawn from the new one. A cube face is a 90 degree frustum, so the wrong part was a straight-edged quadrilateral of shadow on the ground under the lamp, and with the face budget spent elsewhere it could hold for over a second.\n\nA map that already holds an image is now re-baked whole or not at all, and a light being shaded may take one whole cube a frame outside `pointShadowFacesPerFrame`, the allowance a wandering light already had. A map with no image yet still fills a few faces a frame, since nothing samples it until it is complete. What it costs is six faces in the frame a shaded light goes stale, rather than two in each of three."
+   },
+   {
+    "kind": "fixed",
+    "short": "A flame's shadow no longer switches its own fixture in and out as the flame sways: the default near plane clears what the fire burns from at every point of the sway.",
+    "text": "**The near plane moved with the flame, and the fixture under it did not.** `createFlame` puts the light a third of the way up the flame, 0.83 of its width above what it burns from, with a near plane of one width, and sways it by 0.15 of a width on each axis. At the top of the sway the cut sat 7 mm under a 40 cm brazier's coals and at the bottom 13 cm, so the bowl beneath went in and out of the shadow map depending on where the flame stood when the map was last drawn, and the floor under the brazier took a dark disc on some re-bakes and none on others.\n\nThe default `shadowNear` now adds the sway, so it clears the same margin under the fire wherever the flame has wandered. A fixture reaching further below the flame than a sixth of its width sets its own `shadowNear` from its own depth."
+   }
+  ]
+ },
  {
   "version": "4.4.1",
   "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: 789.9 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;
@@ -947,6 +958,9 @@ export declare class WebGL2Renderer implements RendererApi {
      * Scratch, filled in `endFrame`, which may not allocate.
      */
     private frameProjection;
+    /** The temporal resolve's depth-to-metres row, from the inverse of `frameProjection`. */
+    private readonly taaInvProjection;
+    private readonly taaDepthToViewZ;
     private readonly aoInvProjection;
     private readonly aoProjScale;
     /**
@@ -1005,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.
@@ -1178,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;
@@ -1200,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.
      */
@@ -1226,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
@@ -1233,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.
      *
@@ -1840,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.
@@ -2326,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.
@@ -2583,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;
     /**
@@ -3047,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.
      *