minecraft-renderer 0.1.106 → 0.1.108

package/src/wasm-mesher/runtime-build/wasm_mesher.js

@@ -86,6 +86,11 @@ function getArrayU16FromWasm0(ptr, len) {
     return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -153,6 +158,10 @@ function handleError(f, args) {
     }
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 function passArray16ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 2, 2) >>> 0;
     getUint16ArrayMemory0().set(arg, ptr / 2);
@@ -247,6 +256,107 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
+const JsLightEngineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jslightengine_free(ptr >>> 0, 1));
+
+export class JsLightEngine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsLightEngineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jslightengine_free(ptr, 0);
+    }
+    /**
+     * @param {any} event
+     */
+    pushEvent(event) {
+        wasm.jslightengine_pushEvent(this.__wbg_ptr, event);
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    getSkyLight(x, y, z) {
+        const ret = wasm.jslightengine_getSkyLight(this.__wbg_ptr, x, y, z);
+        return ret;
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    getBlockLight(x, y, z) {
+        const ret = wasm.jslightengine_getBlockLight(this.__wbg_ptr, x, y, z);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} emission
+     * @param {Uint8Array} opacity
+     */
+    setLightTables(emission, opacity) {
+        const ptr0 = passArray8ToWasm0(emission, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(opacity, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.jslightengine_setLightTables(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * @returns {number}
+     */
+    get fallbackRelights() {
+        const ret = wasm.jslightengine_fallbackRelights(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {Uint8Array} occupancy
+     */
+    setOcclusionTable(occupancy) {
+        const ptr0 = passArray8ToWasm0(occupancy, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jslightengine_setOcclusionTable(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} enabled
+     */
+    setSkyLightEnabled(enabled) {
+        wasm.jslightengine_setSkyLightEnabled(this.__wbg_ptr, enabled);
+    }
+    /**
+     * @returns {any}
+     */
+    pollCompletedPublication() {
+        const ret = wasm.jslightengine_pollCompletedPublication(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} budget_ms
+     * @returns {boolean}
+     */
+    step(budget_ms) {
+        const ret = wasm.jslightengine_step(this.__wbg_ptr, budget_ms);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} world_min_y
+     * @param {number} world_height
+     */
+    constructor(world_min_y, world_height) {
+        const ret = wasm.jslightengine_js_new(world_min_y, world_height);
+        this.__wbg_ptr = ret >>> 0;
+        JsLightEngineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) JsLightEngine.prototype[Symbol.dispose] = JsLightEngine.prototype.free;
+
 /**
  * Compute wireframe edge positions from a triangle mesh.
  *
@@ -879,11 +989,11 @@ export function parseMapChunkV18Plus(raw_packet, num_sections, max_bits_per_bloc
  * `raw_packet` includes the leading packet-id varint (we skip it).
  * `num_sections` should match the column the light is for (16 in 1.17).
  *
- * Returns `{ x, z, skyLight: Uint8Array(num_sections * 4096),
- *            blockLight: Uint8Array(num_sections * 4096), bytesRead }`.
- * Layout matches the existing 1.18+ light arrays
- * (`x + z*16 + y_abs*256`); the JS-side worker reorders into per-section
- * stack via the same path used for 1.18+ raw map_chunk parsing.
+ * Returns `{ x, z, trustEdges, skyLight, blockLight, skyLightMask,
+ *            emptySkyLightMask, blockLightMask, emptyBlockLightMask,
+ *            skyBelow?, skyAbove?, blockBelow?, blockAbove?, bytesRead }`.
+ * World arrays are `num_sections * 4096` (`x + z*16 + y_abs*256`).
+ * Omitted sections are left 0 and are not authoritative — use the masks.
  * @param {Uint8Array} raw_packet
  * @param {number} num_sections
  * @returns {any}
@@ -948,6 +1058,11 @@ function __wbg_get_imports() {
         const ret = Error(getStringFromWasm0(arg0, arg1));
         return ret;
     };
+    imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+        const v = arg0;
+        const ret = typeof(v) === 'boolean' ? v : undefined;
+        return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+    };
     imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
         const ret = debugString(arg1);
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -955,6 +1070,28 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
+        const ret = arg0 === null;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
+    imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
@@ -962,6 +1099,10 @@ function __wbg_get_imports() {
         const ret = arg0[arg1 >>> 0];
         return ret;
     };
+    imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_instanceof_Int32Array_b6281022039fba32 = function(arg0) {
         let result;
         try {
@@ -990,6 +1131,10 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
+    imports.wbg.__wbg_length_89c3414ed7f0594d = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
     imports.wbg.__wbg_length_ab53989976907f11 = function(arg0) {
         const ret = arg0.length;
         return ret;
@@ -1002,10 +1147,26 @@ function __wbg_get_imports() {
         const ret = new Array();
         return ret;
     };
+    imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+        const ret = new Uint8Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_9f7fd5c3a6ba7298 = function(arg0) {
+        const ret = new Uint16Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_from_slice_e6bd3cfb5a35313d = function(arg0, arg1) {
+        const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
+        return ret;
+    };
     imports.wbg.__wbg_new_with_length_1e8603a5c71d4e06 = function(arg0) {
         const ret = new Int32Array(arg0 >>> 0);
         return ret;
     };
+    imports.wbg.__wbg_new_with_length_202b3db94ba5fc86 = function(arg0) {
+        const ret = new Uint32Array(arg0 >>> 0);
+        return ret;
+    };
     imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return ret;
@@ -1014,12 +1175,23 @@ function __wbg_get_imports() {
         const ret = new Uint16Array(arg0 >>> 0);
         return ret;
     };
+    imports.wbg.__wbg_now_69d776cd24f5215b = function() {
+        const ret = Date.now();
+        return ret;
+    };
+    imports.wbg.__wbg_prototypesetcall_b0bea5f39077cfd3 = function(arg0, arg1, arg2) {
+        Uint16Array.prototype.set.call(getArrayU16FromWasm0(arg0, arg1), arg2);
+    };
     imports.wbg.__wbg_prototypesetcall_dd07c344a74d4bfd = function(arg0, arg1, arg2) {
         Int32Array.prototype.set.call(getArrayI32FromWasm0(arg0, arg1), arg2);
     };
     imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
         Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
     };
+    imports.wbg.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
+        const ret = arg0.push(arg1);
+        return ret;
+    };
     imports.wbg.__wbg_set_169e13b608078b7b = function(arg0, arg1, arg2) {
         arg0.set(getArrayU8FromWasm0(arg1, arg2));
     };
@@ -1036,6 +1208,9 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_set_bb0c6a7fe60d81b5 = function(arg0, arg1, arg2) {
         arg0.set(getArrayU16FromWasm0(arg1, arg2));
     };
+    imports.wbg.__wbg_set_e7cd108182596b7f = function(arg0, arg1, arg2) {
+        arg0.set(getArrayU32FromWasm0(arg1, arg2));
+    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);

package/src/wasm-mesher/runtime-build/wasm_mesher_bg.wasm.d.ts

@@ -2,6 +2,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_jslightengine_free: (a: number, b: number) => void;
 export const computeWireframeEdges: (a: number, b: number, c: number, d: number) => [number, number];
 export const computeWireframeEdgesU16: (a: number, b: number, c: number, d: number) => [number, number];
 export const generateGeometryFromDump118: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number, i1: number, j1: number, k1: number) => any;
@@ -11,6 +12,16 @@ export const generateGeometryFromParsedV16V17: (a: number, b: number, c: number,
 export const generateGeometryFromParsedV16V17Multi: (a: any, b: number, c: number, d: number, e: number, f: number, g: any, h: number, i: any, j: any, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number) => any;
 export const generate_geometry: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number) => any;
 export const generate_geometry_multi: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number) => any;
+export const jslightengine_fallbackRelights: (a: number) => number;
+export const jslightengine_getBlockLight: (a: number, b: number, c: number, d: number) => number;
+export const jslightengine_getSkyLight: (a: number, b: number, c: number, d: number) => number;
+export const jslightengine_js_new: (a: number, b: number) => number;
+export const jslightengine_pollCompletedPublication: (a: number) => any;
+export const jslightengine_pushEvent: (a: number, b: any) => void;
+export const jslightengine_setLightTables: (a: number, b: number, c: number, d: number, e: number) => void;
+export const jslightengine_setOcclusionTable: (a: number, b: number, c: number) => void;
+export const jslightengine_setSkyLightEnabled: (a: number, b: number) => void;
+export const jslightengine_step: (a: number, b: number) => number;
 export const parseChunkDump118: (a: number, b: number, c: number, d: number, e: number) => any;
 export const parseChunkDump118FullColumn: (a: number, b: number, c: number, d: number, e: number) => any;
 export const parseChunkDump118FullColumnAll: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number) => any;

package/src/wasm-mesher/tests/mesherLightDependencies.test.ts

@@ -0,0 +1,83 @@
+//@ts-nocheck
+import { describe, expect, test } from 'vitest'
+import { provenMeshLightVersion } from '../worker/mesherLightDependencies'
+
+function prove(sx: number, sz: number, used: string[], applied: Array<[string, number]>) {
+  return provenMeshLightVersion({
+    sx,
+    sz,
+    usedColumns: new Set(used),
+    appliedVersionByColumn: new Map(applied)
+  })
+}
+
+describe('provenMeshLightVersion', () => {
+  test('a bootstrap neighbor wall takes the published column version when that column was meshed', () => {
+    expect(prove(16, 0, ['0,0', '16,0'], [['0,0', 10]])).toBe(10)
+    expect(prove(0, 16, ['0,0', '0,16'], [['0,0', 8]])).toBe(8)
+  })
+
+  test('negative chunk coordinates use the same column keys', () => {
+    expect(prove(-16, -32, ['-32,-32', '-16,-32'], [['-32,-32', 7]])).toBe(7)
+  })
+
+  test('an unused published column is not proof, even if a dirty job requested that version', () => {
+    expect(prove(16, 0, ['16,0'], [['0,0', 10]])).toBe(0)
+  })
+
+  test('an older own-column version does not hide a newer neighbor publication that was meshed', () => {
+    expect(
+      prove(
+        16,
+        0,
+        ['0,0', '16,0'],
+        [
+          ['16,0', 4],
+          ['0,0', 10]
+        ]
+      )
+    ).toBe(10)
+  })
+
+  test('a later own publication does not cover an earlier neighbor that was left out of the mesh', () => {
+    expect(
+      prove(
+        16,
+        0,
+        ['16,0'],
+        [
+          ['0,0', 10],
+          ['16,0', 12]
+        ]
+      )
+    ).toBe(0)
+  })
+
+  test('a used column older than the missing neighbor still counts', () => {
+    expect(
+      prove(
+        16,
+        0,
+        ['16,0'],
+        [
+          ['0,0', 10],
+          ['16,0', 4]
+        ]
+      )
+    ).toBe(4)
+  })
+
+  test('a far column publication does not raise the stamp', () => {
+    expect(prove(0, 0, ['0,0', '100,100'], [['100,100', 100]])).toBe(0)
+  })
+
+  test('forgetting a column drops it from later proofs', () => {
+    const applied = new Map<string, number>([
+      ['0,0', 10],
+      ['16,0', 10]
+    ])
+    applied.delete('0,0')
+    expect(prove(16, 0, ['16,0'], [...applied.entries()])).toBe(10)
+    expect(prove(0, 0, ['0,0'], [...applied.entries()])).toBe(0)
+  })
+})

package/src/wasm-mesher/tests/mesherWasmColumnTickSelect.test.ts

@@ -0,0 +1,39 @@
+//@ts-nocheck
+import { describe, expect, test } from 'vitest'
+import { BULK_COLUMNS_PER_TICK, selectColumnGroupsForTick } from '../worker/mesherWasmColumnTickSelect'
+
+function dirtyOf(keys: string[]): Map<string, number> {
+  const dirty = new Map<string, number>()
+  for (const key of keys) dirty.set(key, 1)
+  return dirty
+}
+
+describe('selectColumnGroupsForTick', () => {
+  test('urgent columns are selected before bulk columns', () => {
+    const dirty = dirtyOf(['160,64,0', '0,64,0', '32,64,0'])
+    const urgent = new Set(['0,64,0'])
+    const { selected, remaining } = selectColumnGroupsForTick(dirty, urgent, 4)
+    expect(selected.map(group => `${group.x},${group.z}`)).toEqual(['0,0', '160,0', '32,0'])
+    expect(remaining.size).toBe(0)
+  })
+
+  test('a tick leaves leftover bulk columns for the next tick', () => {
+    const keys = ['0,64,0', '16,64,0', '32,64,0', '48,64,0', '64,64,0', '80,64,0']
+    const dirty = dirtyOf(keys)
+    const first = selectColumnGroupsForTick(dirty, new Set(), BULK_COLUMNS_PER_TICK)
+    expect(first.selected).toHaveLength(4)
+    expect([...first.remaining.keys()]).toEqual(['64,64,0', '80,64,0'])
+    const second = selectColumnGroupsForTick(first.remaining, new Set(), BULK_COLUMNS_PER_TICK)
+    expect(second.selected.map(group => `${group.x},${group.z}`)).toEqual(['64,0', '80,0'])
+    expect(second.remaining.size).toBe(0)
+  })
+
+  test('urgent still wins when the same key also has bulk dirties', () => {
+    const dirty = dirtyOf(['16,64,0', '0,64,0', '32,64,0', '48,64,0', '64,64,0', '80,64,0', '96,64,0'])
+    dirty.set('0,64,0', 2)
+    const { selected, remaining } = selectColumnGroupsForTick(dirty, new Set(['0,64,0']), 4)
+    expect(selected[0]).toMatchObject({ x: 0, z: 0 })
+    expect(selected).toHaveLength(5)
+    expect([...remaining.keys()]).toEqual(['80,64,0', '96,64,0'])
+  })
+})

package/src/wasm-mesher/tests/mesherWasmConversionCache.test.ts

@@ -5,7 +5,8 @@ import {
   _peekConversionCache,
   clearConversionCache,
   getOrConvertColumn,
-  invalidateConversion
+  invalidateConversion,
+  patchConversionBlock
 } from '../worker/mesherWasmConversionCache'
 import type { ChunkConversionResult } from '../bridge/convertChunk'
 
@@ -27,6 +28,34 @@ describe('mesherWasmConversionCache', () => {
     clearConversionCache()
   })
 
+  test('patches state and count in place and rejects identity drift', () => {
+    const ref = {}
+    const result = { ...makeResult(0), blockStates: new Uint16Array(4096) }
+    getOrConvertColumn(-16, 0, ref, 'v', -64, -48, () => result, ref)
+    expect(patchConversionBlock(-16, 0, ref, -1, -49, 15, 2)).toBe(true)
+    expect(result.blockStates[4095]).toBe(2)
+    expect(result.blockCount).toBe(1)
+    patchConversionBlock(-16, 0, ref, -1, -49, 15, 3)
+    expect(result.blockCount).toBe(1)
+    expect(patchConversionBlock(-16, 0, {}, -1, -49, 15, 0)).toBe(false)
+    patchConversionBlock(-16, 0, ref, -1, -49, 15, 0)
+    expect(result.blockCount).toBe(0)
+    expect(
+      getOrConvertColumn(
+        -16,
+        0,
+        ref,
+        'v',
+        -64,
+        -48,
+        () => {
+          throw new Error('unexpected conversion')
+        },
+        ref
+      ).result
+    ).toBe(result)
+  })
+
   test('miss then hit on same chunk ref returns cached result', () => {
     const ref = { id: 'chunk-a' }
     let calls = 0

package/src/wasm-mesher/tests/mesherWasmTickParseCache.test.ts

@@ -0,0 +1,73 @@
+//@ts-nocheck
+import { afterEach, describe, expect, test } from 'vitest'
+import { beginTickWasmParseCache, endTickWasmParseCache, getOrConvertTickWasmParse, getTickWasmParseStats } from '../worker/mesherWasmTickParseCache'
+
+afterEach(() => {
+  endTickWasmParseCache()
+})
+
+describe('mesherWasmTickParseCache', () => {
+  test('second convert of the same column in one tick is a hit without copying', () => {
+    beginTickWasmParseCache()
+    let calls = 0
+    const convert = () => {
+      calls++
+      return { tag: calls }
+    }
+    const a = getOrConvertTickWasmParse('0,0', convert)
+    const b = getOrConvertTickWasmParse('0,0', convert)
+    expect(a.hit).toBe(false)
+    expect(b.hit).toBe(true)
+    expect(calls).toBe(1)
+    expect(b.result).toBe(a.result)
+    expect(getTickWasmParseStats()).toEqual({ hits: 1, misses: 1 })
+  })
+
+  test('distinct columns miss independently and unique-column count matches the cache', () => {
+    beginTickWasmParseCache()
+    let calls = 0
+    const convert = () => {
+      calls++
+      return { tag: calls }
+    }
+    for (let i = 0; i < 9; i++) getOrConvertTickWasmParse(`${i * 16},0`, convert)
+    for (let i = 0; i < 9; i++) getOrConvertTickWasmParse(`${i * 16},0`, convert)
+    expect(calls).toBe(9)
+    expect(getTickWasmParseStats()).toEqual({ hits: 9, misses: 9 })
+  })
+
+  test('null results are not cached so a later convert can recover', () => {
+    beginTickWasmParseCache()
+    let calls = 0
+    const a = getOrConvertTickWasmParse('16,16', () => {
+      calls++
+      return null
+    })
+    const b = getOrConvertTickWasmParse('16,16', () => {
+      calls++
+      return { tag: 1 }
+    })
+    expect(a.result).toBeNull()
+    expect(a.hit).toBe(false)
+    expect(b.hit).toBe(false)
+    expect(b.result).toEqual({ tag: 1 })
+    expect(calls).toBe(2)
+  })
+
+  test('end of tick drops entries so the next tick misses', () => {
+    beginTickWasmParseCache()
+    let calls = 0
+    getOrConvertTickWasmParse('0,0', () => {
+      calls++
+      return { tag: 1 }
+    })
+    endTickWasmParseCache()
+    beginTickWasmParseCache()
+    getOrConvertTickWasmParse('0,0', () => {
+      calls++
+      return { tag: 2 }
+    })
+    expect(calls).toBe(2)
+    expect(getTickWasmParseStats()).toEqual({ hits: 0, misses: 1 })
+  })
+})

package/src/wasm-mesher/tests/mesherWasmTickSchedule.test.ts

@@ -0,0 +1,51 @@
+//@ts-nocheck
+import { describe, expect, test, vi } from 'vitest'
+import { BULK_MESH_INTERVAL_MS, createMeshTickScheduler } from '../worker/mesherWasmTickSchedule'
+
+describe('createMeshTickScheduler', () => {
+  test('an urgent kick runs on the next turn, before the bulk poll interval', async () => {
+    vi.useFakeTimers()
+    try {
+      let runs = 0
+      const scheduler = createMeshTickScheduler(() => {
+        runs++
+      })
+      scheduler.kick()
+      expect(runs).toBe(0)
+      await vi.advanceTimersByTimeAsync(0)
+      expect(runs).toBe(1)
+      expect(BULK_MESH_INTERVAL_MS).toBeGreaterThan(0)
+    } finally {
+      vi.clearAllTimers()
+      vi.useRealTimers()
+    }
+  })
+
+  test('a kick during a running tick runs again after that tick finishes', async () => {
+    vi.useFakeTimers()
+    try {
+      let release: () => void = () => {}
+      const gate = new Promise<void>(resolve => {
+        release = resolve
+      })
+      let runs = 0
+      const scheduler = createMeshTickScheduler(() => {
+        runs++
+        if (runs === 1) {
+          scheduler.kick()
+          return gate
+        }
+      })
+      scheduler.kick()
+      await vi.advanceTimersByTimeAsync(0)
+      expect(runs).toBe(1)
+      release()
+      await gate
+      await Promise.resolve()
+      expect(runs).toBe(2)
+    } finally {
+      vi.clearAllTimers()
+      vi.useRealTimers()
+    }
+  })
+})

package/src/wasm-mesher/tests/mesherWasmTopologyPostCache.test.ts

@@ -0,0 +1,78 @@
+//@ts-nocheck
+import { afterEach, describe, expect, test } from 'vitest'
+import {
+  TOPOLOGY_POST_CACHE_LIMIT,
+  clearTopologyPostCache,
+  clearTopologyPostCacheColumn,
+  getOrComputeTopologyPost
+} from '../worker/mesherWasmTopologyPostCache'
+
+afterEach(() => {
+  clearTopologyPostCache()
+})
+
+describe('mesherWasmTopologyPostCache', () => {
+  test('second pass with the same revision does not walk', () => {
+    let walks = 0
+    const compute = () => {
+      walks++
+      return { visibilitySet: 1, signs: { a: walks }, heads: {}, banners: {} }
+    }
+    const first = getOrComputeTopologyPost('0,64,0', 4, compute)
+    const second = getOrComputeTopologyPost('0,64,0', 4, compute)
+    expect(walks).toBe(1)
+    expect(first.hit).toBe(false)
+    expect(second.hit).toBe(true)
+    expect(second.payload).toBe(first.payload)
+  })
+
+  test('revision change walks again', () => {
+    let walks = 0
+    const compute = () => {
+      walks++
+      return { visibilitySet: walks, signs: {}, heads: {}, banners: {} }
+    }
+    getOrComputeTopologyPost('0,64,0', 4, compute)
+    const next = getOrComputeTopologyPost('0,64,0', 5, compute)
+    expect(walks).toBe(2)
+    expect(next.hit).toBe(false)
+    expect(next.payload.visibilitySet).toBe(2)
+  })
+
+  test('missing revision always walks and does not cache', () => {
+    let walks = 0
+    const compute = () => {
+      walks++
+      return { visibilitySet: walks, signs: {}, heads: {}, banners: {} }
+    }
+    getOrComputeTopologyPost('0,64,0', undefined, compute)
+    getOrComputeTopologyPost('0,64,0', undefined, compute)
+    expect(walks).toBe(2)
+  })
+
+  test('unload of a column clears its cached sections', () => {
+    let walks = 0
+    const compute = () => {
+      walks++
+      return { visibilitySet: walks, signs: {}, heads: {}, banners: {} }
+    }
+    getOrComputeTopologyPost('0,64,0', 3, compute)
+    getOrComputeTopologyPost('16,64,0', 3, compute)
+    clearTopologyPostCacheColumn(0, 0)
+    getOrComputeTopologyPost('0,64,0', 3, compute)
+    getOrComputeTopologyPost('16,64,0', 3, compute)
+    expect(walks).toBe(3)
+  })
+
+  test('evicts oldest entries past the cap', () => {
+    for (let i = 0; i < TOPOLOGY_POST_CACHE_LIMIT + 3; i++) {
+      getOrComputeTopologyPost(`${i},64,0`, 1, () => ({ visibilitySet: i, signs: {}, heads: {}, banners: {} }))
+    }
+    let walks = 0
+    getOrComputeTopologyPost('0,64,0', 1, () => {
+      walks++
+      return { visibilitySet: -1, signs: {}, heads: {}, banners: {} }
+    })
+    expect(walks).toBe(1)
+  })
+})