pelican-engine 0.0.0-stage → 0.3.1

package/lib/assets/glb.js

@@ -0,0 +1,277 @@
+import path from "node:path";
+export function parseGLB(data, ctx) {
+    if (data.toString("latin1", 0, 4) !== "glTF") {
+        if (path.extname(ctx.file).toLowerCase() === ".glb")
+            ctx.invalid("GLB/header", "Missing or damaged GLB magic bytes.");
+        ctx.unsupported("model/format", "Only self-contained GLB 2.0 is implemented; JSON .gltf is not supported.");
+    }
+    ctx.check(data.length >= 20, "GLB/header", "Truncated GLB header.");
+    if (data.readUInt32LE(4) !== 2)
+        ctx.unsupported("GLB/version", `GLB version ${data.readUInt32LE(4)} is not implemented.`);
+    ctx.check(data.readUInt32LE(8) === data.length && data.length % 4 === 0, "GLB/length", "Declared GLB length must equal actual bytes and be four-byte aligned.");
+    let offset = 12, raw, bin = Buffer.alloc(0), hasBin = false;
+    while (offset < data.length) {
+        ctx.check(offset + 8 <= data.length, "GLB/chunk", "Truncated chunk header.");
+        const size = data.readUInt32LE(offset), type = data.readUInt32LE(offset + 4), end = offset + 8 + size;
+        ctx.check(size % 4 === 0 && end <= data.length, "GLB/chunk", "Chunk length is misaligned or exceeds GLB boundary.");
+        const chunk = data.subarray(offset + 8, end);
+        if (type === 0x4e4f534a) {
+            ctx.check(offset === 12 && raw === undefined, "GLB/JSON", "Exactly one JSON chunk must be first.");
+            try {
+                raw = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(chunk));
+            }
+            catch {
+                ctx.invalid("GLB/JSON", "Malformed UTF-8 or JSON chunk (padding must be spaces).");
+            }
+        }
+        else if (type === 0x004e4942) {
+            ctx.check(raw !== undefined && !hasBin, "GLB/BIN", "Duplicate BIN chunk or BIN before JSON.");
+            hasBin = true;
+            bin = chunk;
+        }
+        else
+            ctx.unsupported("GLB/chunk", `Unknown GLB chunk type 0x${type.toString(16)}.`);
+        offset = end;
+    }
+    ctx.check(raw && typeof raw === "object" && !Array.isArray(raw), "GLB/JSON", "JSON root must be an object.");
+    const json = raw;
+    ctx.check(json.asset && typeof json.asset === "object", "asset", "Missing glTF asset declaration.");
+    if (json.asset.version !== "2.0" ||
+        (json.asset.minVersion !== undefined && json.asset.minVersion !== "2.0"))
+        ctx.unsupported("asset/version", "Only glTF 2.0 is implemented.");
+    for (const key of [
+        "buffers",
+        "bufferViews",
+        "accessors",
+        "images",
+        "textures",
+        "samplers",
+        "materials",
+        "meshes",
+        "nodes",
+        "skins",
+        "animations",
+        "scenes",
+        "cameras",
+    ]) {
+        const list = json[key];
+        if (list !== undefined)
+            ctx.check(Array.isArray(list) &&
+                list.length > 0 &&
+                list.every((item) => item && typeof item === "object" && !Array.isArray(item)), key, "Expected a nonempty array of objects.");
+    }
+    const supported = new Set(["KHR_materials_specular", "KHR_materials_ior"]);
+    for (const key of ["extensionsUsed", "extensionsRequired"])
+        if (json[key] !== undefined) {
+            ctx.check(Array.isArray(json[key]) &&
+                json[key].length > 0 &&
+                json[key].every((s) => typeof s === "string" && s.length > 0) &&
+                new Set(json[key]).size === json[key].length, key, "Expected extension names.");
+            const unknown = json[key].filter((name) => !supported.has(name));
+            if (unknown.length)
+                ctx.unsupported(key, `glTF extensions are not implemented: ${unknown.join(", ")}.`);
+        }
+    const used = new Set(json.extensionsUsed ?? []);
+    for (const name of json.extensionsRequired ?? [])
+        ctx.check(used.has(name), "extensionsRequired", `${name} must also be declared in extensionsUsed.`);
+    const encountered = new Set();
+    // Never silently lose optional extension semantics in the metadata.
+    const checkExtensions = (value, location) => {
+        if (typeof value === "number")
+            ctx.check(Number.isFinite(value), location, "JSON numbers must be finite.");
+        if (!value || typeof value !== "object")
+            return;
+        if (!Array.isArray(value) && "name" in value)
+            ctx.check(typeof value.name === "string", location + "/name", "Object name must be a string.");
+        for (const [key, child] of Object.entries(value)) {
+            if (key === "extras")
+                continue;
+            if (key === "extensions") {
+                ctx.check(child && typeof child === "object" && !Array.isArray(child), location + "/extensions", "Expected extension object.");
+                for (const [name, payload] of Object.entries(child)) {
+                    const at = location + "/extensions/" + name;
+                    if (!supported.has(name) || !/^glTF\/materials\/(0|[1-9]\d*)$/.test(location))
+                        ctx.unsupported(at, `Extension payload ${name} is not supported at this location.`);
+                    ctx.check(used.has(name), at, `${name} must be declared in extensionsUsed.`);
+                    encountered.add(name);
+                    ctx.check(payload && typeof payload === "object" && !Array.isArray(payload), at, "Expected extension object.");
+                    for (const [field, fieldValue] of Object.entries(payload)) {
+                        if (name === "KHR_materials_specular" && (field === "specularTexture" || field === "specularColorTexture")) {
+                            checkExtensions(fieldValue, at + "/" + field);
+                            continue;
+                        }
+                        if (field === "extensions" || field === "extras") {
+                            checkExtensions({ [field]: fieldValue }, at);
+                            continue;
+                        }
+                        const allowed = name === "KHR_materials_specular"
+                            ? ["specularFactor", "specularColorFactor"] : ["ior"];
+                        ctx.check(allowed.includes(field), at + "/" + field, "Unknown extension property.");
+                        const validNumber = (v, min, max) => typeof v === "number" && Number.isFinite(v) && v >= min && v <= max;
+                        ctx.check(field === "specularColorFactor"
+                            ? Array.isArray(fieldValue) && fieldValue.length === 3 && fieldValue.every(v => validNumber(v, 0, 1))
+                            : validNumber(fieldValue, field === "ior" ? 1 : 0, field === "ior" ? Infinity : 1), at + "/" + field, "Invalid extension factor or IOR.");
+                    }
+                }
+            }
+            else
+                checkExtensions(child, location + "/" + key);
+        }
+    };
+    checkExtensions(json, "glTF");
+    for (const name of used)
+        ctx.check(encountered.has(name), "extensionsUsed", `${name} is declared but not used by a material.`);
+    const buffers = json.buffers ?? [];
+    for (let i = 0; i < buffers.length; i++)
+        if (buffers[i].uri !== undefined)
+            ctx.unsupported(`buffers/${i}/uri`, `External or URI buffer resource ${String(buffers[i].uri)} is not supported; embed it in the GLB BIN chunk.`);
+    ctx.check(buffers.length <= 1, "buffers", "GLB may have only one embedded buffer.");
+    if (buffers.length) {
+        const size = ctx.integer(buffers[0].byteLength, "buffers/0/byteLength", 1);
+        ctx.check(hasBin && size <= bin.length && bin.length - size <= 3, "buffers/0", "Missing BIN resource or buffer length differs from BIN length beyond padding.");
+        ctx.check(bin.subarray(size).every((b) => b === 0), "GLB/BIN", "BIN padding must be zero.");
+        bin = bin.subarray(0, size);
+    }
+    else
+        ctx.check(!hasBin, "GLB/BIN", "BIN chunk has no buffer declaration.");
+    for (const [i, view] of (json.bufferViews ?? []).entries()) {
+        ctx.check(view.buffer === 0 && buffers.length === 1, `bufferViews/${i}/buffer`, "Buffer reference does not exist.");
+        const start = ctx.integer(view.byteOffset ?? 0, `bufferViews/${i}/byteOffset`), size = ctx.integer(view.byteLength, `bufferViews/${i}/byteLength`, 1);
+        ctx.check(start + size <= bin.length, `bufferViews/${i}`, "Buffer view exceeds embedded buffer boundary.");
+        if (view.byteStride !== undefined) {
+            ctx.integer(view.byteStride, `bufferViews/${i}/byteStride`, 4, 252);
+            ctx.check(view.byteStride % 4 === 0, `bufferViews/${i}/byteStride`, "Vertex stride must be a multiple of four.");
+        }
+        if (view.target !== undefined)
+            ctx.check([34962, 34963].includes(view.target), `bufferViews/${i}/target`, "Invalid buffer view target.");
+    }
+    const sizes = {
+        5120: 1,
+        5121: 1,
+        5122: 2,
+        5123: 2,
+        5125: 4,
+        5126: 4,
+    };
+    const counts = {
+        SCALAR: 1,
+        VEC2: 2,
+        VEC3: 3,
+        VEC4: 4,
+        MAT2: 4,
+        MAT3: 9,
+        MAT4: 16,
+    };
+    let inspectedValues = 0;
+    const accessors = (json.accessors ?? []).map((a, i) => {
+        const at = `accessors/${i}`;
+        ctx.integer(a.count, at + "/count", 1);
+        ctx.check(sizes[a.componentType] && counts[a.type], at, "Invalid accessor componentType or type.");
+        const size = sizes[a.componentType], components = counts[a.type];
+        if (a.type.startsWith("MAT") && size < 4)
+            ctx.unsupported(at, "Matrix accessors with sub-32-bit components are not implemented.");
+        if (a.normalized !== undefined)
+            ctx.check(typeof a.normalized === "boolean" &&
+                (!a.normalized || [5120, 5121, 5122, 5123].includes(a.componentType)), at + "/normalized", "Invalid normalized accessor.");
+        const byteOffset = ctx.integer(a.byteOffset ?? 0, at + "/byteOffset");
+        ctx.check(byteOffset % size === 0, at, "Accessor byte offset is misaligned.");
+        let source, stride = size * components, start = 0;
+        if (a.bufferView !== undefined) {
+            const index = ctx.integer(a.bufferView, at + "/bufferView", 0, (json.bufferViews?.length ?? 0) - 1);
+            const view = json.bufferViews[index];
+            stride = view.byteStride ?? stride;
+            ctx.check(stride >= size * components &&
+                stride % size === 0 &&
+                byteOffset + (a.count - 1) * stride + size * components <=
+                    view.byteLength, at, "Accessor range or stride exceeds buffer view boundary.");
+            start = (view.byteOffset ?? 0) + byteOffset;
+            ctx.check(start % size === 0, at, "Accessor absolute byte offset is misaligned.");
+            source = bin;
+        }
+        else
+            ctx.check(byteOffset === 0, at, "Accessor without buffer view cannot have byte offset.");
+        inspectedValues += a.count * components;
+        if (inspectedValues > 16_000_000)
+            ctx.unsupported(at, "Accessors exceed the 16 million scalar inspection limit.");
+        const replacements = new Map();
+        if (a.sparse !== undefined) {
+            const sparse = a.sparse, sparseAt = at + "/sparse";
+            ctx.check(sparse && typeof sparse === "object" && !Array.isArray(sparse), sparseAt, "Expected a sparse object.");
+            if (components > 4)
+                ctx.unsupported(sparseAt, "Sparse matrices are not supported by the current model loader.");
+            if (a.bufferView !== undefined && json.bufferViews[a.bufferView].byteStride !== undefined)
+                ctx.unsupported(sparseAt, "Sparse accessors with interleaved base data are not supported by the current model loader.");
+            const count = ctx.integer(sparse.count, sparseAt + "/count", 1, a.count);
+            ctx.check(sparse.indices && typeof sparse.indices === "object" && !Array.isArray(sparse.indices), sparseAt + "/indices", "Expected sparse indices.");
+            ctx.check(sparse.values && typeof sparse.values === "object" && !Array.isArray(sparse.values), sparseAt + "/values", "Expected sparse values.");
+            const indexSize = sizes[sparse.indices.componentType];
+            ctx.check([5121, 5123, 5125].includes(sparse.indices.componentType), sparseAt + "/indices/componentType", "Sparse indices must be unsigned byte, short, or int.");
+            const sparseStart = (part, label, alignment, length) => {
+                const resource = sparseAt + "/" + label;
+                const index = ctx.integer(part.bufferView, resource + "/bufferView", 0, (json.bufferViews?.length ?? 0) - 1);
+                const view = json.bufferViews[index];
+                const offset = ctx.integer(part.byteOffset ?? 0, resource + "/byteOffset");
+                ctx.check(view.byteStride === undefined && view.target === undefined, resource + "/bufferView", "Sparse buffer views cannot have byteStride or target.");
+                ctx.check(offset % alignment === 0 && ((view.byteOffset ?? 0) + offset) % alignment === 0, resource + "/byteOffset", "Sparse data is misaligned.");
+                ctx.check(offset + length <= view.byteLength, resource, "Sparse data exceeds buffer view boundary.");
+                return (view.byteOffset ?? 0) + offset;
+            };
+            const indexStart = sparseStart(sparse.indices, "indices", indexSize, count * indexSize);
+            const valueStart = sparseStart(sparse.values, "values", size, count * components * size);
+            let previous = -1;
+            for (let n = 0; n < count; n++) {
+                const p = indexStart + n * indexSize;
+                const index = indexSize === 1 ? bin.readUInt8(p) : indexSize === 2 ? bin.readUInt16LE(p) : bin.readUInt32LE(p);
+                ctx.check(index > previous && index < a.count, sparseAt + "/indices", "Sparse indices must be strictly increasing and within accessor count.");
+                replacements.set(index, valueStart + n * components * size);
+                previous = index;
+            }
+        }
+        const values = [], min = Array(components).fill(Infinity), max = Array(components).fill(-Infinity);
+        for (let element = 0; element < a.count; element++)
+            for (let c = 0; c < components; c++) {
+                const replacement = replacements.get(element);
+                const p = replacement === undefined ? start + element * stride + c * size : replacement + c * size;
+                let v = 0;
+                if (source || replacement !== undefined)
+                    switch (a.componentType) {
+                        case 5120:
+                            v = bin.readInt8(p);
+                            break;
+                        case 5121:
+                            v = bin.readUInt8(p);
+                            break;
+                        case 5122:
+                            v = bin.readInt16LE(p);
+                            break;
+                        case 5123:
+                            v = bin.readUInt16LE(p);
+                            break;
+                        case 5125:
+                            v = bin.readUInt32LE(p);
+                            break;
+                        case 5126:
+                            v = bin.readFloatLE(p);
+                            break;
+                    }
+                ctx.check(Number.isFinite(v), at, "Accessor contains a non-finite value.");
+                min[c] = Math.min(min[c], v);
+                max[c] = Math.max(max[c], v);
+                values.push(v);
+            }
+        for (const [key, actual] of [
+            ["min", min],
+            ["max", max],
+        ])
+            if (a[key] !== undefined) {
+                const declared = a[key];
+                ctx.check(Array.isArray(declared) &&
+                    declared.length === components &&
+                    declared.every((v, c) => Number.isFinite(v) &&
+                        Math.abs(v - actual[c]) <=
+                            Math.max(1, Math.abs(actual[c])) * 1e-6), at + "/" + key, "Declared accessor bounds do not match decoded values.");
+            }
+        return { definition: a, values, components, min, max };
+    });
+    return { json, bin, accessors };
+}

