@driftengine/core 3.62.0 → 4.0.0

package/dist/render/temporalAa.js

@@ -1,4 +1,5 @@
 import { mat4 } from 'gl-matrix';
+import { jitterTable } from './recon/jitter.js';
 /**
  * The sub-pixel sequence a temporal resolve samples along, and the state that says whether there
  * is anything to resolve *against* yet.
@@ -33,44 +34,18 @@ export const JITTER_PERIOD = 8;
  */
 export const TEMPORAL_HISTORY_BLEND = 0.9;
 /**
- * The radical inverse of `index` in `base`, which is what makes a Halton sequence fill a gap
- * before it fills a corner.
+ * The period's offsets, centred so they sum to zero — `recon/jitter.ts`'s sequence at eight phases.
  *
- * Consecutive samples land as far from each other as the base allows, so eight of them cover the
- * pixel evenly where eight random ones would leave holes and pairs.
+ * **One sequence for the temporal resolve and for reconstruction**, and these are the numbers the
+ * resolve has always used: Halton in bases two and three, each period centred on its own mean,
+ * because accumulating towards an off-centre mean resolves to a picture displaced from the depth
+ * it was tested against.
  */
-function halton(index, base) {
-    let result = 0;
-    let fraction = 1;
-    let i = index;
-    while (i > 0) {
-        fraction /= base;
-        result += fraction * (i % base);
-        i = Math.floor(i / base);
-    }
-    return result;
-}
-/**
- * The period's offsets, centred so they sum to zero.
- *
- * **Halton's own mean is not the middle of the pixel** — over eight samples base two averages
- * 0.445 rather than 0.5 — and accumulating towards a mean that is off centre resolves to a picture
- * displaced from the depth buffer it was tested against and from every pass that did not jitter.
- * Subtracting the period's own mean costs nothing and makes the property exact rather than
- * approximate, which is what lets the test assert it.
- */
-const OFFSETS = (() => {
-    const raw = [];
-    for (let i = 1; i <= JITTER_PERIOD; i++)
-        raw.push([halton(i, 2), halton(i, 3)]);
-    const meanX = raw.reduce((sum, o) => sum + o[0], 0) / JITTER_PERIOD;
-    const meanY = raw.reduce((sum, o) => sum + o[1], 0) / JITTER_PERIOD;
-    return raw.map(([x, y]) => [x - meanX, y - meanY]);
-})();
+const OFFSETS = jitterTable(JITTER_PERIOD);
 /** Where in its pixel frame `frameIndex` samples, in pixels, centred on zero. */
 export function jitterOffset(frameIndex) {
     const at = ((frameIndex % JITTER_PERIOD) + JITTER_PERIOD) % JITTER_PERIOD;
-    return OFFSETS[at];
+    return [OFFSETS[at * 2], OFFSETS[at * 2 + 1]];
 }
 /**
  * `source` shifted by `offsetX`, `offsetY` pixels on a `width` by `height` target.

package/dist/render/textLayout.js

@@ -180,13 +180,19 @@ function buildCube() {
     for (const face of faces) {
         const [a, b, c, d] = face.corners;
         /*
-         * Wound clockwise, which is backwards — deliberately. The vertex shader flips Y to put the
-         * origin at the top left, and a mirror reverses winding, so faces authored the usual way
-         * come out back-facing and every one of them is culled. The symptom is text that renders
-         * with no GL error and no pixels, which is a genuinely difficult thing to look at and
-         * diagnose.
+         * **Wound the usual way, and it was wound backwards on purpose until 2026-09-16.**
+         *
+         * The comment that stood here said the vertex shader's Y flip mirrors the winding, so faces
+         * authored the usual way "come out back-facing and every one of them is culled". Measured on
+         * both backends, that is not what happens: with the usual winding both draw solid glyphs, and
+         * with the reversed one **WebGL2 draws a one-pixel sliver of every cell** while WebGPU draws
+         * them solid. The text on the default backend has been a dotted outline of itself.
+         *
+         * It survived because it is legible. A reader sees letters; only a capture beside the other
+         * backend says the cells are hollow, and `demo/dev/overlay.html` is where that comparison is
+         * cheap — 7,678 lit pixels against 14,982 for the same string.
          */
