@woosh/meep-engine 3.9.0 → 3.11.0

package/src/avif/threaded_image_encoder.js

@@ -1,6 +1,12 @@
-// Pool dispatcher for AVIF encoding. Each pool worker runs the single-threaded
-// encoder, so concurrency = pool size. Workers are spawned lazily on first
-// request and shut down after an idle period.
+// Pool dispatcher for AVIF encoding. Each pool worker runs meep's own encoder, so concurrency =
+// pool size. Workers are spawned lazily on first request and shut down after an idle period.
+//
+// The encoder is pure JavaScript now, which makes the pool an optimisation rather than a
+// requirement: where there are no workers to be had — node, a worker that cannot nest one, a
+// browser that refuses a module worker — the same encode simply runs here instead. That is why
+// nothing below throws for want of a Worker.
+
+import { create_encoder, encode_bitmap_source, encode_sampler_source } from './encode_image_source.js';
 
 const IDLE_SHUTDOWN_MS = 5000;
 
@@ -75,22 +81,76 @@ export class ThreadedImageEncoder {
         this.slots = null;
         this.id_counter = 0;
         this.pending_termination = -1;
+
+        /** @type {boolean} set once it is known that this environment has no workers to give */
+        this.inline = false;
+
+        /** @type {Av1EncodeContext|null} used only on the inline path */
+        this.encoder = null;
     }
 
+    /**
+     * Bring the pool up, or decide once that there is not going to be one.
+     *
+     * A worker can fail to start for reasons that have nothing to do with this code — no `Worker`
+     * at all, no module workers, a policy that forbids them — and there is nothing useful to do
+     * about any of them except encode here instead. The decision is remembered so that a failed
+     * spawn is not retried on every image.
+     *
+     * @returns {boolean} whether there is a pool to submit to
+     */
     #ensure_running() {
         if (this.slots !== null) {
             this.#cancel_termination();
-            return;
+            return true;
+        }
+
+        if (this.inline) {
+            return false;
+        }
+
+        if (typeof Worker === 'undefined') {
+            this.inline = true;
+            return false;
         }
 
