@woosh/meep-engine 3.29.0 → 3.31.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.29.0",
+  "version": "3.31.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",
@@ -26,6 +26,8 @@
     "generate-types": "tsc --project tsconfig.types.json",
     "check-types": "node scripts/check-types.mjs",
     "test": "vitest run",
+    "test:extended": "vitest run --mode extended",
+    "test:all": "vitest run --mode all",
     "dev": "vite"
   },
   "browserslist": [

package/src/core/binary/BinaryBuffer.d.ts.map

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

package/src/core/binary/BinaryBuffer.js

@@ -22,6 +22,14 @@ const MIN_GROWTH_STEP = 1024;
  */
 const MAX_SAFE_UINT_VAR = 2147483647;
 
+/**
+ * Highest shift {@link BinaryBuffer#readUintVar} will accept. MAX_SAFE_UINT_VAR occupies 31 bits,
+ * which is 5 groups of 7, so the last group starts at bit 28. A continuation flag past that
+ * means the stream is not a uintVar this buffer wrote.
+ * @type {number}
+ */
+const MAX_SHIFT_UINT_VAR = 28;
+
 /**
  * @readonly
  * @type {number}
@@ -189,16 +197,20 @@ export class BinaryBuffer {
         const oldData = this.__data_uint8;
         const newData = new Uint8Array(capacity);
 
-        if (this.position > 0) {
+        // Copy everything that fits, not just what lies below `position`. Callers seek backwards
+        // to patch a header and then keep writing, and clamping at the cursor would drop the
+        // tail they already wrote.
+        const retained = Math.min(
+            oldData.buffer.byteLength,
+            newData.buffer.byteLength
+        );
+
+        if (retained > 0) {
             //copy old data
             array_buffer_copy(
                 oldData.buffer, 0,
                 newData.buffer, 0,
-                Math.min(
-                    oldData.buffer.byteLength,
-                    newData.buffer.byteLength,
-                    this.position
-                )
+                retained
             );
         }
 
@@ -974,8 +986,20 @@ export class BinaryBuffer {
      * @param {number} value must be an unsigned integer
      */
     writeUintVar(value) {
-        assert.isNonNegativeInteger(value, 'value');
-        assert.ok(value <= MAX_SAFE_UINT_VAR, `value=[${value}] exceeds maximum safe limit[=${MAX_SAFE_UINT_VAR}]`);
+        /**
+         * Deliberately an ordinary throw and not an `assert.*`: the accumulator below uses a signed
+         * `>>=`, so a value at or above 2^31 coerces to a negative int32 and `-1 >> 7 === -1` spins
+         * the loop forever, writing 0x80 until the heap gives out. The consumer strips asserts, so a
+         * strippable guard is no guard at all in the build that ships. `MAX_SAFE_UINT_VAR` is 2^31-1,
+         * which is also the ceiling {@link #readUintVar} can reconstruct, so this is the format's
+         * own limit rather than a conservative one.
+         *
+         * `(value | 0) !== value` catches non-integers, NaN and anything outside int32 in one test;
+         * `value < 0` takes the negative half of that range.
+         */
+        if ((value | 0) !== value || value < 0) {
+            throw new RangeError(`value=[${value}] must be an integer in [0, ${MAX_SAFE_UINT_VAR}]`);
+        }
 
         let first = true;
         let _v = value;
@@ -1011,11 +1035,20 @@ export class BinaryBuffer {
             //read carry-over flag
             more = (lower7bits & 128) !== 0;
 
-            //read value part of the byte
-            value |= (lower7bits & 0x7f) << shift;
+            // Accumulate by multiplication rather than `|= x << shift`: JS takes shift counts
+            // modulo 32, so the fifth group would wrap back over the low bits, and `|=` would
+            // coerce the result to a signed int32.
+            value += (lower7bits & 0x7f) * (2 ** shift);
 
             //increment shift
             shift += 7;
+
+            if (more && shift > MAX_SHIFT_UINT_VAR) {
+                // Deliberately not an `assert` - those are stripped by the consumer, and a
+                // corrupt stream must not be able to run this loop off the end of the buffer.
+                // `writeUintVar` caps at MAX_SAFE_UINT_VAR, which is 5 groups.
+                throw new Error(`uintVar is too long, more than ${(MAX_SHIFT_UINT_VAR / 7) + 1} bytes`);
+            }
         }
 
         return value;
@@ -1142,6 +1175,14 @@ export class BinaryBuffer {
 
         const uint8 = this.__data_uint8;
 
+        if (length < 0 || end > this.capacity) {
+            // Deliberately not an `assert` - those are stripped by the consumer, and a truncated
+            // or corrupt stream has to fail in a stripped build too. Every scalar read goes
+            // through `DataView` and throws `RangeError` past the end; this path goes through
+            // `Uint8Array`, which would silently zero-fill instead.
+            throw new Error(`Attempting to read ${length} bytes at position ${source_position}, only ${this.capacity - source_position} available`);
+        }
+
         if (length < 128) {
             // small copy
             array_copy(uint8, source_position, destination, destination_offset, length);
@@ -1217,9 +1258,7 @@ export class BinaryBuffer {
             // expand the buffer if we couldn't write 4 bytes
             if (cursor + 4 > capacity) {
 
-                // setCapacity only preserves bytes below `position`, and the
-                // loop writes ahead of it, so publish the cursor first or the
-                // string body written so far is dropped by the reallocation
+                // keep `position` in step with the local cursor across the reallocation
                 this.position = cursor;
 
                 this.ensureCapacity(cursor + 4);
@@ -1284,9 +1323,10 @@ export class BinaryBuffer {
             const byte1 = bytes[i++];
             let codePoint;
 
-            if (byte1 === 0) {
-                break;  // NULL
-            }
+            // NOTE: there is no NUL sentinel here on purpose. `writeUTF8String` writes a
+            // code-unit count up front and encodes U+0000 as a single 0x00 byte, so breaking on
+            // a zero byte would leave `position` short of the record and desynchronise every
+            // field after it. The count is what bounds this loop.
 
             if ((byte1 & 0x80) === 0) {  // 1-byte
                 codePoint = byte1;

package/src/core/binary/BitImage2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BitImage2.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitImage2.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;OAGG;IACH,mBAHW,MAAM,UACN,MAAM,EAUhB;IAJG,cAAkB;IAClB,eAAoB;IACpB,sBAAuD;IACvD,kBAAqE;IAGzE;;;;OAIG;IACH,OAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,OAHW,MAAM,KACN,MAAM,QAIhB;IAED,sBAAsB;IACtB,cAEC;IAED,2CAA2C;IAC3C,eADc,MAAM,CAanB;IAED;;;;;;;;OAQG;IACH,eALW,SAAS,MACT,MAAM,MACN,MAAM,GACJ,OAAO,CAkCnB;IAED;;;;;;;OAOG;IACH,eAJW,SAAS,MACT,MAAM,MACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,eAFW,MAAM,QA0BhB;IAED;;;;;;;OAOG;IACH,2BAHW,MAAM,cACN,MAAM,QA0BhB;IAED;;;;;;OAMG;IACH,cAFa,SAAS,CAMrB;IAED;;;;;;OAMG;IACH,qBAFW,SAAS,QAcnB;CACJ"}
+{"version":3,"file":"BitImage2.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitImage2.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;OAGG;IACH,mBAHW,MAAM,UACN,MAAM,EAUhB;IAJG,cAAkB;IAClB,eAAoB;IACpB,sBAAuD;IACvD,kBAAqE;IAGzE;;;;OAIG;IACH,OAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,OAHW,MAAM,KACN,MAAM,QAIhB;IAED,sBAAsB;IACtB,cAEC;IAED,2CAA2C;IAC3C,eADc,MAAM,CAQnB;IAED;;;;;;;;OAQG;IACH,eALW,SAAS,MACT,MAAM,MACN,MAAM,GACJ,OAAO,CAkCnB;IAED;;;;;;;OAOG;IACH,eAJW,SAAS,MACT,MAAM,MACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,eAFW,MAAM,QA0BhB;IAED;;;;;;;OAOG;IACH,2BAHW,MAAM,cACN,MAAM,QA0BhB;IAED;;;;;;OAMG;IACH,cAFa,SAAS,CAMrB;IAED;;;;;;OAMG;IACH,qBAFW,SAAS,QAcnB;CACJ"}

package/src/core/binary/BitImage2.js

@@ -1,4 +1,5 @@
 import { assert } from "../assert.js";
+import { bitCount } from "./operations/bitCount.js";
 
 /**
  * A 2D bitmap with word-packed rows (one bit per cell), built for atlas
@@ -59,12 +60,7 @@ export class BitImage2 {
         const data = this.data;
         let count = 0;
         for (let i = 0; i < data.length; i++) {
-            let w = data[i];
-            // Hamming weight (SWAR popcount)
-            w = w - ((w >>> 1) & 0x55555555);
-            w = (w & 0x33333333) + ((w >>> 2) & 0x33333333);
-            w = (w + (w >>> 4)) & 0x0f0f0f0f;
-            count += (Math.imul(w, 0x01010101) >>> 24);
+            count += bitCount(data[i]);
         }
         return count;
     }

package/src/core/binary/BitSet.js

@@ -2,7 +2,7 @@ import { assert } from "../assert.js";
 import { max3 } from "../math/max3.js";
 import { min2 } from "../math/min2.js";
 import { align_32 } from "./align_32.js";
-import { lsb_32 } from "./lsb_32.js";
+import { ctz32 } from "./ctz32.js";
 import { bitCount } from "./operations/bitCount.js";
 
 /**
@@ -368,7 +368,7 @@ export class BitSet {
             const masked_word = data[word_index] & fill_mask;
 
             if (masked_word !== 0) {
-                bit_index = lsb_32(masked_word);
+                bit_index = ctz32(masked_word);
                 return (word_index << 5) + bit_index;
             }
 
@@ -386,7 +386,7 @@ export class BitSet {
                 continue;
             }
 
-            bit_index = lsb_32(word);
+            bit_index = ctz32(word);
 
             bit_address = (word_index << 5) + bit_index;
 
@@ -426,7 +426,7 @@ export class BitSet {
             const masked_word = (word | fill_mask) >>> 0;
 
             if (masked_word !== 4294967295) {
-                bit_index = lsb_32(~masked_word);
+                bit_index = ctz32(~masked_word);
                 return bit_index + word_index * 32;
             }
 
@@ -460,7 +460,7 @@ export class BitSet {
                     continue;
                 }
 
-                bit_index = lsb_32(~word);
+                bit_index = ctz32(~word);
                 return bit_index + word_index * 32;
             }
         }

package/src/core/binary/compression/chunks_to_stream.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Present an array of byte views as a `ReadableStream`, one chunk per `pull`.
+ *
+ * Every entry point in this directory feeds its input to the platform's compression API this way
+ * rather than as a sequence of awaited writes, and this is the reason: a pipe settles both sides
+ * together, so a failure while reading the output cancels the input instead of deadlocking on
+ * backpressure, and the source is only asked for a chunk when the transform has room for one, so a
+ * large input is never resident twice.
+ *
+ * `pull` is deliberately the only method. Enqueueing everything up front from `start` would hand
+ * the whole input to the stream's internal queue at once, which is the buffering this shape exists
+ * to avoid.
+ *
+ * The chunks are not copied, so the views must remain unchanged until whatever consumes the stream
+ * has settled.
+ *
+ * @param {Uint8Array[]} chunks
+ * @returns {ReadableStream<Uint8Array>}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function chunks_to_stream(chunks: Uint8Array[]): ReadableStream<Uint8Array>;
+//# sourceMappingURL=chunks_to_stream.d.ts.map

package/src/core/binary/compression/chunks_to_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunks_to_stream.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/compression/chunks_to_stream.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yCANW,UAAU,EAAE,GACV,eAAe,UAAU,CAAC,CAiBtC"}

package/src/core/binary/compression/chunks_to_stream.js

@@ -0,0 +1,35 @@
+/**
+ * Present an array of byte views as a `ReadableStream`, one chunk per `pull`.
+ *
+ * Every entry point in this directory feeds its input to the platform's compression API this way
+ * rather than as a sequence of awaited writes, and this is the reason: a pipe settles both sides
+ * together, so a failure while reading the output cancels the input instead of deadlocking on
+ * backpressure, and the source is only asked for a chunk when the transform has room for one, so a
+ * large input is never resident twice.
+ *
+ * `pull` is deliberately the only method. Enqueueing everything up front from `start` would hand
+ * the whole input to the stream's internal queue at once, which is the buffering this shape exists
+ * to avoid.
+ *
+ * The chunks are not copied, so the views must remain unchanged until whatever consumes the stream
+ * has settled.
+ *
+ * @param {Uint8Array[]} chunks
+ * @returns {ReadableStream<Uint8Array>}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function chunks_to_stream(chunks) {
+    let index = 0;
+
+    return new ReadableStream({
+        pull(controller) {
+            if (index === chunks.length) {
+                controller.close();
+            } else {
+                controller.enqueue(chunks[index++]);
+            }
+        }
+    });
+}

package/src/core/binary/compression/compress_bytes.d.ts

@@ -1,10 +1,9 @@
 /**
  * Compress pieces of one stream using the platform's compression API.
  *
- * The mirror of {@link decompress_bytes}, and written the same way for the same reason: the input
- * goes through a pipe rather than a sequence of awaited writes, so that a failure on either side
- * settles the other instead of deadlocking on backpressure. The input views must remain unchanged
- * until the returned promise settles.
+ * The mirror of {@link decompress_bytes}. Both feed the input through {@link chunks_to_stream},
+ * whose docblock holds the reason for the pipe. The input views must remain unchanged until the
+ * returned promise settles.
  *
  * There is no compression level here because the platform API does not expose one — `deflate-raw`
  * is whatever the host's zlib defaults to. A caller that needs a level needs a different encoder.

package/src/core/binary/compression/compress_bytes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compress_bytes.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/compression/compress_bytes.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,uCAPW,UAAU,EAAE,WACZ,SAAS,GAAC,aAAa,GAAC,MAAM,GAC5B,QAAQ,UAAU,CAAC,CAqB/B"}
+{"version":3,"file":"compress_bytes.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/compression/compress_bytes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,uCAPW,UAAU,EAAE,WACZ,SAAS,GAAC,aAAa,GAAC,MAAM,GAC5B,QAAQ,UAAU,CAAC,CAS/B"}

package/src/core/binary/compression/compress_bytes.js

@@ -1,10 +1,11 @@
+import { chunks_to_stream } from "./chunks_to_stream.js";
+
 /**
  * Compress pieces of one stream using the platform's compression API.
  *
- * The mirror of {@link decompress_bytes}, and written the same way for the same reason: the input
- * goes through a pipe rather than a sequence of awaited writes, so that a failure on either side
- * settles the other instead of deadlocking on backpressure. The input views must remain unchanged
- * until the returned promise settles.
+ * The mirror of {@link decompress_bytes}. Both feed the input through {@link chunks_to_stream},
+ * whose docblock holds the reason for the pipe. The input views must remain unchanged until the
+ * returned promise settles.
  *
  * There is no compression level here because the platform API does not expose one — `deflate-raw`
  * is whatever the host's zlib defaults to. A caller that needs a level needs a different encoder.
@@ -17,19 +18,7 @@
  * @copyright Company Named Limited (c) 2026
  */
 export async function compress_bytes(chunks, format = "deflate") {
-    let index = 0;
-
-    const input = new ReadableStream({
-        pull(controller) {
-            if (index === chunks.length) {
-                controller.close();
-            } else {
-                controller.enqueue(chunks[index++]);
-            }
-        }
-    });
-
-    const output = input.pipeThrough(new CompressionStream(format));
+    const output = chunks_to_stream(chunks).pipeThrough(new CompressionStream(format));
 
     return new Uint8Array(await new Response(output).arrayBuffer());
 }

package/src/core/binary/compression/decompress_bytes.d.ts

@@ -1,8 +1,7 @@
 /**
  * Decompress pieces of one stream using the platform's compression API.
  *
- * Feed the input through a pipe so that read failures also cancel the input and settle the
- * writable side. Awaiting writes before draining the output can deadlock on backpressure.
+ * The input goes through {@link chunks_to_stream}, whose docblock holds the reason for the pipe.
  * The input views must remain unchanged until the returned promise settles.
  *
  * @param {Uint8Array[]} chunks

package/src/core/binary/compression/decompress_bytes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decompress_bytes.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/compression/decompress_bytes.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,yCAJW,UAAU,EAAE,WACZ,SAAS,GAAC,aAAa,GAAC,MAAM,GAC5B,QAAQ,UAAU,CAAC,CAkB/B"}
+{"version":3,"file":"decompress_bytes.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/compression/decompress_bytes.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,yCAJW,UAAU,EAAE,WACZ,SAAS,GAAC,aAAa,GAAC,MAAM,GAC5B,QAAQ,UAAU,CAAC,CAM/B"}

package/src/core/binary/compression/decompress_bytes.js

@@ -1,8 +1,9 @@
+import { chunks_to_stream } from "./chunks_to_stream.js";
+
 /**
  * Decompress pieces of one stream using the platform's compression API.
  *
- * Feed the input through a pipe so that read failures also cancel the input and settle the
- * writable side. Awaiting writes before draining the output can deadlock on backpressure.
+ * The input goes through {@link chunks_to_stream}, whose docblock holds the reason for the pipe.
  * The input views must remain unchanged until the returned promise settles.
  *
  * @param {Uint8Array[]} chunks
@@ -10,19 +11,7 @@
  * @returns {Promise<Uint8Array>}
  */
 export async function decompress_bytes(chunks, format = "deflate") {
-    let index = 0;
-
-    const input = new ReadableStream({
-        pull(controller) {
-            if (index === chunks.length) {
-                controller.close();
-            } else {
-                controller.enqueue(chunks[index++]);
-            }
-        }
-    });
-
-    const output = input.pipeThrough(new DecompressionStream(format));
+    const output = chunks_to_stream(chunks).pipeThrough(new DecompressionStream(format));
 
     return new Uint8Array(await new Response(output).arrayBuffer());
 }

package/src/core/binary/compression/decompress_bytes_into.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decompress_bytes_into.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/compression/decompress_bytes_into.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mDAXW,UAAU,UACV,MAAM,SACN,MAAM,UACN,UAAU,EAAE,WACZ,SAAS,GAAC,aAAa,GAAC,MAAM,GAC5B,QAAQ,MAAM,CAAC,CA8D3B"}
+{"version":3,"file":"decompress_bytes_into.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/compression/decompress_bytes_into.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mDAXW,UAAU,UACV,MAAM,SACN,MAAM,UACN,UAAU,EAAE,WACZ,SAAS,GAAC,aAAa,GAAC,MAAM,GAC5B,QAAQ,MAAM,CAAC,CAkD3B"}

package/src/core/binary/compression/decompress_bytes_into.js

@@ -1,4 +1,5 @@
 import { assert } from "../../assert.js";
+import { chunks_to_stream } from "./chunks_to_stream.js";
 
 /**
  * Decompress pieces of one stream straight into a buffer the caller already owns, writing at most
@@ -40,19 +41,7 @@ export async function decompress_bytes_into(destination, offset, limit, chunks,
         'the destination must hold `limit` bytes at `offset`'
     );
 
-    let index = 0;
-
-    const input = new ReadableStream({
-        pull(controller) {
-            if (index === chunks.length) {
-                controller.close();
-            } else {
-                controller.enqueue(chunks[index++]);
-            }
-        }
-    });
-
-    const reader = input.pipeThrough(new DecompressionStream(format)).getReader();
+    const reader = chunks_to_stream(chunks).pipeThrough(new DecompressionStream(format)).getReader();
 
     let written = 0;
 

package/src/core/binary/ctz32.d.ts

@@ -1,8 +1,16 @@
 /**
- * Count trailing zeroes
- * adapted from https://github.com/git/git/blob/bcd6bc478adc4951d57ec597c44b12ee74bc88fb/ewah/ewok.h#L44
- * @param {number} x expected to be an integer
- * @return {number}
+ * Count trailing zeroes — the index of the least significant set bit.
+ *
+ * `Math.clz32` is an intrinsic, so isolating the lowest set bit with `x & -x` and counting the
+ * leading zeroes above it beats both a five-step binary search and a de Bruijn table lookup
+ * (measured 2026-09-20 over a 64k mixed-word array: 11.5 ms against 12.9 ms for the branch ladder
+ * and 13.4 ms for the table, median of 12 interleaved rounds). It is also how the sibling
+ * {@link msb_32} is written.
+ *
+ * @param {number} x expected to be an integer; only the low 32 bits are read
+ * @return {number} `0..31` for the position of the lowest set bit, or `32` when no bit is set —
+ * the same out-of-range answer {@link Math.clz32} gives for zero, and distinguishable from
+ * "bit 0 is set" in a way that `0` would not be.
  */
 export function ctz32(x: number): number;
 //# sourceMappingURL=ctz32.d.ts.map

package/src/core/binary/ctz32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ctz32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/ctz32.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,yBAHW,MAAM,GACL,MAAM,CAoCjB"}
+{"version":3,"file":"ctz32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/ctz32.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,yBALW,MAAM,GACL,MAAM,CAYjB"}

package/src/core/binary/ctz32.js

@@ -1,41 +1,23 @@
-/**
- * Count trailing zeroes
- * adapted from https://github.com/git/git/blob/bcd6bc478adc4951d57ec597c44b12ee74bc88fb/ewah/ewok.h#L44
- * @param {number} x expected to be an integer
- * @return {number}
- */
-export function ctz32(x) {
-    let _x = x;
-    let n = 0;
-
-    if ((_x & 0xffff) === 0) {
-        _x >>= 16;
-        n += 16;
-    }
-
-    if ((_x & 0xff) === 0) {
-        _x >>= 8;
-        n += 8;
-    }
-
-    if ((_x & 0xf) === 0) {
-        _x >>= 4;
-        n += 4;
-    }
-
-    if ((_x & 0x3) === 0) {
-        _x >>= 2;
-        n += 2;
-    }
-
-    if ((_x & 0x1) === 0) {
-        _x >>= 1;
-        n += 1;
-    }
-
-    if (_x === 0) {
-        n += 1;
-    }
-
-    return n;
-}
+/**
+ * Count trailing zeroes — the index of the least significant set bit.
+ *
+ * `Math.clz32` is an intrinsic, so isolating the lowest set bit with `x & -x` and counting the
+ * leading zeroes above it beats both a five-step binary search and a de Bruijn table lookup
+ * (measured 2026-09-20 over a 64k mixed-word array: 11.5 ms against 12.9 ms for the branch ladder
+ * and 13.4 ms for the table, median of 12 interleaved rounds). It is also how the sibling
+ * {@link msb_32} is written.
+ *
+ * @param {number} x expected to be an integer; only the low 32 bits are read
+ * @return {number} `0..31` for the position of the lowest set bit, or `32` when no bit is set —
+ * the same out-of-range answer {@link Math.clz32} gives for zero, and distinguishable from
+ * "bit 0 is set" in a way that `0` would not be.
+ */
+export function ctz32(x) {
+    const lowest_set_bit = x & -x;
+
+    if (lowest_set_bit === 0) {
+        return 32;
+    }
+
+    return 31 - Math.clz32(lowest_set_bit);
+}

package/src/core/binary/lsb_32.d.ts

@@ -1,9 +1,17 @@
 /**
  * Get index of the least significant set bit
  * Also known as ctz32 or "count trailing zeroes"
+ *
+ * @deprecated Use {@link ctz32}, which this now is. The two were separate implementations of one
+ * function — a binary search and a de Bruijn table lookup — that disagreed on an input of zero:
+ * this one used to answer `0`, indistinguishable from "bit 0 is set". It answers `32` now. Every
+ * call site in the tree already guarded the zero case by hand, so the change is a widening of the
+ * documented range, not a behaviour a caller could have been relying on deliberately.
+ *
  * @see https://graphics.stanford.edu/~seander/bithacks.html
  * @param {number} v
- * @returns {number}
+ * @returns {number} `0..31`, or `32` when no bit is set
  */
-export function lsb_32(v: number): number;
+export const lsb_32: typeof ctz32;
+import { ctz32 } from "./ctz32.js";
 //# sourceMappingURL=lsb_32.d.ts.map

package/src/core/binary/lsb_32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lsb_32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/lsb_32.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,0BAHW,MAAM,GACJ,MAAM,CAIlB"}
+{"version":3,"file":"lsb_32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/lsb_32.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,kCAA4B;sBAhBN,YAAY"}

package/src/core/binary/lsb_32.js

@@ -1,12 +1,17 @@
-import { msb_lut_de_bruijn } from "./msb_lut_de_bruijn.js";
-
-/**
- * Get index of the least significant set bit
- * Also known as ctz32 or "count trailing zeroes"
- * @see https://graphics.stanford.edu/~seander/bithacks.html
- * @param {number} v
- * @returns {number}
- */
-export function lsb_32(v) {
-    return msb_lut_de_bruijn[((v & -v) * 0x077CB531) >>> 27];
-}
+import { ctz32 } from "./ctz32.js";
+
+/**
+ * Get index of the least significant set bit
+ * Also known as ctz32 or "count trailing zeroes"
+ *
+ * @deprecated Use {@link ctz32}, which this now is. The two were separate implementations of one
+ * function — a binary search and a de Bruijn table lookup — that disagreed on an input of zero:
+ * this one used to answer `0`, indistinguishable from "bit 0 is set". It answers `32` now. Every
+ * call site in the tree already guarded the zero case by hand, so the change is a widening of the
+ * documented range, not a behaviour a caller could have been relying on deliberately.
+ *
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @param {number} v
+ * @returns {number} `0..31`, or `32` when no bit is set
+ */
+export const lsb_32 = ctz32;

package/src/core/binary/lz4/lz4_compress_block_hc.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { lsb_32 } from "../lsb_32.js";
+import { ctz32 } from "../ctz32.js";
 import { LZ4_LEVEL } from "./LZ4_LEVEL.js";
 import { LZ4_MAX_INPUT_SIZE } from "./LZ4_MAX_INPUT_SIZE.js";
 
@@ -340,7 +340,7 @@ function count_pattern(position, end, pattern) {
         }
 
         // the first byte that differs is the lowest one set, and the bytes below it agreed
-        return (p - position) + (lsb_32(diff) >> 3);
+        return (p - position) + (ctz32(diff) >> 3);
     }
 
     let shift = 0;