package/lib/assets/index.js

@@ -0,0 +1,53 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AssetInspectionError, InspectionContext } from "./errors.js";
+import { inspectModel } from "./model.js";
+import { inspectTexture } from "./texture.js";
+import { inspectWAV } from "./audio.js";
+export { AssetInspectionError } from "./errors.js";
+/** Read-only, offline inspection. Reject invalid assets before returning JSON metadata. */
+export async function inspectAsset(file, type) {
+    const ctx = new InspectionContext(file);
+    let data;
+    try {
+        data = await fs.readFile(file);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            throw new AssetInspectionError("TC_ASSET_MISSING", file, "file", "Asset file does not exist.", "Correct the asset path or restore the source file.");
+        return ctx.invalid("file", `Cannot read asset (${code ?? "I/O error"}).`);
+    }
+    try {
+        let metadata;
+        switch (type) {
+            case "model":
+                metadata = await inspectModel(data, ctx);
+                break;
+            case "texture":
+                metadata = inspectTexture(data, ctx);
+                break;
+            case "audio":
+                metadata = inspectWAV(data, ctx);
+                break;
+            case "binary":
+                metadata = { format: "binary" };
+                break;
+            default:
+                return ctx.unsupported("type", `Unknown asset type ${String(type)}.`);
+        }
+        return {
+            ...metadata,
+            bytes: data.length,
+            sha256: createHash("sha256").update(data).digest("hex"),
+        };
+    }
+    catch (error) {
+        if (error instanceof AssetInspectionError)
+            throw error;
+        // A recognizable supported format with a damaged schema must never leak a raw TypeError.
+        const extension = path.extname(file).toLowerCase();
+        return ctx.invalid(type, `Malformed ${extension || type} asset: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/lib/assets/jpeg.js

@@ -0,0 +1,199 @@
+// Baseline sequential Huffman JPEG: validate every coefficient in the entropy stream.
+// Pixel reconstruction/IDCT is unnecessary for dimensions and integrity inspection.
+export function inspectJPEG(data, ctx) {
+    let offset = 2, width = 0, height = 0, restartInterval = 0;
+    const quantization = new Set();
+    const tables = new Map();
+    const components = [];
+    while (offset < data.length) {
+        ctx.check(data[offset++] === 0xff, "JPEG/marker", "Expected marker prefix.");
+        while (data[offset] === 0xff)
+            offset++;
+        const marker = data[offset++];
+        ctx.check(marker !== undefined &&
+            marker !== 0 &&
+            marker !== 0xd8 &&
+            marker !== 0xd9 &&
+            !(marker >= 0xd0 && marker <= 0xd7), "JPEG/marker", "Unexpected marker before image scan.");
+        ctx.check(offset + 2 <= data.length, "JPEG/segment", "Truncated segment length.");
+        const length = data.readUInt16BE(offset), end = offset + length;
+        ctx.check(length >= 2 && end <= data.length, "JPEG/segment", "Segment length exceeds file.");
+        const segment = data.subarray(offset + 2, end);
+        offset = end;
+        if (marker === 0xdb) {
+            let p = 0;
+            while (p < segment.length) {
+                const spec = segment[p++], precision = spec >>> 4, id = spec & 15;
+                ctx.check(precision <= 1 &&
+                    id <= 3 &&
+                    p + 64 * (precision + 1) <= segment.length, "JPEG/DQT", "Invalid quantization table.");
+                if (precision)
+                    ctx.unsupported("JPEG/DQT", "16-bit quantization tables are not baseline JPEG.");
+                for (let i = 0; i < 64; i++)
+                    ctx.check(segment[p++] > 0, "JPEG/DQT", "Zero quantization coefficient.");
+                quantization.add(id);
+            }
+            ctx.check(segment.length > 0, "JPEG/DQT", "Empty quantization segment.");
+        }
+        else if (marker === 0xc4) {
+            let p = 0;
+            while (p < segment.length) {
+                ctx.check(p + 17 <= segment.length, "JPEG/DHT", "Truncated Huffman table.");
+                const spec = segment[p++], kind = spec >>> 4, id = spec & 15;
+                ctx.check(kind <= 1 && id <= 3, "JPEG/DHT", "Invalid Huffman table selector.");
+                const counts = segment.subarray(p, p + 16);
+                p += 16;
+                const total = counts.reduce((a, b) => a + b, 0);
+                ctx.check(total > 0 && total <= 256 && p + total <= segment.length, "JPEG/DHT", "Invalid Huffman symbol count.");
+                const table = new Map();
+                let code = 0;
+                for (let bits = 1; bits <= 16; bits++) {
+                    ctx.check(code + counts[bits - 1] < 2 ** bits, "JPEG/DHT", "Oversubscribed Huffman tree or forbidden all-ones code.");
+                    for (let i = 0; i < counts[bits - 1]; i++) {
+                        const value = segment[p++];
+                        ctx.check(kind === 0
+                            ? value <= 11
+                            : value === 0 ||
+                                value === 0xf0 ||
+                                ((value & 15) > 0 && (value & 15) <= 10), "JPEG/DHT", "Invalid baseline Huffman symbol.");
+                        table.set((1 << bits) + code++, value);
+                    }
+                    code *= 2;
+                }
+                tables.set(`${kind}/${id}`, table);
+            }
+            ctx.check(segment.length > 0, "JPEG/DHT", "Empty Huffman segment.");
+        }
+        else if (marker === 0xc0) {
+            ctx.check(!components.length && segment.length >= 6 && segment[0] === 8, "JPEG/SOF0", "Invalid baseline frame or duplicate frame header.");
+            height = segment.readUInt16BE(1);
+            width = segment.readUInt16BE(3);
+            const count = segment[5];
+            ctx.check(width > 0 &&
+                height > 0 &&
+                count > 0 &&
+                segment.length === 6 + count * 3, "JPEG/SOF0", "Invalid dimensions or frame component count.");
+            if (![1, 3].includes(count))
+                ctx.unsupported("JPEG/components", "Only grayscale and three-component baseline JPEG are implemented.");
+            for (let i = 0; i < count; i++) {
+                const p = 6 + i * 3, id = segment[p], h = segment[p + 1] >>> 4, v = segment[p + 1] & 15, q = segment[p + 2];
+                ctx.check(!components.some((c) => c.id === id) &&
+                    h > 0 &&
+                    h <= 4 &&
+                    v > 0 &&
+                    v <= 4 &&
+                    q <= 3, "JPEG/SOF0", "Invalid frame component or sampling factor.");
+                components.push({ id, h, v, q });
+            }
+            ctx.check(components.reduce((n, c) => n + c.h * c.v, 0) <= 10, "JPEG/SOF0", "Too many blocks per MCU.");
+            if (count === 1 && (components[0].h !== 1 || components[0].v !== 1))
+                ctx.unsupported("JPEG/sampling", "Grayscale sampling factors other than 1x1 are not implemented.");
+        }
+        else if (marker === 0xdd) {
+            ctx.check(segment.length === 2, "JPEG/DRI", "Invalid restart interval segment.");
+            restartInterval = segment.readUInt16BE(0);
+        }
+        else if (marker === 0xda) {
+            ctx.check(components.length && segment.length >= 4, "JPEG/SOS", "Missing frame or truncated scan header.");
+            const count = segment[0];
+            ctx.check(count > 0 && segment.length === 1 + count * 2 + 3, "JPEG/SOS", "Invalid scan component count.");
+            if (count !== components.length)
+                ctx.unsupported("JPEG/SOS", "Multiple/non-interleaved scans are not implemented.");
+            ctx.check(segment[segment.length - 3] === 0 &&
+                segment[segment.length - 2] === 63 &&
+                segment[segment.length - 1] === 0, "JPEG/SOS", "Invalid baseline spectral selection.");
+            const scan = [];
+            for (let i = 0; i < count; i++) {
+                const id = segment[1 + i * 2], spec = segment[2 + i * 2], c = components.find((c) => c.id === id);
+                ctx.check(c && !scan.includes(c), "JPEG/SOS", "Unknown or duplicate scan component.");
+                c.dc = spec >>> 4;
+                c.ac = spec & 15;
+                ctx.check(quantization.has(c.q) &&
+                    tables.has(`0/${c.dc}`) &&
+                    tables.has(`1/${c.ac}`), "JPEG/SOS", "Missing quantization or Huffman table.");
+                scan.push(c);
+            }
+            const hmax = Math.max(...components.map((c) => c.h)), vmax = Math.max(...components.map((c) => c.v));
+            const mcus = Math.ceil(width / (8 * hmax)) * Math.ceil(height / (8 * vmax));
+            if (mcus * components.reduce((n, c) => n + c.h * c.v, 0) > 8_000_000)
+                ctx.unsupported("JPEG/scan", "Image exceeds the inspection block limit.");
+            let bitsLeft = 0, current = 0, restart = 0;
+            const bit = () => {
+                if (!bitsLeft) {
+                    ctx.check(offset < data.length, "JPEG/entropy", "Truncated entropy stream.");
+                    current = data[offset++];
+                    if (current === 0xff)
+                        ctx.check(data[offset++] === 0, "JPEG/entropy", "Unexpected marker or truncated entropy stream.");
+                    bitsLeft = 8;
+                }
+                return (current >>> --bitsLeft) & 1;
+            };
+            const symbol = (table) => {
+                let code = 0;
+                for (let n = 1; n <= 16; n++) {
+                    code = code * 2 + bit();
+                    const value = table.get((1 << n) + code);
+                    if (value !== undefined)
+                        return value;
+                }
+                return ctx.invalid("JPEG/entropy", "Entropy code is absent from Huffman table.");
+            };
+            const align = () => {
+                ctx.check((current & ((1 << bitsLeft) - 1)) === (1 << bitsLeft) - 1, "JPEG/entropy", "Invalid entropy padding bits.");
+                bitsLeft = 0;
+            };
+            for (let mcu = 0; mcu < mcus; mcu++) {
+                if (mcu && restartInterval && mcu % restartInterval === 0) {
+                    align();
+                    ctx.check(data[offset++] === 0xff &&
+                        data[offset++] === 0xd0 + (restart++ % 8), "JPEG/restart", "Missing or out-of-order restart marker.");
+                }
+                for (const c of scan)
+                    for (let block = 0; block < c.h * c.v; block++) {
+                        const dcBits = symbol(tables.get(`0/${c.dc}`));
+                        for (let i = 0; i < dcBits; i++)
+                            bit();
+                        let coefficient = 1;
+                        while (coefficient < 64) {
+                            const ac = symbol(tables.get(`1/${c.ac}`));
+                            if (ac === 0)
+                                break;
+                            if (ac === 0xf0)
+                                coefficient += 16;
+                            else {
+                                coefficient += ac >>> 4;
+                                ctx.check(coefficient < 64, "JPEG/entropy", "AC run exceeds block boundary.");
+                                for (let i = 0; i < (ac & 15); i++)
+                                    bit();
+                                coefficient++;
+                            }
+                            ctx.check(coefficient <= 64, "JPEG/entropy", "AC run exceeds block boundary.");
+                        }
+                    }
+            }
+            align();
+            ctx.check(data[offset++] === 0xff, "JPEG/EOI", "Missing end marker or excess entropy data.");
+            while (data[offset] === 0xff)
+                offset++;
+            ctx.check(data[offset++] === 0xd9 && offset === data.length, "JPEG/EOI", "Missing end marker, extra scan or trailing data.");
+            return {
+                format: "jpeg",
+                width,
+                height,
+                bitDepth: 8,
+                channels: components.length,
+                encoding: "baseline-huffman",
+            };
+        }
+        else if ((marker >= 0xc1 &&
+            marker <= 0xcf &&
+            ![0xc4, 0xc8, 0xcc].includes(marker)) ||
+            marker === 0xcc) {
+            ctx.unsupported("JPEG/encoding", `JPEG frame/coding marker 0x${marker.toString(16)} is not baseline Huffman (SOF0).`);
+        }
+        else if (!(marker >= 0xe0 && marker <= 0xef) && marker !== 0xfe) {
+            ctx.unsupported("JPEG/marker", `JPEG marker 0x${marker.toString(16)} is not implemented.`);
+        }
+    }
+    return ctx.invalid("JPEG/SOS", "Missing image scan or truncated JPEG.");
+}