-        this.slots = [];
-        for (let i = 0; i < this.worker_count; i++) {
-            const worker = new Worker(
-                new URL('./encoder_worker.js', import.meta.url),
-                { type: 'module', name: `avif-encoder-${i}` }
-            );
-            this.slots.push(new WorkerSlot(worker, () => this.#on_slot_release()));
+        const slots = [];
+
+        try {
+            for (let i = 0; i < this.worker_count; i++) {
+                const worker = new Worker(
+                    new URL('./encoder_worker.js', import.meta.url),
+                    { type: 'module', name: `avif-encoder-${i}` }
+                );
+                slots.push(new WorkerSlot(worker, () => this.#on_slot_release()));
+            }
+        } catch (e) {
+            for (const slot of slots) {
+                slot.terminate();
+            }
+
+            this.inline = true;
+
+            return false;
         }
+
+        this.slots = slots;
+
+        return true;
+    }
+
+    /**
+     * The encoder the inline path reuses. Built on first use, because a session that never falls
+     * back never needs one.
+     *
+     * @returns {Av1EncodeContext}
+     */
+    #inline_encoder() {
+        if (this.encoder === null) {
+            this.encoder = create_encoder();
+        }
+
+        return this.encoder;
     }
 
     #pick_slot() {
@@ -136,43 +196,51 @@ export class ThreadedImageEncoder {
     }
 
     /**
-     * @param {ImageBitmap} bitmap — transferred to the worker; do not use after this call
+     * @param {ImageBitmap} bitmap — consumed; do not use after this call
      * @param {number} quality — 0..1
      * @param {number} [speed] — 0 (slowest, best) .. 10 (fastest)
      * @returns {Promise<ArrayBuffer>}
      */
     encode_bitmap(bitmap, quality, speed) {
-        this.#ensure_running();
+        const payload = { bitmap, quality, speed };
+
+        if (!this.#ensure_running()) {
+            return promise_of(() => encode_bitmap_source(payload, this.#inline_encoder()));
+        }
+
         const id = this.id_counter++;
         const slot = this.#pick_slot();
-        return slot.submit(id, 'encode_bitmap', { bitmap, quality, speed }, [bitmap]);
+        return slot.submit(id, 'encode_bitmap', payload, [bitmap]);
     }
 
     /**
      * @param {{ data: TypedArray, width: number, height: number, itemSize: number }} sampler2d
-     *   — sampler2d.data buffer is transferred to the worker; do not use after this call
+     *   — consumed; do not use after this call. The pool transfers the buffer to a worker, and the
+     *   inline path is entitled to the same freedom even though it does not take it
      * @param {number} quality — 0..1
      * @param {number} [speed] — 0 (slowest, best) .. 10 (fastest)
      * @returns {Promise<ArrayBuffer>}
      */
     encode_sampler2d(sampler2d, quality, speed) {
-        this.#ensure_running();
-        const id = this.id_counter++;
-        const slot = this.#pick_slot();
-
         const data = sampler2d.data;
-        const is_hdr = data instanceof Uint16Array;
 
         const payload = {
             data,
             width: sampler2d.width,
             height: sampler2d.height,
             item_size: sampler2d.itemSize,
-            is_hdr,
+            is_hdr: data instanceof Uint16Array,
             quality,
             speed
         };
 
+        if (!this.#ensure_running()) {
+            return promise_of(() => encode_sampler_source(payload, this.#inline_encoder()));
+        }
+
+        const id = this.id_counter++;
+        const slot = this.#pick_slot();
+
         return slot.submit(id, 'encode_sampler2d', payload, [data.buffer]);
     }
 
@@ -188,6 +256,24 @@ export class ThreadedImageEncoder {
     }
 }
 
+/**
+ * Run something that may throw, as a promise.
+ *
+ * The inline path has to hand back the same promise the worker path does, and it has to reject
+ * rather than throw where the worker path would have rejected — a caller that catches one and not
+ * the other is a caller that breaks the day workers go away.
+ *
+ * @param {function(): ArrayBuffer} work
+ * @returns {Promise<ArrayBuffer>}
+ */
+function promise_of(work) {
+    try {
+        return Promise.resolve(work());
+    } catch (e) {
+        return Promise.reject(e);
+    }
+}
+
 let _instance = null;
 
 /**

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

@@ -205,11 +205,31 @@ export class BinaryBuffer {
      * @return {number}
      */
     readInt16(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    readInt16LE(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    readInt16BE(): number;
     /**
      *
      * @returns {number}
      */
     readInt32(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    readInt32LE(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    readInt32BE(): number;
     /**
      *
      * @returns {bigint}
@@ -372,11 +392,31 @@ export class BinaryBuffer {
      * @param {number} value
      */
     writeInt16(value: number): void;
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt16BE(value: number): void;
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt16LE(value: number): void;
     /**
      *
      * @param {number} value
      */
     writeInt32(value: number): void;
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt32BE(value: number): void;
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt32LE(value: number): void;
     /**
      *
      * @param {bigint} value

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

@@ -294,6 +294,30 @@ export class BinaryBuffer {
         return result;
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    readInt16LE() {
+        const result = this.dataView.getInt16(this.position, EndianType.LittleEndian);
+
+        this.position += 2;
+
+        return result;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    readInt16BE() {
+        const result = this.dataView.getInt16(this.position, EndianType.BigEndian);
+
+        this.position += 2;
+
+        return result;
+    }
+
     /**
      *
      * @returns {number}
@@ -306,6 +330,30 @@ export class BinaryBuffer {
         return result;
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    readInt32LE() {
+        const result = this.dataView.getInt32(this.position, EndianType.LittleEndian);
+
+        this.position += 4;
+
+        return result;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    readInt32BE() {
+        const result = this.dataView.getInt32(this.position, EndianType.BigEndian);
+
+        this.position += 4;
+
+        return result;
+    }
+
     /**
      *
      * @returns {bigint}
@@ -654,6 +702,32 @@ export class BinaryBuffer {
         this.position = end;
     }
 
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt16BE(value) {
+        const end = this.position + 2;
+        this.ensureCapacity(end);
+
+        this.dataView.setInt16(this.position, value, EndianType.BigEndian);
+
+        this.position = end;
+    }
+
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt16LE(value) {
+        const end = this.position + 2;
+        this.ensureCapacity(end);
+
+        this.dataView.setInt16(this.position, value, EndianType.LittleEndian);
+
+        this.position = end;
+    }
+
     /**
      *
      * @param {number} value
@@ -667,6 +741,32 @@ export class BinaryBuffer {
         this.position = end;
     }
 
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt32BE(value) {
+        const end = this.position + 4;
+        this.ensureCapacity(end);
+
+        this.dataView.setInt32(this.position, value, EndianType.BigEndian);
+
+        this.position = end;
+    }
+
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt32LE(value) {
+        const end = this.position + 4;
+        this.ensureCapacity(end);
+
+        this.dataView.setInt32(this.position, value, EndianType.LittleEndian);
+
+        this.position = end;
+    }
+
     /**
      *
      * @param {bigint} value

package/src/core/binary/hash/crc32.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 32-bit Cyclic Redundancy Checksum.
+ * @see https://en.wikipedia.org/wiki/Cyclic_redundancy_check
+ * @param {Uint8Array} buffer byte buffer
+ * @param {number} [offset=0] where to start in the input buffer
+ * @param {number} [length=buffer.length] how many bytes to include in checksum calculation
+ * @return {number} Unsigned 32-bit integer value
+ * @copyright Company Named Limited (c) 2026
+ *
+ * @example
+ *      const buffer = new BinaryBuffer();
+ *      buffer.writeASCIIString("Hello World");
+ *      const checksum = crc32(buffer.raw_bytes, 0, buffer.position);
+ */
+export function crc32(buffer: Uint8Array, offset?: number, length?: number): number;
+//# sourceMappingURL=crc32.d.ts.map

package/src/core/binary/hash/crc32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crc32.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/hash/crc32.js"],"names":[],"mappings":"AA2EA;;;;;;;;;;;;;GAaG;AACH,8BAXW,UAAU,WACV,MAAM,WACN,MAAM,GACL,MAAM,CAcjB"}

package/src/core/binary/hash/crc32.js

@@ -0,0 +1,96 @@
+import { assert } from "../../assert.js";
+
+/*
+ * CRC-32/ISO-3309, the reflected 0xEDB88320 variant. The same checksum PNG chunks, ZIP local file
+ * headers and gzip trailers all carry, which is why this lives in core rather than beside any one
+ * of them.
+ *
+ * Ported from C source at https://www.w3.org/TR/PNG-CRCAppendix.html
+ * See also ISO 3309 [ISO-3309] or ITU-T V.42 [ITU-V42] for a formal specification
+ */
+
+/**
+ *
+ * @type {Uint32Array}
+ */
+const crc_table = new Uint32Array(256);
+
+// Precompute checksum table
+for (let n = 0; n < 256; n++) {
+    let c = n;
+
+    for (let k = 0; k < 8; k++) {
+
+        if ((c & 1) !== 0) {
+            // CRC32b polynomial
+            c = 0xedb88320 ^ (c >>> 1);
+        } else {
+            c = c >>> 1;
+        }
+
+    }
+
+    crc_table[n] = c;
+}
+
+const INITIAL = 0xffffffff;
+
+/**
+ * Update a running CRC with the bytes buf[0..len-1]--the CRC
+ * should be initialized to all 1's, and the transmitted value
+ * is the 1's complement of the final running CRC (see the crc32() routine below)).
+ * @param {number} input_crc starting CRC value
+ * @param {Uint8Array} buffer
+ * @param {number} offset
+ * @param {number} length
+ * @return {number}
+ */
+function update_crc(
+    input_crc,
+    buffer,
+    offset,
+    length,
+) {
+    assert.isNonNegativeInteger(input_crc, 'input_crc');
+    assert.defined(buffer, 'buffer');
+    assert.isNonNegativeInteger(offset, 'offset');
+    assert.isNonNegativeInteger(length, 'length');
+
+    let crc = input_crc;
+
+    const end = offset + length;
+
+    for (let n = offset; n < end; n++) {
+
+        const byte = buffer[n];
+
+        const lookup_index = (crc ^ byte) & 0xff;
+
+        crc = crc_table[lookup_index] ^ (crc >>> 8);
+
+    }
+
+    return crc;
+}
+
+/**
+ * 32-bit Cyclic Redundancy Checksum.
+ * @see https://en.wikipedia.org/wiki/Cyclic_redundancy_check
+ * @param {Uint8Array} buffer byte buffer
+ * @param {number} [offset=0] where to start in the input buffer
+ * @param {number} [length=buffer.length] how many bytes to include in checksum calculation
+ * @return {number} Unsigned 32-bit integer value
+ * @copyright Company Named Limited (c) 2026
+ *
+ * @example
+ *      const buffer = new BinaryBuffer();
+ *      buffer.writeASCIIString("Hello World");
+ *      const checksum = crc32(buffer.raw_bytes, 0, buffer.position);
+ */
+export function crc32(
+    buffer,
+    offset=0,
+    length=buffer.length,
+) {
+    return (update_crc(INITIAL, buffer, offset, length) ^ INITIAL) >>> 0;
+}

package/src/core/binary/utf8/utf8_decode.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Decode a range of bytes as UTF-8.
+ *
+ * Hand-rolled rather than delegating to `TextDecoder`: this runs in environments that do not
+ * universally provide one, and the strings it is asked for — box names, aux types, chunk keywords —
+ * are short enough that the loop costs nothing.
+ *
+ * Malformed input is decoded leniently rather than rejected. A stray continuation byte is consumed
+ * as though it led a two-byte sequence, and a sequence truncated by `end` reads zeroes for its
+ * missing bytes. Both produce a wrong character and neither overruns or loops: callers here parse
+ * files written by other people's encoders, where refusing a name is worse than mangling one.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} [start] index of the first byte to decode
+ * @param {number} [end] index one past the last byte to decode
+ * @returns {string}
+ *
+ * @copyright Company Named Limited (c) 2026
+ */
+export function utf8_decode(bytes: Uint8Array, start?: number, end?: number): string;
+//# sourceMappingURL=utf8_decode.d.ts.map

package/src/core/binary/utf8/utf8_decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8_decode.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/utf8/utf8_decode.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,mCAPW,UAAU,UACV,MAAM,QACN,MAAM,GACJ,MAAM,CA2BlB"}

package/src/core/binary/utf8/utf8_decode.js

@@ -0,0 +1,43 @@
+/**
+ * Decode a range of bytes as UTF-8.
+ *
+ * Hand-rolled rather than delegating to `TextDecoder`: this runs in environments that do not
+ * universally provide one, and the strings it is asked for — box names, aux types, chunk keywords —
+ * are short enough that the loop costs nothing.
+ *
+ * Malformed input is decoded leniently rather than rejected. A stray continuation byte is consumed
+ * as though it led a two-byte sequence, and a sequence truncated by `end` reads zeroes for its
+ * missing bytes. Both produce a wrong character and neither overruns or loops: callers here parse
+ * files written by other people's encoders, where refusing a name is worse than mangling one.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} [start] index of the first byte to decode
+ * @param {number} [end] index one past the last byte to decode
+ * @returns {string}
+ *
+ * @copyright Company Named Limited (c) 2026
+ */
+export function utf8_decode(bytes, start = 0, end = bytes.length) {
+    let result = "";
+
+    let i = start;
+
+    while (i < end) {
+        const b0 = bytes[i++];
+
+        if (b0 < 0x80) {
+            result += String.fromCharCode(b0);
+        } else if (b0 < 0xe0) {
+            result += String.fromCharCode(((b0 & 0x1f) << 6) | (bytes[i++] & 0x3f));
+        } else if (b0 < 0xf0) {
+            result += String.fromCharCode(((b0 & 0x0f) << 12) | ((bytes[i++] & 0x3f) << 6) | (bytes[i++] & 0x3f));
+        } else {
+            const code_point = ((b0 & 0x07) << 18) | ((bytes[i++] & 0x3f) << 12) | ((bytes[i++] & 0x3f) << 6) | (bytes[i++] & 0x3f);
+            const offset = code_point - 0x10000;
+
+            result += String.fromCharCode(0xd800 + (offset >> 10), 0xdc00 + (offset & 0x3ff));
+        }
+    }
+
+    return result;
+}

package/src/core/binary/utf8/utf8_encode_into.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Encode `text` as UTF-8 into `bytes`, starting at `offset`.
+ *
+ * Does not check capacity: size the destination with {@link utf8_encoded_length} first. Splitting
+ * the two is what keeps this a single pass into memory the caller already owns, rather than an
+ * allocation per string.
+ *
+ * An unpaired surrogate is encoded as itself, in three bytes. That is not well-formed UTF-8, but it
+ * is what round-trips through {@link utf8_decode}, and silently substituting U+FFFD would lose data
+ * the caller never asked us to judge.
+ *
+ * @param {string} text
+ * @param {Uint8Array} bytes destination, with at least `utf8_encoded_length(text)` bytes free
+ * @param {number} [offset] index to start writing at
+ * @returns {number} number of bytes written
+ *
+ * @copyright Company Named Limited (c) 2026
+ */
+export function utf8_encode_into(text: string, bytes: Uint8Array, offset?: number): number;
+//# sourceMappingURL=utf8_encode_into.d.ts.map

package/src/core/binary/utf8/utf8_encode_into.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8_encode_into.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/utf8/utf8_encode_into.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,uCAPW,MAAM,SACN,UAAU,WACV,MAAM,GACJ,MAAM,CAiClB"}

package/src/core/binary/utf8/utf8_encode_into.js

@@ -0,0 +1,48 @@
+/**
+ * Encode `text` as UTF-8 into `bytes`, starting at `offset`.
+ *
+ * Does not check capacity: size the destination with {@link utf8_encoded_length} first. Splitting
+ * the two is what keeps this a single pass into memory the caller already owns, rather than an
+ * allocation per string.
+ *
+ * An unpaired surrogate is encoded as itself, in three bytes. That is not well-formed UTF-8, but it
+ * is what round-trips through {@link utf8_decode}, and silently substituting U+FFFD would lose data
+ * the caller never asked us to judge.
+ *
+ * @param {string} text
+ * @param {Uint8Array} bytes destination, with at least `utf8_encoded_length(text)` bytes free
+ * @param {number} [offset] index to start writing at
+ * @returns {number} number of bytes written
+ *
+ * @copyright Company Named Limited (c) 2026
+ */
+export function utf8_encode_into(text, bytes, offset = 0) {
+    const length = text.length;
+
+    let at = offset;
+
+    for (let i = 0; i < length; i++) {
+        const code = text.codePointAt(i);
+
+        if (code < 0x80) {
+            bytes[at++] = code;
+        } else if (code < 0x800) {
+            bytes[at++] = 0xc0 | (code >> 6);
+            bytes[at++] = 0x80 | (code & 0x3f);
+        } else if (code < 0x10000) {
+            bytes[at++] = 0xe0 | (code >> 12);
+            bytes[at++] = 0x80 | ((code >> 6) & 0x3f);
+            bytes[at++] = 0x80 | (code & 0x3f);
+        } else {
+            bytes[at++] = 0xf0 | (code >> 18);
+            bytes[at++] = 0x80 | ((code >> 12) & 0x3f);
+            bytes[at++] = 0x80 | ((code >> 6) & 0x3f);
+            bytes[at++] = 0x80 | (code & 0x3f);
+
+            // codePointAt consumed both halves of the surrogate pair
+            i++;
+        }
+    }
+
+    return at - offset;
+}

package/src/core/binary/utf8/utf8_encoded_length.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Number of bytes {@link utf8_encode_into} will write for `text`, excluding any terminator the
+ * caller adds.
+ *
+ * Exists so a caller can size or grow a buffer before encoding into it, which is what lets the
+ * encode itself be a single pass with no allocation.
+ *
+ * @param {string} text
+ * @returns {number}
+ *
+ * @copyright Company Named Limited (c) 2026
+ */
+export function utf8_encoded_length(text: string): number;
+//# sourceMappingURL=utf8_encoded_length.d.ts.map

package/src/core/binary/utf8/utf8_encoded_length.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8_encoded_length.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/utf8/utf8_encoded_length.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,0CALW,MAAM,GACJ,MAAM,CA2BlB"}