-        for (const corner of [a, c, b, a, d, c]) {
+        for (const corner of [a, b, c, a, c, d]) {
             positions.push(corner[0], corner[1], corner[2]);
             normals.push(face.normal[0], face.normal[1], face.normal[2]);
         }

package/dist/render/textRenderer.d.ts

@@ -22,8 +22,10 @@ export declare class TextRenderer {
     /**
      * @param originX left edge, in pixels from the left of the viewport.
      * @param originY baseline, in pixels from the top.
+     *
+     * Answers whether it drew, which the renderer counts on its frame budget.
      */
-    draw(viewportWidth: number, viewportHeight: number, originX: number, originY: number, style: TextStyle, timeSec: number): void;
+    draw(viewportWidth: number, viewportHeight: number, originX: number, originY: number, style: TextStyle, timeSec: number): boolean;
     dispose(): void;
     /** Both instance buffers, from the arrays the layout filled in place. */
     private upload;

package/dist/render/textRenderer.js

@@ -63,10 +63,12 @@ export class TextRenderer {
     /**
      * @param originX left edge, in pixels from the left of the viewport.
      * @param originY baseline, in pixels from the top.
+     *
+     * Answers whether it drew, which the renderer counts on its frame budget.
      */
     draw(viewportWidth, viewportHeight, originX, originY, style, timeSec) {
         if (this.layout.instanceCount === 0 || style.alpha <= 0)
-            return;
+            return false;
         const gl = this.gl;
         gl.useProgram(this.program);
         gl.bindVertexArray(this.vao);
@@ -122,6 +124,7 @@ export class TextRenderer {
         }
         gl.drawArraysInstanced(gl.TRIANGLES, 0, TEXT_CUBE.vertexCount, this.layout.instanceCount);
         gl.bindVertexArray(null);
+        return true;
     }
     dispose() {
         const gl = this.gl;

package/dist/render/translucentQueue.d.ts

@@ -50,8 +50,14 @@ export interface TranslucentDraw {
 export declare class TranslucentQueue {
     private readonly pool;
     private count;
+    private refracting;
     /** How many draws this frame has recorded. */
     get length(): number;
+    /**
+     * Whether anything recorded this frame refracts, so a backend replaying the set knows to copy the
+     * frame behind it first, and does not copy it for a set that never reads it.
+     */
+    get refracts(): boolean;
     /** How many records are pooled, which a test uses to assert a steady scene stops allocating. */
     get capacity(): number;
     /**

package/dist/render/translucentQueue.js

@@ -19,10 +19,18 @@ function newRecord() {
 export class TranslucentQueue {
     pool = [];
     count = 0;
+    refracting = 0;
     /** How many draws this frame has recorded. */
     get length() {
         return this.count;
     }
+    /**
+     * Whether anything recorded this frame refracts, so a backend replaying the set knows to copy the
+     * frame behind it first, and does not copy it for a set that never reads it.
+     */
+    get refracts() {
+        return this.refracting > 0;
+    }
     /** How many records are pooled, which a test uses to assert a steady scene stops allocating. */
     get capacity() {
         return this.pool.length;
@@ -57,6 +65,8 @@ export class TranslucentQueue {
             record.tint = record.tintStore;
         }
         record.refraction = options.refraction ?? 0;
+        if (record.refraction > 0)
+            this.refracting++;
         record.thicknessM = options.thicknessM ?? 0;
         const refractTint = options.refractTint ?? null;
         if (refractTint === null) {
@@ -86,5 +96,6 @@ export class TranslucentQueue {
     /** Empty it for the next frame, keeping the storage. */
     reset() {
         this.count = 0;
+        this.refracting = 0;
     }
 }

package/dist/render/windStreakRenderer.d.ts

@@ -30,8 +30,9 @@ export declare class WindStreakRenderer {
     strengthFor(speed: number): number;
     /** Refilled per call rather than allocated; this is a per-frame path. */
     private readonly resolved;
+    /** Answers whether it drew, which the renderer counts on its frame budget. */
     draw(gl: WebGL2RenderingContext, camera: FrameView, wind: WindField, timeSeconds: number, tint: Vec3, 
     /** True when the camera is below the waterline. */
-    submerged?: boolean): void;
+    submerged?: boolean): boolean;
     dispose(gl: WebGL2RenderingContext): void;
 }

package/dist/render/windStreakRenderer.js

@@ -47,13 +47,14 @@ export class WindStreakRenderer {
     }
     /** Refilled per call rather than allocated; this is a per-frame path. */
     resolved = createResolvedWindStreaks();
+    /** Answers whether it drew, which the renderer counts on its frame budget. */
     draw(gl, camera, wind, timeSeconds, tint, 
     /** True when the camera is below the waterline. */
     submerged = false) {
         /* Chosen in `windStreakDraw.ts` so both backends show the same weather. */
         const settled = resolveWindStreaks(wind.speed, wind.driftX, wind.driftZ, this.onsetSpeed, this.fullSpeed, submerged, this.resolved);
         if (!settled.visible)
-            return;
+            return false;
         const u = this.uniforms;
         gl.useProgram(this.program);
         gl.uniformMatrix4fv(u['uViewProj'] ?? null, false, camera.viewProjection);
@@ -76,6 +77,7 @@ export class WindStreakRenderer {
         gl.enable(gl.CULL_FACE);
         gl.depthMask(true);
         gl.disable(gl.BLEND);
+        return true;
     }
     dispose(gl) {
         for (const buffer of this.buffers)

package/dist/world/cell.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The world as a sparse grid of cells: the unit that streams, freezes and rebases.
+ *
+ * **A position on a boundary belongs to exactly one cell, and which one is decided by `Math.floor`
+ * rather than by rounding.** Both sides, or neither, are the two ways this goes wrong, and both
+ * present as an entity that flickers between cells while standing still — which then flickers
+ * between loaded and unloaded.
+ *
+ * **Negative coordinates work.** A naive bit-packing of the grid coordinate breaks below zero and
+ * the symptom is a world that is fine in one quadrant, which is the quadrant anybody tests in.
+ */
+/** The grid coordinate a world coordinate falls in. */
+export declare function cellCoord(value: number, size: number): number;
+/** Whether these grid coordinates fit the packing. See `AXIS_BITS` for the range. */
+export declare function cellCoordInRange(c: number): boolean;
+/**
+ * Pack grid coordinates into one identifier.
+ *
+ * **Out of range throws rather than wrapping**, and the reason is what wrapping does: a coordinate
+ * past the bias produces an identifier belonging to a different, real cell, so two distant places
+ * in the world silently become the same cell. That is a corruption with no symptom near where it
+ * happened. This is a streaming-time path, not a per-vertex one, so the check costs nothing that
+ * matters.
+ */
+export declare function cellIdFrom(cx: number, cy: number, cz: number): number;
+export declare function cellIdFor(x: number, y: number, z: number, size: number): number;
+export declare function cellCoordsOf(id: number, out: Int32Array): void;
+/** Minimum corner and size, in world units. */
+export declare function cellBounds(id: number, size: number, out: Float64Array): void;
+/**
+ * Every cell within `radius` of a point, appended to `out`.
+ *
+ * Symmetric about the centre and conservative: a cell the sphere merely touches is included,
+ * because the cost of an extra cell is a wasted load and the cost of a missing one is a hole.
+ */
+export declare function cellsInRadius(x: number, y: number, z: number, radius: number, size: number, out: number[]): number;
+/**
+ * The grid a query walks: its cell, and the most cells one query may walk.
+ *
+ * **The limit is stated rather than discovered.** A view's frustum is bounded by its far plane, and
+ * a far plane a thousand cells away is a million-cell walk per predicted frame — a frame-time cliff
+ * that looks like a hang. A query that would walk more than `maxCells` refuses and says how many.
+ */
+export interface CellGrid {
+    /** Cell edge length, world units. */
+    readonly size: number;
+    readonly maxCells: number;
+}
+export declare function createCellGrid(size: number, maxCells?: number): CellGrid;
+/**
+ * Every cell the view looks into, into `out`, in coordinate order. Returns how many.
+ *
+ * `viewProj` is column-major and OpenGL-convention, as `gl-matrix` builds one, and in absolute
+ * world units — **in double precision if the world is past 2^24**, because a plane's offset out there
+ * is not a number a single float holds to the metre.
+ *
+ * **Conservative, as `cellsInRadius` is**: a cell is left out only when it lies wholly beyond one of
+ * the view's planes, so every point the view can see is in a returned cell, and a cell near a
+ * corner of the view can be returned without being seen. The cells walked are those inside the
+ * box round the view's eight corners, which is why a view with no far plane is refused: its box has
+ * no far side.
+ */
+export declare function cellsInFrustum(grid: CellGrid, viewProj: ArrayLike<number>, out: number[]): number;

package/dist/world/cell.js

@@ -0,0 +1,181 @@
+/**
+ * The world as a sparse grid of cells: the unit that streams, freezes and rebases.
+ *
+ * **A position on a boundary belongs to exactly one cell, and which one is decided by `Math.floor`
+ * rather than by rounding.** Both sides, or neither, are the two ways this goes wrong, and both
+ * present as an entity that flickers between cells while standing still — which then flickers
+ * between loaded and unloaded.
+ *
+ * **Negative coordinates work.** A naive bit-packing of the grid coordinate breaks below zero and
+ * the symptom is a world that is fine in one quadrant, which is the quadrant anybody tests in.
+ */
+import { mat4 } from 'gl-matrix';
+import { boxInFrustum, frustumFromViewProjection } from '../math/frustum.js';
+/**
+ * Bits per axis in a packed cell identifier.
+ *
+ * Seventeen gives ±65,536 cells an axis, and three of them multiply to 2.25e15 — inside the
+ * 9.01e15 an integer stays exact in a double. At a 256-metre cell that is ±16,777 km an axis,
+ * which is more world than anybody has; at one metre it is still ±65 km.
+ */
+const AXIS_BITS = 17;
+const AXIS_SPAN = 1 << AXIS_BITS;
+const AXIS_BIAS = AXIS_SPAN >> 1;
+/** The grid coordinate a world coordinate falls in. */
+export function cellCoord(value, size) {
+    return Math.floor(value / size);
+}
+/** Whether these grid coordinates fit the packing. See `AXIS_BITS` for the range. */
+export function cellCoordInRange(c) {
+    return Number.isInteger(c) && c >= -AXIS_BIAS && c < AXIS_BIAS;
+}
+/**
+ * Pack grid coordinates into one identifier.
+ *
+ * **Out of range throws rather than wrapping**, and the reason is what wrapping does: a coordinate
+ * past the bias produces an identifier belonging to a different, real cell, so two distant places
+ * in the world silently become the same cell. That is a corruption with no symptom near where it
+ * happened. This is a streaming-time path, not a per-vertex one, so the check costs nothing that
+ * matters.
+ */
+export function cellIdFrom(cx, cy, cz) {
+    if (!cellCoordInRange(cx) || !cellCoordInRange(cy) || !cellCoordInRange(cz)) {
+        throw new RangeError(`cell coordinate (${cx}, ${cy}, ${cz}) is outside the ±${AXIS_BIAS} the packing holds`);
+    }
+    const x = cx + AXIS_BIAS;
+    const y = cy + AXIS_BIAS;
+    const z = cz + AXIS_BIAS;
+    /* Multiplication rather than shifts: a shift in JavaScript is 32-bit and would wrap here. */
+    return (x * AXIS_SPAN + y) * AXIS_SPAN + z;
+}
+export function cellIdFor(x, y, z, size) {
+    return cellIdFrom(cellCoord(x, size), cellCoord(y, size), cellCoord(z, size));
+}
+export function cellCoordsOf(id, out) {
+    const z = id % AXIS_SPAN;
+    const rest = (id - z) / AXIS_SPAN;
+    const y = rest % AXIS_SPAN;
+    const x = (rest - y) / AXIS_SPAN;
+    out[0] = x - AXIS_BIAS;
+    out[1] = y - AXIS_BIAS;
+    out[2] = z - AXIS_BIAS;
+}
+const COORDS = new Int32Array(3);
+/** Minimum corner and size, in world units. */
+export function cellBounds(id, size, out) {
+    cellCoordsOf(id, COORDS);
+    out[0] = COORDS[0] * size;
+    out[1] = COORDS[1] * size;
+    out[2] = COORDS[2] * size;
+    out[3] = size;
+}
+/**
+ * Every cell within `radius` of a point, appended to `out`.
+ *
+ * Symmetric about the centre and conservative: a cell the sphere merely touches is included,
+ * because the cost of an extra cell is a wasted load and the cost of a missing one is a hole.
+ */
+export function cellsInRadius(x, y, z, radius, size, out) {
+    out.length = 0;
+    const lo = [
+        cellCoord(x - radius, size),
+        cellCoord(y - radius, size),
+        cellCoord(z - radius, size),
+    ];
+    const hi = [
+        cellCoord(x + radius, size),
+        cellCoord(y + radius, size),
+        cellCoord(z + radius, size),
+    ];
+    for (let cx = lo[0]; cx <= hi[0]; cx += 1) {
+        for (let cy = lo[1]; cy <= hi[1]; cy += 1) {
+            for (let cz = lo[2]; cz <= hi[2]; cz += 1) {
+                out.push(cellIdFrom(cx, cy, cz));
+            }
+        }
+    }
+    return out.length;
+}
+export function createCellGrid(size, maxCells = 65_536) {
+    if (!(size > 0 && size < Infinity)) {
+        throw new RangeError(`a cell of ${String(size)} units is not a cell`);
+    }
+    if (!(Number.isInteger(maxCells) && maxCells >= 1)) {
+        throw new RangeError(`a limit of ${String(maxCells)} cells is not a limit`);
+    }
+    return { size, maxCells };
+}
+/* Double precision throughout: a world past 2^24 units is what this grid is for. */
+const PLANES = new Float64Array(24);
+const INVERSE = new Float64Array(16);
+const CORNER_LOW = new Float64Array(3);
+const CORNER_HIGH = new Float64Array(3);
+/**
+ * Every cell the view looks into, into `out`, in coordinate order. Returns how many.
+ *
+ * `viewProj` is column-major and OpenGL-convention, as `gl-matrix` builds one, and in absolute
+ * world units — **in double precision if the world is past 2^24**, because a plane's offset out there
+ * is not a number a single float holds to the metre.
+ *
+ * **Conservative, as `cellsInRadius` is**: a cell is left out only when it lies wholly beyond one of
+ * the view's planes, so every point the view can see is in a returned cell, and a cell near a
+ * corner of the view can be returned without being seen. The cells walked are those inside the
+ * box round the view's eight corners, which is why a view with no far plane is refused: its box has
+ * no far side.
+ */
+export function cellsInFrustum(grid, viewProj, out) {
+    out.length = 0;
+    const matrix = viewProj;
+    if (mat4.invert(INVERSE, matrix) === null) {
+        throw new RangeError('cellsInFrustum: a view with no inverse has no far plane to bound it');
+    }
+    CORNER_LOW.fill(Infinity);
+    CORNER_HIGH.fill(-Infinity);
+    for (let corner = 0; corner < 8; corner += 1) {
+        const x = corner & 1 ? 1 : -1;
+        const y = corner & 2 ? 1 : -1;
+        const z = corner & 4 ? 1 : -1;
+        const m = INVERSE;
+        const w = m[3] * x + m[7] * y + m[11] * z + m[15];
+        /*
+         * A corner at or behind the eye's plane is a corner at infinity: the view has no far side.
+         * **This is the only check the corners need.** A lens deep enough for a corner to overflow has
+         * its far plane at infinity in double precision, where this is exactly zero, and a matrix small
+         * enough to overflow its inverse has a determinant that has already underflowed to none.
+         */
+        if (!(w > 0)) {
+            throw new RangeError('cellsInFrustum: a view whose far plane is at infinity bounds no cells');
+        }
+        for (let axis = 0; axis < 3; axis += 1) {
+            const value = (m[axis] * x +
+                m[4 + axis] * y +
+                m[8 + axis] * z +
+                m[12 + axis]) /
+                w;
+            CORNER_LOW[axis] = Math.min(CORNER_LOW[axis], value);
+            CORNER_HIGH[axis] = Math.max(CORNER_HIGH[axis], value);
+        }
+    }
+    const size = grid.size;
+    const x0 = cellCoord(CORNER_LOW[0], size);
+    const y0 = cellCoord(CORNER_LOW[1], size);
+    const z0 = cellCoord(CORNER_LOW[2], size);
+    const x1 = cellCoord(CORNER_HIGH[0], size);
+    const y1 = cellCoord(CORNER_HIGH[1], size);
+    const z1 = cellCoord(CORNER_HIGH[2], size);
+    const span = (x1 - x0 + 1) * (y1 - y0 + 1) * (z1 - z0 + 1);
+    if (span > grid.maxCells) {
+        throw new RangeError(`cellsInFrustum: this view spans ${String(span)} cells, more than the ${String(grid.maxCells)} its grid allows`);
+    }
+    frustumFromViewProjection(matrix, PLANES);
+    for (let cx = x0; cx <= x1; cx += 1) {
+        for (let cy = y0; cy <= y1; cy += 1) {
+            for (let cz = z0; cz <= z1; cz += 1) {
+                if (boxInFrustum(PLANES, cx * size, cy * size, cz * size, (cx + 1) * size, (cy + 1) * size, (cz + 1) * size)) {
+                    out.push(cellIdFrom(cx, cy, cz));
+                }
+            }
+        }
+    }
+    return out.length;
+}

package/dist/world/cellStream.d.ts

@@ -0,0 +1,103 @@
+import type { CellGrid } from './cell.ts';
+/** What a stream needs of whatever holds a cell's contents. */
+export interface CellStore {
+    loaded(id: number): boolean;
+    /** Begin loading. Lower `priority` is sooner, matching the queue's convention. */
+    load(id: number, priority: number): void;
+    unload(id: number): void;
+}
+export interface CellStreamOptions {
+    readonly store: CellStore;
+    /** Cell edge length, world units. */
+    readonly size: number;
+    /** How far around a view cells are wanted. */
+    readonly radius: number;
+    /** How many pumps a cell may go unwanted before it is dropped. */
+    readonly hysteresis: number;
+    /** The render origin the predicted views are relative to. Absent means the world origin. */
+    readonly origin?: ArrayLike<number>;
+    /**
+     * The projection the predicted views are drawn through. With it, a stream also wants the cells
+     * those views look into, out to its far plane; without it, only the cells within `radius`.
+     */
+    readonly projection?: ArrayLike<number>;
+    /** The most cells one view's query may walk. See `CellGrid`. */
+    readonly maxCells?: number;
+}
+export interface CellStream {
+    readonly store: CellStore;
+    readonly size: number;
+    readonly radius: number;
+    readonly hysteresis: number;
+    /**
+     * Where the predicted views' origin is, in absolute world coordinates.
+     *
+     * **A view matrix is `Float32Array`, and that is why this exists.** `runPrediction` writes views
+     * into single precision — which is right, because a view matrix is what a renderer takes — and
+     * single precision stops resolving whole metres past 2²⁴. A world larger than that cannot put an
+     * absolute position through one: at 2²⁵ the spacing is four metres, so the camera position
+     * recovered from the matrix is wrong by up to two. Streaming survives it, because
+     * `cellsInRadius` is conservative and four metres against a five-hundred-metre cell only ever
+     * adds a cell — but it is wrong, and it is wrong in exactly the place this mechanism exists for.
+     *
+     * So the views are render-space, relative to this, and the stream adds it back. Zero by default,
+     * which is what every consumer that fits inside single precision already had.
+     */
+    readonly origin: Float64Array;
+    /** Cell identifier to the frame it was last wanted. What the hysteresis counts against. */
+    readonly lastWanted: Map<number, number>;
+    /** Pumps so far. Monotonic, and the only clock this has. */
+    frame: number;
+    readonly grid: CellGrid;
+    /**
+     * The caller's own array, read on every predicted frame — so a lens that zooms or pulls its far
+     * plane in is followed without telling the stream.
+     */
+    readonly projection: ArrayLike<number> | null;
+}
+export declare function createCellStream(options: CellStreamOptions): CellStream;
+/**
+ * Move the origin the predicted views are relative to.
+ *
+ * Called with whatever `renderOrigin` answered for this frame, so the two cannot drift apart. It is
+ * a write rather than a parameter to `needs` because the predictor's shape is `Predictor<number>`
+ * and that interface is Wave 3B's, shared with texture tiles, which have no origin.
+ */
+export declare function setCellStreamOrigin(stream: CellStream, x: number, y: number, z: number): void;
+/**
+ * Where the camera is, out of a view matrix, into `out`.
+ *
+ * **A view matrix is `R · T(−p)`, so its translation column is in *view* space** and negating it is
+ * right only while the camera is unrotated. The camera's world position is `−Rᵀ · t`, and the
+ * transpose is the inverse because a view rotation is orthonormal. Getting this wrong is invisible
+ * in any test whose camera is not turned, and wrong by the whole camera offset in every other.
+ *
+ * Column-major, as `gl-matrix` writes one: `m[0..2]` is the first column.
+ */
+export declare function cameraPositionFrom(view: ArrayLike<number>, out: Float64Array): void;
+/**
+ * The stream as a `Predictor<number>` over cell identifiers.
+ *
+ * Structurally typed on purpose — see the header. A caller passes the result straight to
+ * `runPrediction` from `@driftengine/texture`.
+ */
+export declare function cellPredictor(stream: CellStream): {
+    needs(view: Float32Array, out: number[], budget: number): number;
+    resident(id: number): boolean;
+    request(id: number, priority: number): void;
+};
+/**
+ * Mark what is in range *now*, then drop what has gone unwanted long enough. Returns how many went.
+ *
+ * **The pump marks as well as drops, and the first draft only dropped.** Prediction marks what is
+ * coming; without the pump marking what is here, a camera standing still wants nothing — its
+ * predicted path never leaves the cell it is in, the horizon moves past every cell it already
+ * occupies, and the streamer unloads the ground somebody is standing on. That is not a case to
+ * guard against separately: it is the same question as "what does this camera want", asked about
+ * the present instead of the future.
+ *
+ * So there is no special case for the camera's own cell. `cellsInRadius` includes it at any
+ * radius, including zero, which means the guarantee follows from the marking rather than from a
+ * check somebody could delete without a test failing.
+ */
+export declare function pumpCellStream(stream: CellStream, x: number, y: number, z: number): number;