Vito
0095db8cbc
* feat(inspect): bounded browser PNG reader matching the server's
The Inspect page will read a chosen file entirely in the browser, and the
record it shows must equal what Images shows for the same bytes. This adds
to web/js/png-metadata.js (loaded by the legacy pages as before, with
parsePngTextChunks unchanged):
- readPngMetadataFile(file, {signal, prefix, yieldControl, decompress}):
a port of utils/prompt_inspector.py's _png_metadata, _PngRecords,
_png_text, _inflate and _batch_normalized. It slices only chunk headers,
80-byte keyword prefixes and the retained prompt, workflow, parameters
and comfyassets_prompt_pairs records, CRC-checks what it keeps, applies
the same budgets (2 MiB shared role budget encoded and decoded, 4 MiB
workflow that becomes limited, 8 MiB and 4 MiB duplicate budgets, 4 MiB
duplicate decoded parameters, 10,000 chunks, the batch-index rule for
parameters copies) and compares duplicate chunks byte for byte. Every
range is checked against file.size before slicing and charged against a
19,794,389-byte ceiling, so a multi-gigabyte PNG costs only its metadata.
Compressed text inflates through DecompressionStream with one 256-byte
write in flight and the output capped at the record's allowance; an
AbortSignal rejects the read with an AbortError and leaves no unhandled
rejection; yieldControl runs about every 8 ms of work.
- classifyPrefix(bytes): png, jpeg, webp, iso-bmff, matroska, avi, asf or
null from the first 32 bytes.
- readImageHeader(file, kind): JPEG (SOFn walk as Pillow) and WebP (VP8,
VP8L, VP8X) dimensions from at most 64 KiB.
tests/test_local_inspect_parity.py drives tests/js/support/local-inspect-
oracle.mjs over the committed and test-time inspection parity corpus plus
compressed, oversized, Latin-1, batch-duplicate and all-four-record shapes,
and asserts records, record formats, dimensions and readability equal
read_inspection_file on each file; the two JPEG/WebP fixtures are checked
against Pillow. tests/js/png-local-reader.test.js pins each server rule,
the sparse 3 GiB read, the prefix reuse, inflation back-pressure and abort.
tests/fixtures/local-inspect/tiny.{jpg,webp} are CC0 FFmpeg test patterns.
* feat(inspect): bounded browser video tag readers
Add web/js/workspace/local-video.mjs: ISO-BMFF (MP4/MOV/M4V) and Matroska
(MKV/WebM) walkers that read only the container tags the server asks ffprobe
for, slicing box and element headers, carrier names and retained values within
the server's budgets and never a byte inside mdat or a Cluster; a port of
utils/video_metadata.select_video_carrier with the record budgets of
read_inspection_file; and a byte-exact json.loads/json.dumps round trip so
envelope objects reserialize as the server spells them.
Every naming rule mirrors ffprobe 9.0.2 on hand-built files: legacy ilst atoms,
mdta keys, joined repeats, data types, Matroska language and default handling,
and Tags behind a Cluster found only through a SeekHead.
Tests: node units over byte-exact container builders and the committed
fixtures; a Python parity test comparing the local carrier with the server's
selection from the same tag maps (mocked probe) and from the same files (real
ffprobe, including 1 MiB + 2.5 MiB per-key records); an ffprobe
characterization of the recorded fixture maps.
* feat(inspect): server-identical local projection and payload
Port utils/inspection_response.py to the browser: a strict parse with Python's
Decimal spelling, duplicate-key rejection, NaN/Infinity as null and integers
past 2^53-1 as text; the prompt, workflow and carrier projection with the
depth-64 and 20,000-node ceilings; _metadata; and the 8 MiB omission steps
(workflow graph, then prompt graph, then all raw) measured as UTF-8 bytes.
local-inspection.mjs builds the inspection_version 1 wire for one chosen File
from the Task 1 and Task 2 readers (observation selected-local-file, interim
unresolved roles, unavailable library), fits it to the response budget, and
exposes localFileAdapter for the shared controller, inspector and viewer:
handles are session-owned by a private token, so a tampered or hand-made
descriptor is rejected and blob: URLs are never resolved through the API
client. projectInspectionPayload admits selected-local-file only for a
local-file identity.
A Python oracle test compares projectMetadata with _metadata byte for byte over
the parity PNG corpus, the committed video fixtures and tag maps, 75 committed
adversarial record sets (projection-cases.json) and node-ceiling sets built at
test time.
* test(inspect): import oracle modules by file URL for Windows
The local-inspect oracle imported product modules with path.join(...), which
Node parses as a URL scheme on Windows (D:\... -> ERR_UNSUPPORTED_ESM_URL_SCHEME),
failing every tests/test_local_inspect_parity.py oracle test on the Windows CI
job. Every dynamic import in tests/js/support now goes through moduleUrl, a
pathToFileURL wrapper, and a node unit proves the Windows form on any host and
scans the oracles so a path import cannot return.
* fix(inspect): read video tags as ffprobe reports them
Same bytes now give the server's record in five shapes where the local
reader was stricter or kept different tags (PR #277 final review I1, I2,
M1, M2, M4):
- Invalid UTF-8 in a tag value is replaced as ffprobe's default
string_validation=replace does (av_utf8_decode, one U+FFFD per failing
decode step), instead of failing the read. Key names and TagNames that
do not decode are no carrier and are skipped.
- An ilst item whose keys index is 0 or out of range is skipped, as
ffmpeg does, instead of failing the read.
- Only the first keys box is read, as ffmpeg does.
- A first per-key workflow over 4 MiB keeps its place in the carrier
choice as an unread marker, so the server's carrier (per-key, workflow
limited) is chosen; when the server's first probe would overflow, the
re-probe leaves it out and its own bound applies.
- An envelope integer of more than 4300 digits fails the Python json
port, so that envelope is skipped as CPython's json.loads skips it.
Each shape was checked against ffprobe 9.0.2 and read_inspection_file;
the real-ffprobe parity test now builds them, and a 600-case random-byte
comparison of the replacement against ffprobe matched.
* perf(inspect): measure the local response size natively and yield between steps
fitInspectionPayload counted the UTF-8 size of an 8-12 MB wire with a
per-character loop and ran every omission step on the main thread in one
turn (PR #277 final review M7). The size is now counted by TextEncoder
encodeInto through one bounded scratch buffer, and each re-measure
follows a yieldControl turn, with an abort signal checked between steps.
The fit is async; the fitted payload is the same as before.
* fix(inspect): hold video tags as ffmpeg's dictionary does, decode Mac Roman text
Three more same-bytes divergences, found while verifying the review
fixes against ffprobe 9.0.2 and read_inspection_file:
- ffmpeg keeps one tag per ASCII-folded name under the spelling set
last (ISO-BMFF joins the values with ";", Matroska keeps the last), so
PROMPT and Prompt are one record on the server; the local reader kept
both and failed the read as a duplicate. A legacy comment atom and a
later COMMENT key likewise leave no exact-case envelope.
- ffprobe's format_tags filter folds ASCII case only, so a name that is
"workflow" only under Unicode case rules is never reported; the local
reader took it.
- ISO-BMFF data types 0 and 3 are Mac Roman text to ffmpeg, written into
twice the input size (a long value is cut); the local reader decoded
type 0 as UTF-8 and skipped type 3.
The real-ffprobe parity test builds each shape.
* docs(testing): list the local Inspect divergences; raise touched coverage floors
TESTING.md now tracks the local Inspect (#249 PR L1) divergences that
remain after the review fixes, each checked on a host with ffprobe 9.0.2:
media kind by bytes versus extension (parity is for the same bytes with a
matching extension), JPEG dimensions past the 64 KiB header read, classic
QuickTime udta text atoms, raw versus escaped tag bounds, the 10,000
element ceiling, unknown EBML DocTypes, the JSON depth approximation and
the C _decimal assumption.
coverage:update raised the branch floors of the three local Inspect
modules this PR touches; the unrelated activity-scan raise it proposed is
left at main's values.
550 lines
34 KiB
JavaScript
550 lines
34 KiB
JavaScript
// Run with: node --test tests/js/
|
||
// The browser PNG File reader is a port of utils/prompt_inspector.py's bounded
|
||
// reader (_png_metadata, _PngRecords, _png_text, _inflate, _batch_normalized). Each
|
||
// rule below names the Python branch it mirrors; tests/test_local_inspect_parity.py
|
||
// proves the two agree on the committed parity corpus.
|
||
const test = require("node:test");
|
||
const assert = require("node:assert/strict");
|
||
const fs = require("node:fs");
|
||
const path = require("node:path");
|
||
const zlib = require("node:zlib");
|
||
const { classifyPrefix, readPngMetadataFile, readImageHeader } = require("../../web/js/png-metadata.js");
|
||
const bytes = require("./helpers/png-bytes.mjs");
|
||
|
||
const { png, raw, ihdr, idat, iend, tEXt, zTXt, iTXt, chunk, blobOf, sparseBlob, recordingBlob, slowBlob, failingBlob, shrunkBlob, concat, u32, latin1, parametersText } = bytes;
|
||
|
||
const MiB = 1024 * 1024;
|
||
const ROLE_BUDGET = 2 * MiB;
|
||
const WORKFLOW_BUDGET = 4 * MiB;
|
||
const PNG_READ_CEILING = 19794389;
|
||
const FIXTURES = path.join(__dirname, "..", "fixtures", "local-inspect");
|
||
|
||
async function read(fileBytes, options) {
|
||
return readPngMetadataFile(blobOf(fileBytes), options);
|
||
}
|
||
|
||
function fill(byte, count) {
|
||
return Buffer.alloc(count, byte);
|
||
}
|
||
|
||
test("contract: the reader, classifier and header reader are exported", () => {
|
||
assert.equal(typeof readPngMetadataFile, "function");
|
||
assert.equal(typeof classifyPrefix, "function");
|
||
assert.equal(typeof readImageHeader, "function");
|
||
});
|
||
|
||
test("reads the four retained records and the IHDR size from a core SaveImage PNG", async () => {
|
||
const result = await read(raw(
|
||
ihdr(640, 480),
|
||
idat(),
|
||
tEXt("prompt", '{"1":{"class_type":"KSampler"}}'),
|
||
iTXt("workflow", '{"nodes":[]}'),
|
||
tEXt("parameters", "cat\nSteps: 20, Seed: 1"),
|
||
zTXt("comfyassets_prompt_pairs", '{"pairs":[]}'),
|
||
tEXt("Software", "ComfyUI"),
|
||
iend(),
|
||
));
|
||
assert.deepEqual(result, {
|
||
status: "complete",
|
||
records: {
|
||
prompt: '{"1":{"class_type":"KSampler"}}',
|
||
workflow: '{"nodes":[]}',
|
||
parameters: "cat\nSteps: 20, Seed: 1",
|
||
comfyassets_prompt_pairs: '{"pairs":[]}',
|
||
},
|
||
limited: [],
|
||
width: 640,
|
||
height: 480,
|
||
});
|
||
});
|
||
|
||
test("local PNG skips sparse pixels and reads post-IDAT text", async () => {
|
||
// Two 1.5 GiB IDAT chunks (each under the 0x7FFFFFFF chunk ceiling) with the
|
||
// prompt after them: nothing of the 3 GiB is read or allocated.
|
||
const half = 1.5 * 1024 * 1024 * 1024;
|
||
const head = concat(bytes.SIGNATURE, ihdr(8192, 8192), u32(half), latin1("IDAT"));
|
||
const idat1 = { start: bytes.SIGNATURE.length + ihdr().length, end: bytes.SIGNATURE.length + ihdr().length + 8 + half + 4 };
|
||
const idat2 = { start: idat1.end, end: idat1.end + 8 + half + 4 };
|
||
const between = concat(u32(0), u32(half), latin1("IDAT"));
|
||
const tail = concat(u32(0), tEXt("prompt", '{"3":{"class_type":"KSampler"}}'), iend());
|
||
const size = idat2.end - 4 + tail.length;
|
||
const file = sparseBlob([
|
||
{ offset: 0, bytes: head },
|
||
{ offset: idat1.end - 4, bytes: between },
|
||
{ offset: idat2.end - 4, bytes: tail },
|
||
], size);
|
||
|
||
const result = await readPngMetadataFile(file);
|
||
|
||
assert.equal(result.status, "complete");
|
||
assert.deepEqual(result.records, { prompt: '{"3":{"class_type":"KSampler"}}' });
|
||
assert.deepEqual([result.width, result.height], [8192, 8192]);
|
||
const insideIdat = file.ranges.filter(([start, end]) => [idat1, idat2].some((region) => start >= region.start && end <= region.end));
|
||
assert.ok(insideIdat.length >= 2, "the IDAT headers were read");
|
||
for (const [start, end] of insideIdat) assert.ok(end - start <= 12, `range inside IDAT longer than 12: [${start}, ${end})`);
|
||
const total = file.ranges.reduce((sum, [start, end]) => sum + (end - start), 0);
|
||
assert.ok(total <= PNG_READ_CEILING, `read ${total} bytes`);
|
||
});
|
||
|
||
test("serves the retained prefix without slicing it again", async () => {
|
||
const whole = png(tEXt("prompt", "p"));
|
||
const file = recordingBlob(whole);
|
||
const result = await readPngMetadataFile(file, { prefix: whole.subarray(0, 32) });
|
||
assert.equal(result.status, "complete");
|
||
assert.ok(file.ranges.every(([start]) => start >= 32), JSON.stringify(file.ranges));
|
||
assert.deepEqual(result.records, { prompt: "p" });
|
||
});
|
||
|
||
test("unknown text keys are skipped by length without reading their body", async () => {
|
||
const body = fill(0x41, 1000);
|
||
const whole = png(tEXt("Software", body), tEXt("prompt", "p"));
|
||
const softwareStart = bytes.SIGNATURE.length + ihdr().length + idat().length;
|
||
const bodyStart = softwareStart + 8 + "Software".length + 1;
|
||
const bodyEnd = bodyStart + body.length + 4;
|
||
const file = recordingBlob(whole);
|
||
const result = await readPngMetadataFile(file);
|
||
assert.equal(result.status, "complete");
|
||
const insideBody = file.ranges.filter(([start, end]) => start < bodyEnd && end > softwareStart + 8 + 80);
|
||
assert.deepEqual(insideBody, [], "the body past the 80-byte keyword prefix was sliced");
|
||
});
|
||
|
||
const WF_OVER = WORKFLOW_BUDGET + 1;
|
||
const bigWorkflow = () => tEXt("workflow", fill(0x7b, WF_OVER - "workflow".length - 1));
|
||
|
||
// One row per Python branch (prompt_inspector.py:91-260).
|
||
const RULES = [
|
||
{ name: "bad IHDR CRC", file: () => raw(ihdr(1, 1, { crc: 1 }), idat(), iend()), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "bad text CRC", file: () => png(tEXt("prompt", "p", { crc: 1 })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "bad IEND CRC", file: () => raw(ihdr(), idat(), iend({ crc: 1 })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "first chunk not IHDR", file: () => raw(idat(), ihdr(), iend()), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "IHDR not 13 bytes", file: () => raw(chunk("IHDR", concat(u32(1), u32(1), [8, 6, 0, 0])), idat(), iend()), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "second IHDR", file: () => raw(ihdr(), idat(), ihdr(), iend()), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "zero width", file: () => raw(ihdr(0, 1), idat(), iend()), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "zero height", file: () => raw(ihdr(1, 0), idat(), iend()), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "length 0x80000000", file: () => raw(ihdr(), idat(), chunk("tEXt", latin1("k\0v"), { declaredLength: 0x80000000 }), iend()), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "end past size", file: () => raw(ihdr(), idat(), chunk("tEXt", latin1("k\0v"), { declaredLength: 100 }), iend()), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "file ends inside a chunk header", file: () => raw(ihdr(), idat(), u32(5)), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "file ends before any chunk", file: () => raw(), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "too short for a signature", file: () => bytes.SIGNATURE.subarray(0, 5), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "not a PNG", file: () => latin1("GIF89a................................."), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "IEND without IDAT", file: () => raw(ihdr(), tEXt("prompt", "p"), iend()), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "nonzero IEND length", file: () => raw(ihdr(), idat(), chunk("IEND", [1])), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "duplicate key with a different length", file: () => png(tEXt("prompt", "one"), tEXt("prompt", "other")), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "duplicate key, same length, different bytes", file: () => png(tEXt("prompt", "one"), tEXt("prompt", "two")), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "duplicate key, same bytes, different chunk type", file: () => png(tEXt("prompt", "one"), chunk("zTXt", latin1("prompt\0one"))), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{
|
||
name: "byte-identical duplicate kept once",
|
||
file: () => png(tEXt("prompt", "same"), tEXt("prompt", "same"), tEXt("prompt", "same")),
|
||
expect: { status: "complete", records: { prompt: "same" }, limited: [], width: 1, height: 1 },
|
||
},
|
||
{
|
||
name: "parameters copies differing only in Batch index keep the last",
|
||
file: () => png(tEXt("parameters", parametersText("cat", 0)), tEXt("parameters", parametersText("cat", 1)), tEXt("parameters", parametersText("cat", 12))),
|
||
expect: { status: "complete", records: { parameters: parametersText("cat", 12) }, limited: [], width: 1, height: 1 },
|
||
},
|
||
{ name: "parameters copies with any other difference", file: () => png(tEXt("parameters", parametersText("cat", 0)), tEXt("parameters", parametersText("dog", 1))), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "parameters copies without a settings footer", file: () => png(tEXt("parameters", "cat"), tEXt("parameters", "dog")), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "parameters copies with two footers", file: () => png(tEXt("parameters", `${parametersText("cat", 0)}\nSteps: 1, x`), tEXt("parameters", `${parametersText("cat", 1)}\nSteps: 1, x`)), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "parameters copies with two batch indexes", file: () => png(tEXt("parameters", parametersText("cat", 0, { seedField: "Batch index: 0" })), tEXt("parameters", parametersText("cat", 1, { seedField: "Batch index: 1" }))), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "parameters copies whose batch index is not a whole settings field", file: () => png(tEXt("parameters", "Steps: 20, Batch index: 0 trailing"), tEXt("parameters", "Steps: 20, Batch index: 1 trailing")), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{
|
||
name: "workflow 4 MiB + 1 encoded is limited, other records intact",
|
||
file: () => png(tEXt("prompt", "p"), bigWorkflow(), tEXt("parameters", "cat\nSteps: 1, x")),
|
||
expect: { status: "complete", records: { prompt: "p", parameters: "cat\nSteps: 1, x" }, limited: ["workflow"], width: 1, height: 1 },
|
||
},
|
||
{
|
||
name: "a duplicate of a limited workflow is skipped",
|
||
file: () => png(bigWorkflow(), bigWorkflow(), tEXt("prompt", "p")),
|
||
expect: { status: "complete", records: { prompt: "p" }, limited: ["workflow"], width: 1, height: 1 },
|
||
},
|
||
{
|
||
name: "workflow over 4 MiB decoded (zTXt) is limited",
|
||
file: () => png(zTXt("workflow", fill(0x7b, WORKFLOW_BUDGET + 1), { level: 9 }), tEXt("prompt", "p")),
|
||
expect: { status: "complete", records: { prompt: "p" }, limited: ["workflow"], width: 1, height: 1 },
|
||
},
|
||
{
|
||
name: "workflow at exactly 4 MiB decoded is kept",
|
||
file: () => png(zTXt("workflow", fill(0x7b, WORKFLOW_BUDGET), { level: 9 })),
|
||
check: (result) => {
|
||
assert.equal(result.status, "complete");
|
||
assert.equal(result.records.workflow.length, WORKFLOW_BUDGET);
|
||
assert.deepEqual(result.limited, []);
|
||
},
|
||
},
|
||
{
|
||
name: "workflow under 4 MiB inflated but over 4 MiB as UTF-8 is limited",
|
||
file: () => png(zTXt("workflow", fill(0xe9, WORKFLOW_BUDGET - 10), { level: 9 }), tEXt("prompt", "p")),
|
||
expect: { status: "complete", records: { prompt: "p" }, limited: ["workflow"], width: 1, height: 1 },
|
||
},
|
||
{ name: "roles 2 MiB + 1 encoded", file: () => png(tEXt("prompt", fill(0x41, ROLE_BUDGET + 1 - "prompt".length - 1))), expect: { status: "unreadable", reason: "metadata-limit" } },
|
||
{ name: "roles summed over 2 MiB encoded", file: () => png(tEXt("prompt", fill(0x41, 1.5 * MiB)), tEXt("parameters", fill(0x41, 0.5 * MiB))), expect: { status: "unreadable", reason: "metadata-limit" } },
|
||
{ name: "roles 2 MiB + 1 decoded via zTXt", file: () => png(zTXt("prompt", fill(0x41, ROLE_BUDGET + 1), { level: 9 })), expect: { status: "unreadable", reason: "metadata-limit" } },
|
||
{ name: "roles over 2 MiB as UTF-8 from Latin-1 high bytes", file: () => png(tEXt("prompt", fill(0xe9, MiB + 1))), expect: { status: "unreadable", reason: "metadata-limit" } },
|
||
{
|
||
name: "roles share the decoded budget across records",
|
||
file: () => png(zTXt("prompt", fill(0x41, 1.5 * MiB), { level: 9 }), zTXt("parameters", fill(0x41, 0.5 * MiB + 1), { level: 9 })),
|
||
expect: { status: "unreadable", reason: "metadata-limit" },
|
||
},
|
||
{
|
||
name: "roles at exactly 2 MiB decoded are kept",
|
||
file: () => png(zTXt("prompt", fill(0x41, 1.5 * MiB), { level: 9 }), zTXt("parameters", fill(0x41, 0.5 * MiB), { level: 9 })),
|
||
check: (result) => {
|
||
assert.equal(result.status, "complete");
|
||
assert.equal(result.records.prompt.length + result.records.parameters.length, ROLE_BUDGET);
|
||
},
|
||
},
|
||
{
|
||
name: "duplicate workflow bytes capped at 8 MiB: the workflow becomes limited",
|
||
file: () => {
|
||
const workflow = tEXt("workflow", fill(0x7b, 3 * MiB));
|
||
return png(workflow, workflow, workflow, workflow, tEXt("prompt", "p"));
|
||
},
|
||
expect: { status: "complete", records: { prompt: "p" }, limited: ["workflow"], width: 1, height: 1 },
|
||
},
|
||
{
|
||
name: "duplicate workflow bytes within 8 MiB keep the workflow",
|
||
file: () => {
|
||
const workflow = tEXt("workflow", fill(0x7b, 3 * MiB));
|
||
return png(workflow, workflow, workflow);
|
||
},
|
||
check: (result) => {
|
||
assert.equal(result.status, "complete");
|
||
assert.equal(result.records.workflow.length, 3 * MiB);
|
||
assert.deepEqual(result.limited, []);
|
||
},
|
||
},
|
||
{
|
||
name: "duplicate role bytes capped at 4 MiB",
|
||
file: () => {
|
||
const prompt = tEXt("prompt", fill(0x41, 1.5 * MiB));
|
||
return png(prompt, prompt, prompt, prompt);
|
||
},
|
||
expect: { status: "unreadable", reason: "metadata-limit" },
|
||
},
|
||
{
|
||
name: "duplicate decoded parameters capped at 4 MiB",
|
||
file: () => {
|
||
const copy = (index) => zTXt("parameters", parametersText(fill(0x41, 1.5 * MiB).toString("latin1"), index), { level: 9 });
|
||
return png(copy(0), copy(1), copy(2), copy(3));
|
||
},
|
||
expect: { status: "unreadable", reason: "metadata-limit" },
|
||
},
|
||
{
|
||
name: "a longer batch copy draws the growth from the role budget",
|
||
file: () => {
|
||
const base = parametersText("", 9);
|
||
const positive = fill(0x41, ROLE_BUDGET - base.length - 1).toString("latin1");
|
||
return png(zTXt("parameters", parametersText(positive, 9), { level: 9 }), zTXt("parameters", parametersText(positive, 100), { level: 9 }));
|
||
},
|
||
expect: { status: "unreadable", reason: "metadata-limit" },
|
||
},
|
||
{
|
||
name: "a longer batch copy within the role budget is kept",
|
||
file: () => {
|
||
const base = parametersText("", 9);
|
||
const positive = fill(0x41, ROLE_BUDGET - base.length - 2).toString("latin1");
|
||
return png(zTXt("parameters", parametersText(positive, 9), { level: 9 }), zTXt("parameters", parametersText(positive, 10), { level: 9 }));
|
||
},
|
||
check: (result) => {
|
||
assert.equal(result.status, "complete");
|
||
assert.ok(result.records.parameters.endsWith("Batch index: 10, Seed: 1"));
|
||
},
|
||
},
|
||
{
|
||
name: "a batch copy inflating past the role budget",
|
||
file: () => png(tEXt("parameters", parametersText("cat", 0)), zTXt("parameters", parametersText(fill(0x41, ROLE_BUDGET).toString("latin1"), 1), { level: 9 })),
|
||
expect: { status: "unreadable", reason: "metadata-limit" },
|
||
},
|
||
{
|
||
name: "10,000 chunks without IEND",
|
||
file: () => concat(bytes.SIGNATURE, ihdr(), idat(), ...Array.from({ length: 9999 }, () => chunk("xxXx", [])), iend()),
|
||
expect: { status: "unreadable", reason: "metadata-limit" },
|
||
},
|
||
{
|
||
name: "IEND as the 10,000th chunk is read",
|
||
file: () => concat(bytes.SIGNATURE, ihdr(), idat(), ...Array.from({ length: 9997 }, () => chunk("xxXx", [])), iend()),
|
||
expect: { status: "complete", records: {}, limited: [], width: 1, height: 1 },
|
||
},
|
||
{ name: "zTXt method not 0", file: () => png(zTXt("prompt", "p", { method: 1 })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "zTXt without a method byte", file: () => png(chunk("zTXt", latin1("prompt\0"))), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "iTXt flag 2", file: () => png(iTXt("prompt", "p", { flag: 2 })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "iTXt compressed with method 1", file: () => png(iTXt("prompt", "p", { flag: 1, method: 1 })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{
|
||
name: "iTXt uncompressed ignores the method byte",
|
||
file: () => png(iTXt("prompt", "p", { flag: 0, method: 7 })),
|
||
expect: { status: "complete", records: { prompt: "p" }, limited: [], width: 1, height: 1 },
|
||
},
|
||
{ name: "iTXt shorter than flag and method", file: () => png(chunk("iTXt", latin1("prompt\0\0"))), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "iTXt missing the translated keyword separator", file: () => png(chunk("iTXt", concat(latin1("prompt\0"), [0, 0], latin1("en\0text")))), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "iTXt non-ASCII language tag", file: () => png(iTXt("prompt", "p", { lang: [0xc3, 0xa9] })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "iTXt invalid UTF-8 translated keyword", file: () => png(iTXt("prompt", "p", { translated: [0xff] })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "iTXt invalid UTF-8 text", file: () => png(iTXt("prompt", [0xc3, 0x28])), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "iTXt encoded surrogate", file: () => png(iTXt("prompt", [0xed, 0xa0, 0x80])), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "NUL in tEXt text", file: () => png(tEXt("prompt", "a\0b")), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "NUL in inflated zTXt text", file: () => png(zTXt("prompt", "a\0b")), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "NUL in iTXt text", file: () => png(iTXt("prompt", "a\0b")), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "keyword of 0 bytes", file: () => png(chunk("tEXt", latin1("\0v"))), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "keyword of 80 bytes", file: () => png(tEXt("k".repeat(80), "v")), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "keyword without a NUL", file: () => png(chunk("tEXt", latin1("nonul"))), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "empty text chunk", file: () => png(chunk("tEXt", [])), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "malformed keyword on an unknown key still fails", file: () => png(tEXt("prompt", "p"), chunk("tEXt", latin1("x".repeat(100)))), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{
|
||
name: "keyword of 79 bytes is read",
|
||
file: () => png(tEXt("k".repeat(79), "v"), tEXt("prompt", "p")),
|
||
expect: { status: "complete", records: { prompt: "p" }, limited: [], width: 1, height: 1 },
|
||
},
|
||
{
|
||
name: "Latin-1 0xE9 is an e-acute in tEXt and zTXt",
|
||
file: () => png(tEXt("prompt", [0xe9]), zTXt("parameters", [0xe9, 0x0a, 0x53, 0x74, 0x65, 0x70, 0x73, 0x3a, 0x20, 0x31])),
|
||
expect: { status: "complete", records: { prompt: "é", parameters: "é\nSteps: 1" }, limited: [], width: 1, height: 1 },
|
||
},
|
||
{
|
||
name: "iTXt BOM is preserved, compressed and not",
|
||
file: () => png(iTXt("prompt", "{}"), iTXt("workflow", "[]", { flag: 1, lang: "en", translated: "wörkflow" })),
|
||
expect: { status: "complete", records: { prompt: "{}", workflow: "[]" }, limited: [], width: 1, height: 1 },
|
||
},
|
||
{ name: "truncated zlib data", file: () => png(zTXt("prompt", "x".repeat(500), { compressed: zlib.deflateSync(latin1("x".repeat(500))).subarray(0, 8) })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "trailing bytes after the zlib stream", file: () => png(zTXt("prompt", "p", { compressed: concat(zlib.deflateSync(latin1("p")), [1, 2, 3]) })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "empty zlib data", file: () => png(zTXt("prompt", "p", { compressed: [] })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "garbage zlib data", file: () => png(zTXt("prompt", "p", { compressed: [1, 2, 3, 4, 5, 6, 7, 8] })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{ name: "truncated compressed iTXt", file: () => png(iTXt("prompt", "p", { flag: 1, compressed: zlib.deflateSync(latin1("x".repeat(500))).subarray(0, 8) })), expect: { status: "unreadable", reason: "invalid-png" } },
|
||
{
|
||
name: "chunks after IEND are ignored",
|
||
file: () => concat(png(tEXt("prompt", "p")), tEXt("workflow", "w")),
|
||
expect: { status: "complete", records: { prompt: "p" }, limited: [], width: 1, height: 1 },
|
||
},
|
||
{
|
||
name: "non-ASCII chunk types are skipped",
|
||
file: () => png(chunk("\xff\xfe\x80\x81", [1, 2, 3]), tEXt("prompt", "p")),
|
||
expect: { status: "complete", records: { prompt: "p" }, limited: [], width: 1, height: 1 },
|
||
},
|
||
];
|
||
|
||
for (const rule of RULES) {
|
||
test(`server rules, one by one: ${rule.name}`, async () => {
|
||
const result = await read(rule.file());
|
||
if (rule.check) rule.check(result);
|
||
else assert.deepEqual(result, rule.expect);
|
||
});
|
||
}
|
||
|
||
test("decompress: undefined with zTXt is decompression-unavailable and yields no records", async () => {
|
||
const result = await read(png(tEXt("prompt", "p"), zTXt("workflow", "w")), { decompress: undefined });
|
||
assert.deepEqual(result, { status: "unreadable", reason: "decompression-unavailable" });
|
||
const plain = await read(png(tEXt("prompt", "p"), zTXt("Comment", "skipped")), { decompress: undefined });
|
||
assert.deepEqual(plain.records, { prompt: "p" });
|
||
});
|
||
|
||
function instrumentedStream(transform) {
|
||
const stats = { writes: [], inFlight: 0, maxInFlight: 0 };
|
||
return {
|
||
stats,
|
||
Stream: class {
|
||
constructor() {
|
||
const stream = new TransformStream({
|
||
async transform(chunk, controller) {
|
||
stats.writes.push(chunk.byteLength);
|
||
stats.inFlight += 1;
|
||
stats.maxInFlight = Math.max(stats.maxInFlight, stats.inFlight);
|
||
await transform(chunk, controller);
|
||
stats.inFlight -= 1;
|
||
},
|
||
});
|
||
this.writable = stream.writable;
|
||
this.readable = stream.readable;
|
||
}
|
||
},
|
||
};
|
||
}
|
||
|
||
test("inflation keeps one <=256-byte write in flight", async () => {
|
||
const body = fill(0x41, 3000);
|
||
const { stats, Stream } = instrumentedStream(async (chunk, controller) => {
|
||
await new Promise((resolve) => setTimeout(resolve, 1));
|
||
controller.enqueue(chunk);
|
||
});
|
||
// The fake "inflates" by passing bytes through, so the stored body is the text.
|
||
const result = await read(png(chunk("zTXt", concat(latin1("prompt\0"), [0], body))), { decompress: Stream });
|
||
assert.equal(result.status, "complete");
|
||
assert.equal(result.records.prompt, body.toString("latin1"));
|
||
assert.ok(stats.writes.every((size) => size <= 256), JSON.stringify(stats.writes));
|
||
assert.equal(stats.writes.reduce((sum, size) => sum + size, 0), body.length);
|
||
assert.equal(stats.maxInFlight, 1);
|
||
});
|
||
|
||
test("inflation settles once on abort with an AbortError and no unhandled rejection", async () => {
|
||
const unhandled = [];
|
||
const onUnhandled = (reason) => unhandled.push(reason);
|
||
process.on("unhandledRejection", onUnhandled);
|
||
try {
|
||
const { stats, Stream } = instrumentedStream(() => new Promise(() => {}));
|
||
const controller = new AbortController();
|
||
const pending = readPngMetadataFile(blobOf(png(zTXt("prompt", "p".repeat(1000)))), { decompress: Stream, signal: controller.signal });
|
||
let settled = 0;
|
||
pending.then(() => settled++, () => settled++);
|
||
await new Promise((resolve) => setTimeout(resolve, 5));
|
||
assert.equal(settled, 0, "the read waits on the stream");
|
||
controller.abort();
|
||
await assert.rejects(pending, (error) => error.name === "AbortError");
|
||
await new Promise((resolve) => setTimeout(resolve, 10));
|
||
assert.equal(settled, 1);
|
||
assert.equal(stats.maxInFlight, 1);
|
||
assert.deepEqual(unhandled, []);
|
||
} finally {
|
||
process.off("unhandledRejection", onUnhandled);
|
||
}
|
||
});
|
||
|
||
test("a stream error under a live signal is still invalid-png, not an abort", async () => {
|
||
const controller = new AbortController();
|
||
const result = await read(png(zTXt("prompt", "p", { compressed: [1, 2, 3, 4, 5, 6, 7, 8] })), { signal: controller.signal });
|
||
assert.deepEqual(result, { status: "unreadable", reason: "invalid-png" });
|
||
assert.equal(controller.signal.aborted, false);
|
||
});
|
||
|
||
test("an already aborted signal rejects before any slice", async () => {
|
||
const controller = new AbortController();
|
||
controller.abort();
|
||
const file = recordingBlob(png(tEXt("prompt", "p")));
|
||
await assert.rejects(readPngMetadataFile(file, { signal: controller.signal }), (error) => error.name === "AbortError");
|
||
assert.deepEqual(file.ranges, []);
|
||
});
|
||
|
||
test("aborting between slices rejects with an AbortError", async () => {
|
||
const controller = new AbortController();
|
||
const whole = png(tEXt("prompt", "p"));
|
||
let slices = 0;
|
||
const file = {
|
||
size: whole.length,
|
||
slice(start, end) {
|
||
return {
|
||
arrayBuffer: async () => {
|
||
if (++slices === 3) controller.abort();
|
||
return whole.slice(start, end).buffer;
|
||
},
|
||
};
|
||
},
|
||
};
|
||
await assert.rejects(readPngMetadataFile(file, { signal: controller.signal }), (error) => error.name === "AbortError");
|
||
});
|
||
|
||
test("aborting while inflating a real deflate stream rejects with an AbortError", async () => {
|
||
const controller = new AbortController();
|
||
let inflating = false;
|
||
class Tracked extends DecompressionStream {
|
||
constructor(format) {
|
||
super(format);
|
||
inflating = true;
|
||
}
|
||
}
|
||
// The slow slices make the pacer yield inside the inflater's feed loop; that
|
||
// yield aborts, so the real stream is torn down mid-inflation.
|
||
const yieldControl = async () => {
|
||
if (inflating) controller.abort();
|
||
};
|
||
const slow = slowBlob(png(zTXt("prompt", "p", { compressed: require("node:crypto").randomBytes(5000) })), 10);
|
||
await assert.rejects(readPngMetadataFile(slow, { signal: controller.signal, yieldControl, decompress: Tracked }), (error) => error.name === "AbortError");
|
||
assert.equal(inflating, true);
|
||
});
|
||
|
||
test("yields control about every 8 ms while the file answers slowly", async () => {
|
||
let yields = 0;
|
||
const yieldControl = async () => {
|
||
yields += 1;
|
||
};
|
||
const result = await readPngMetadataFile(slowBlob(png(tEXt("prompt", "p")), 10), { yieldControl });
|
||
assert.equal(result.status, "complete");
|
||
assert.ok(yields >= 1, `yielded ${yields} times`);
|
||
});
|
||
|
||
test("the default yield lets the event loop turn", async () => {
|
||
const result = await readPngMetadataFile(slowBlob(png(tEXt("prompt", "p")), 10));
|
||
assert.deepEqual(result.records, { prompt: "p" });
|
||
});
|
||
|
||
test("a slice that fails is a read failure", async () => {
|
||
assert.deepEqual(await readPngMetadataFile(failingBlob(100)), { status: "unreadable", reason: "read-failure" });
|
||
assert.deepEqual(await readPngMetadataFile(null), { status: "unreadable", reason: "read-failure" });
|
||
});
|
||
|
||
test("a file that shrank under the reader is a read failure", async () => {
|
||
const whole = png(tEXt("prompt", "p"));
|
||
assert.deepEqual(await readPngMetadataFile(shrunkBlob(whole.subarray(0, 40), whole.length)), { status: "unreadable", reason: "read-failure" });
|
||
});
|
||
|
||
test("classifier", () => {
|
||
assert.deepEqual(classifyPrefix(bytes.SIGNATURE), { media: "image", kind: "png" });
|
||
assert.deepEqual(classifyPrefix(Uint8Array.from([0xff, 0xd8, 0xff, 0xe0])), { media: "image", kind: "jpeg" });
|
||
assert.deepEqual(classifyPrefix(latin1("RIFF\0\0\0\0WEBPVP8 ")), { media: "image", kind: "webp" });
|
||
assert.deepEqual(classifyPrefix(latin1("\0\0\0\x18ftypisom\0\0\0\0")), { media: "video", kind: "iso-bmff" });
|
||
assert.deepEqual(classifyPrefix(latin1("\0\0\0\x14ftypqt ")), { media: "video", kind: "iso-bmff" });
|
||
assert.deepEqual(classifyPrefix(Uint8Array.from([0x1a, 0x45, 0xdf, 0xa3, 0x01])), { media: "video", kind: "matroska" });
|
||
assert.deepEqual(classifyPrefix(latin1("RIFF\0\0\0\0AVI LIST")), { media: "video", kind: "avi" });
|
||
const asf = Uint8Array.from([0x30, 0x26, 0xb2, 0x75, 0x8e, 0x66, 0xcf, 0x11, 0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62, 0xce, 0x6c, 0, 0]);
|
||
assert.deepEqual(classifyPrefix(asf), { media: "video", kind: "asf" });
|
||
assert.deepEqual(classifyPrefix(asf.buffer), { media: "video", kind: "asf" });
|
||
for (const text of ["plain text file", "<!DOCTYPE html><html>", '<?xml version="1.0"?><svg', "#EXTM3U\n#EXT-X-VERSION:3", "RIFF\0\0\0\0WAVEfmt ", "\0\0\0\x18moov", ""]) {
|
||
assert.equal(classifyPrefix(latin1(text)), null, text);
|
||
}
|
||
assert.equal(classifyPrefix(bytes.SIGNATURE.subarray(0, 7)), null);
|
||
assert.equal(classifyPrefix(Uint8Array.from([0xff, 0xd8])), null);
|
||
assert.equal(classifyPrefix("not bytes"), null);
|
||
assert.equal(classifyPrefix(null), null);
|
||
});
|
||
|
||
test("image header: JPEG and WebP fixtures match Pillow's dimensions", async () => {
|
||
// tests/test_local_inspect_parity.py asserts the same two files against Pillow.
|
||
const jpeg = blobOf(fs.readFileSync(path.join(FIXTURES, "tiny.jpg")));
|
||
assert.deepEqual(await readImageHeader(jpeg, "jpeg"), { format: "JPEG", width: 48, height: 32 });
|
||
const webp = blobOf(fs.readFileSync(path.join(FIXTURES, "tiny.webp")));
|
||
assert.deepEqual(await readImageHeader(webp, "webp"), { format: "WEBP", width: 40, height: 24 });
|
||
});
|
||
|
||
test("image header: JPEG marker walk skips padding, junk, standalone markers and tables", async () => {
|
||
const segment = (marker, body) => concat([0xff, marker], u32(body.length + 2).subarray(2), body);
|
||
const sof = (marker, width, height) => segment(marker, concat([8], u32(height).subarray(2), u32(width).subarray(2), [3]));
|
||
const sized = concat([0xff, 0xd8], segment(0xe1, fill(0, 20)), [0xff, 0xff, 0xff, 0x00, 0x00, 0x11], [0xff, 0xd0], [0xff, 0x01], segment(0xc4, fill(0, 4)), segment(0xc8, []), segment(0xcc, [1]), sof(0xc2, 300, 200));
|
||
assert.deepEqual(await readImageHeader(blobOf(sized), "jpeg"), { format: "JPEG", width: 300, height: 200 });
|
||
for (const marker of [0xc0, 0xc1, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf]) {
|
||
assert.deepEqual(await readImageHeader(blobOf(concat([0xff, 0xd8], sof(marker, 7, 9))), "jpeg"), { format: "JPEG", width: 7, height: 9 }, marker.toString(16));
|
||
}
|
||
const none = { format: "JPEG", width: null, height: null };
|
||
assert.deepEqual(await readImageHeader(blobOf(concat([0xff, 0xd8], segment(0xda, [1]))), "jpeg"), none, "SOS before SOF");
|
||
assert.deepEqual(await readImageHeader(blobOf(concat([0xff, 0xd8], [0xff])), "jpeg"), none, "ends on a marker byte");
|
||
assert.deepEqual(await readImageHeader(blobOf(concat([0xff, 0xd8], [0xff, 0xe1, 0x00])), "jpeg"), none, "ends inside a length");
|
||
assert.deepEqual(await readImageHeader(blobOf(concat([0xff, 0xd8], [0xff, 0xc0, 0x00, 0x08, 8, 0])), "jpeg"), none, "ends inside SOF");
|
||
assert.deepEqual(await readImageHeader(blobOf(concat([0xff, 0xd8], segment(0xe1, []))), "jpeg"), none, "no SOF at all");
|
||
assert.deepEqual(await readImageHeader(blobOf(Uint8Array.from([0xff])), "jpeg"), none, "too short");
|
||
assert.deepEqual(await readImageHeader(blobOf(latin1("RIFF")), "jpeg"), none, "not a JPEG");
|
||
// A SOF past the 64 KiB read gives no dimensions rather than reading on.
|
||
assert.deepEqual(await readImageHeader(blobOf(concat([0xff, 0xd8], segment(0xe1, fill(0, 65000)), segment(0xe2, fill(0, 1000)), sof(0xc0, 5, 5))), "jpeg"), none, "SOF beyond 64 KiB");
|
||
});
|
||
|
||
test("image header: WebP VP8, VP8L and VP8X headers", async () => {
|
||
const riff = (...rest) => concat(latin1("RIFF"), u32(0), latin1("WEBP"), ...rest);
|
||
const chunkHeader = (type, size) => concat(latin1(type), Uint8Array.from([size & 0xff, (size >>> 8) & 0xff, (size >>> 16) & 0xff, 0]));
|
||
const vp8 = riff(chunkHeader("VP8 ", 100), [0x30, 0x0b, 0x00, 0x9d, 0x01, 0x2a], [40, 0x40], [24, 0x80], fill(0, 20));
|
||
assert.deepEqual(await readImageHeader(blobOf(vp8), "webp"), { format: "WEBP", width: 40, height: 24 }, "scale bits are masked");
|
||
// 14-bit width-1 = 63 and height-1 = 47, little-endian bit-packed after the 0x2f signature.
|
||
const vp8l = riff(chunkHeader("VP8L", 100), [0x2f], [0x3f, 0xc0, 0x0b, 0x00, 0x00], fill(0, 20));
|
||
assert.deepEqual(await readImageHeader(blobOf(vp8l), "webp"), { format: "WEBP", width: 64, height: 48 });
|
||
const vp8x = riff(chunkHeader("VP8X", 10), [0x10, 0, 0, 0], [0xff, 0x00, 0x01], [0x2f, 0x00, 0x00], fill(0, 20));
|
||
assert.deepEqual(await readImageHeader(blobOf(vp8x), "webp"), { format: "WEBP", width: 65792, height: 48 });
|
||
const none = { format: "WEBP", width: null, height: null };
|
||
assert.deepEqual(await readImageHeader(blobOf(riff(chunkHeader("VP8 ", 100), [0x30, 0x0b, 0x00, 0x00, 0x01, 0x2a], fill(0, 24))), "webp"), none, "bad start code");
|
||
assert.deepEqual(await readImageHeader(blobOf(riff(chunkHeader("VP8L", 100), [0x00], fill(0, 24))), "webp"), none, "bad VP8L signature");
|
||
assert.deepEqual(await readImageHeader(blobOf(riff(chunkHeader("ALPH", 100), fill(0, 24))), "webp"), none, "unknown first chunk");
|
||
assert.deepEqual(await readImageHeader(blobOf(riff(chunkHeader("VP8 ", 100))), "webp"), none, "too short");
|
||
assert.deepEqual(await readImageHeader(blobOf(latin1("RIFF\0\0\0\0WAVEfmt ".padEnd(40, "\0"))), "webp"), none, "not WebP");
|
||
});
|
||
|
||
test("image header: other kinds give no format and the read stays within 64 KiB", async () => {
|
||
assert.deepEqual(await readImageHeader(blobOf(bytes.SIGNATURE), "png"), { format: null, width: null, height: null });
|
||
const file = recordingBlob(concat([0xff, 0xd8], fill(0, 200000)));
|
||
await readImageHeader(file, "jpeg");
|
||
assert.deepEqual(file.ranges, [[0, 65536]]);
|
||
const small = recordingBlob(concat([0xff, 0xd8, 0xff]));
|
||
await readImageHeader(small, "jpeg");
|
||
assert.deepEqual(small.ranges, [[0, 3]]);
|
||
});
|