humanish 0.146.0 → 0.147.0

package/CHANGELOG.md

@@ -8,6 +8,16 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.147.0: Screenshots take half the space (2026-10-25)
+
+humanish 0.147.0 keeps a computer-use participant's screenshots as lossless WebP, 0.47 to 0.55 of
+the PNG size with the same pixels, and `verify`, study analysis and export read them; earlier
+humanish versions refuse a bundle with WebP screenshots. `actor.serviceTier: fast` runs OpenAI
+computer-use participants in Fast mode. On the Taskly benchmark a Fast mode step took 14% less
+time at 2.15 times the participant cost, and each request is priced at the tier that served it.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.147.0)
+
 ## 0.146.0: Studies start and finish sooner (2026-10-23)
 
 humanish 0.146.0 cuts the wait around a hosted study. A Chrome participant starts once its page

package/dist/actors/computer-use/loop/spend.js

@@ -58,11 +58,12 @@ export function bookLostRequest(session, turnNumber, lost) {
     }
     const input = session.usage.lastReportedInput();
     session.usage.reserve(input, maxOutputTokens);
+    const serviceTier = session.provider.modelSettings?.serviceTier;
+    const booked = { input, output: maxOutputTokens, cachedInput: 0, cacheWriteInput: input };
     const usd = session.settings.estimateTurnCostUsd?.({
-        input,
-        output: maxOutputTokens,
-        cachedInput: 0,
-        cacheWriteInput: input,
+        ...booked,
+        // A request in Fast mode is booked at the fast rate, which a per-request record selects.
+        ...(serviceTier === undefined ? {} : { turns: [{ ...booked, serviceTier }] }),
     });
     const charge = `${input} input tokens at the highest input rate and ${maxOutputTokens} output tokens${typeof usd === "number" ? ` ($${usd})` : ""}`;
     const over = spendStop(session);

package/dist/actors/computer-use/loop/trace.js

@@ -127,6 +127,9 @@ export function loopResult(session, stop, debrief) {
                     ...(provider.modelSettings.maxOutputTokens === undefined
                         ? {}
                         : { maxOutputTokens: provider.modelSettings.maxOutputTokens }),
+                    ...(provider.modelSettings.serviceTier === undefined
+                        ? {}
+                        : { serviceTier: provider.modelSettings.serviceTier }),
                 },
             }),
         waitSettings: {

package/dist/actors/computer-use/loop/types.d.ts

@@ -191,12 +191,15 @@ export interface CuaTurn {
         output?: number;
         cachedInput?: number;
         cacheWriteInput?: number;
+        /** The processing tier that served this request, when the session asked for one. */
+        serviceTier?: string;
         /** Per model inference inside this provider interaction. */
         turns?: Array<{
             input?: number;
             output?: number;
             cachedInput?: number;
             cacheWriteInput?: number;
+            serviceTier?: string;
         }>;
     };
     /** True when the model reported a natural endpoint (no further action). */
@@ -234,6 +237,8 @@ export interface CuaProvider {
     readonly modelSettings?: {
         readonly reasoningEffort: ReasoningEffort;
         readonly maxOutputTokens?: number;
+        /** The processing tier every request asks for; absent asks for none. */
+        readonly serviceTier?: "fast";
     };
     readonly capabilities: ActorCapabilities;
     /**

package/dist/actors/computer-use/loop/usage.js

@@ -14,12 +14,19 @@ function normalizedUsageTurns(usage) {
             return undefined;
         if ((raw.cachedInput ?? 0) + (raw.cacheWriteInput ?? 0) > (raw.input ?? 0))
             return undefined;
-        turns.push(Object.fromEntries(fields.flatMap((field) => (raw[field] === undefined ? [] : [[field, raw[field]]]))));
+        turns.push({
+            ...Object.fromEntries(fields.flatMap((field) => (raw[field] === undefined ? [] : [[field, raw[field]]]))),
+            ...servedTier(raw.serviceTier),
+        });
     }
     return fields.every((field) => turns.reduce((sum, turn) => sum + (turn[field] ?? 0), 0) === (usage[field] ?? 0))
         ? turns
         : undefined;
 }
+/** The served-tier field of a usage record, kept only when the provider named one. */
+function servedTier(tier) {
+    return typeof tier === "string" && tier !== "" ? { serviceTier: tier } : {};
+}
 export function isCompleteTurnUsage(usage) {
     return (usage !== undefined &&
         validTokenCount(usage.input) &&
@@ -130,7 +137,7 @@ export class UsageLedger {
         this.cacheWriteInput += usage.cacheWriteInput ?? 0;
         this.output += usage.output ?? 0;
         if (raw.turns === undefined)
-            this.turns.push(usage);
+            this.turns.push({ ...usage, ...servedTier(raw.serviceTier) });
         else if (turns !== undefined)
             this.turns.push(...turns);
     }
@@ -218,6 +225,7 @@ export class UsageLedger {
             output,
             cachedInput: 0,
             cacheWriteInput: input,
+            ...servedTier(this.provider.modelSettings?.serviceTier),
         }));
         const sum = (field) => booked.reduce((total, turn) => total + turn[field], 0);
         const input = (settled.input ?? 0) + sum("input");

package/dist/actors/computer-use/openai-conversation.d.ts

@@ -8,6 +8,8 @@ export interface OpenAiConversationSettings {
     readonly reasoningEffort: ReasoningEffort;
     readonly maxOutputTokens?: number;
     readonly safetyIdentifier?: string;
+    /** OpenAI Fast mode for every request of the session. */
+    readonly serviceTier?: "fast";
     /** The summaries to ask for until the account or model rejects them; undefined asks for none. */
     readonly reasoningSummary: OpenAiReasoningSummary | undefined;
     /** Carry the conversation on the client from the first request (explicit_context). */
@@ -98,6 +100,11 @@ export declare class OpenAiConversation {
      */
     private waitOutcome;
     private context;
+    /**
+     * A reply, parsed. When the session asked for a tier, the reply's usage records the tier that
+     * served it, which is what the request bills at: Fast mode can fall back to `default`.
+     */
+    private parse;
     /**
      * A participant request: the opening request, or a continuation carrying `sent`. A threaded
      * continuation names the previous response; an explicit-context one carries the conversation

package/dist/actors/computer-use/openai-conversation.js

@@ -75,7 +75,7 @@ export class OpenAiConversation {
         if (closing === "impressions")
             this.evidence.requested(this.mode, this.carried, sent, closing);
         const completed = asRecord(reply).status === "completed";
-        const parsed = parseOpenAiResponse(reply);
+        const parsed = this.parse(reply);
         const account = completed ? closingAccount(parsed.turn.message, closing, strict) : undefined;
         // A refusal would most likely stand under the strict schema too, so it is not asked again.
         if (completed && account === undefined && !strict && !refused(reply)) {
@@ -164,6 +164,23 @@ export class OpenAiConversation {
             ...(settings.safetyIdentifier === undefined
                 ? {}
                 : { safetyIdentifier: settings.safetyIdentifier }),
+            ...(settings.serviceTier === undefined ? {} : { serviceTier: settings.serviceTier }),
+        };
+    }
+    /**
+     * A reply, parsed. When the session asked for a tier, the reply's usage records the tier that
+     * served it, which is what the request bills at: Fast mode can fall back to `default`.
+     */
+    parse(reply) {
+        const parsed = parseOpenAiResponse(reply);
+        const { usage } = parsed.turn;
+        if (this.settings.serviceTier === undefined || usage === undefined)
+            return parsed;
+        if (parsed.serviceTier === undefined)
+            return parsed;
+        return {
+            ...parsed,
+            turn: { ...parsed.turn, usage: { ...usage, serviceTier: parsed.serviceTier } },
         };
     }
     /**
@@ -204,7 +221,7 @@ export class OpenAiConversation {
         // Recorded before the reply is accepted: accepting can cut the carried history, and the record
         // counts what this request carried.
         this.evidence.requested(this.mode, this.carried, sent);
-        const parsed = parseOpenAiResponse(reply);
+        const parsed = this.parse(reply);
         if (parsed.turn.interruption === "output_limit")
             return parsed.turn;
         this.moveOn(parsed, sent);

package/dist/actors/computer-use/openai-provider.d.ts

@@ -68,6 +68,8 @@ export interface OpenAiResponsesProviderOptions {
     reasoningEffort?: ReasoningEffort;
     /** Optional positive integer output limit per response, including reasoning. Not a spend cap. */
     maxOutputTokens?: number;
+    /** OpenAI Fast mode on every request; absent sends no `service_tier`. */
+    serviceTier?: "fast";
     /**
      * Reasoning-summary capture. Defaults to "auto" (the provider picks the best
      * summarizer the model supports); "off" never asks. If the account/model rejects the

package/dist/actors/computer-use/openai-provider.js

@@ -418,6 +418,7 @@ export function createOpenAiResponsesProvider(options) {
         ...(options.safetyIdentifier === undefined
             ? {}
             : { safetyIdentifier: options.safetyIdentifier }),
+        ...(options.serviceTier === undefined ? {} : { serviceTier: options.serviceTier }),
         reasoningSummary: options.reasoningSummary === "off" ? undefined : (options.reasoningSummary ?? "auto"),
         zeroDataRetention: options.zeroDataRetention === true,
         now: options.now ?? Date.now,
@@ -471,6 +472,7 @@ export function createOpenAiResponsesProvider(options) {
         modelSettings: {
             reasoningEffort,
             ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+            ...(options.serviceTier === undefined ? {} : { serviceTier: options.serviceTier }),
         },
         capabilities: OPENAI_RESPONSES_CU_CAPABILITIES,
         // This is a vision provider: nextTurn sends the screenshot as the computer_call_output, so

package/dist/actors/computer-use/openai-wire.d.ts

@@ -15,6 +15,8 @@ export interface ParsedOpenAiResponse {
     /** The function calls, in reply order, each owed a function_call_output. */
     functionCalls: FunctionCall[];
     outputItems: unknown[];
+    /** The processing tier the reply says served it (`service_tier`), when it says one. */
+    serviceTier?: string;
 }
 /** A function call a reply made: its id, and its name, which is WAIT_TOOL_NAME unless it erred. */
 export interface FunctionCall {
@@ -52,6 +54,8 @@ export interface OpenAiCuContext {
     /** When set, request provider-sanctioned reasoning summaries. Absent = do not ask. */
     reasoningSummary?: OpenAiReasoningSummary;
     safetyIdentifier?: string;
+    /** OpenAI Fast mode (`service_tier: "fast"`). Absent sends no tier: the project's default. */
+    serviceTier?: "fast";
 }
 /**
  * Build the first-turn request body: the instructions and the first screen, so the first decision

package/dist/actors/computer-use/openai-wire.js

@@ -271,7 +271,14 @@ export function parseOpenAiResponse(raw) {
         ...(message.length > 0 ? { message } : {}),
         ...(usage === undefined ? {} : { usage }),
     };
-    return { turn, callIds, functionCalls, outputItems: output };
+    const serviceTier = optionalString(root.service_tier);
+    return {
+        turn,
+        callIds,
+        functionCalls,
+        outputItems: output,
+        ...(serviceTier === undefined ? {} : { serviceTier }),
+    };
 }
 /**
  * A function the participant names its wait length with; the computer tool's `wait` names none.
@@ -324,6 +331,7 @@ function sharedRequestFields(ctx) {
             ...(ctx.reasoningSummary === undefined ? {} : { summary: ctx.reasoningSummary }),
         },
         ...(ctx.safetyIdentifier === undefined ? {} : { safety_identifier: ctx.safetyIdentifier }),
+        ...(ctx.serviceTier === undefined ? {} : { service_tier: ctx.serviceTier }),
         ...(ctx.stateless === true ? { store: false, include: ["reasoning.encrypted_content"] } : {}),
     };
 }

package/dist/actors/contract.d.ts

@@ -187,6 +187,10 @@ export interface ActorTokenUsage {
         cachedInput?: number;
         cacheWriteInput?: number;
         output?: number;
+        /** The processing tier the provider reported serving this request at (OpenAI `service_tier`:
+         *  `default`, `priority`, `fast`). Recorded when the participant asked for a tier; Fast mode
+         *  can fall back to `default`, which bills the standard rate. */
+        serviceTier?: string;
     }>;
     total?: number;
     costUsd?: number;
@@ -364,6 +368,7 @@ export interface ActorTrace {
     modelSettings?: {
         reasoningEffort: string;
         maxOutputTokens?: number;
+        serviceTier?: string;
     };
     /**
      * Additive + optional: the wait lengths the computer-use loop applied, defaults included. Absent

package/dist/analysis/evidence.js

@@ -348,13 +348,13 @@ function packEvidence(selected, packings, textByEntry, evidence, images) {
                     eventId: source.eventId,
                     path: source.capturePath,
                     sha256: sha256(bytes),
-                    mimeType: "image/png",
+                    mimeType: captureMimeType(source.capturePath),
                 }
                 : null;
-            if (bytes)
+            if (capture)
                 images.push({
                     evidenceId: id,
-                    dataUrl: `data:image/png;base64,${bytes.toString("base64")}`,
+                    dataUrl: `data:${capture.mimeType};base64,${bytes.toString("base64")}`,
                 });
             evidence.push({
                 id,
@@ -448,7 +448,7 @@ export async function validateAnalysisEvidence(prepared, artifact, bundleBytes)
             if (source.capturePath === null ||
                 entry.capture.path !== source.capturePath ||
                 entry.capture.eventId !== source.eventId ||
-                entry.capture.mimeType !== "image/png")
+                entry.capture.mimeType !== captureMimeType(source.capturePath))
                 throw new Error("ANALYSIS_CAPTURE_REFERENCE_INVALID");
             let hash = checkedCaptures.get(source.capturePath);
             if (hash === undefined) {
@@ -474,3 +474,7 @@ export async function validateAnalysisEvidence(prepared, artifact, bundleBytes)
     if (!current?.equals(bundleBytes))
         throw new Error("ANALYSIS_SOURCE_CHANGED");
 }
+/** A capture's image type, from the extension screenshotEvidenceError checked it against. */
+function captureMimeType(capturePath) {
+    return capturePath.toLowerCase().endsWith(".webp") ? "image/webp" : "image/png";
+}

package/dist/analysis/image-tokens.js

@@ -1,3 +1,4 @@
+import { WEBP_HEADER_BYTES, webpHeaderDimensions } from "../evidence/webp.js";
 /** An input image the analysis providers accept; the groups are the image type and its base64 bytes. */
 export const INPUT_IMAGE_DATA_URL = /^data:image\/(png|jpeg|webp);base64,([A-Za-z0-9+/]+={0,2})$/;
 /**
@@ -36,8 +37,13 @@ const GEMINI_HIGH_RESOLUTION_IMAGE_TOKENS = Object.freeze({
 /** The most one image can cost on `model`, whatever its size. */
 export const imageTokenCeiling = (model) => GEMINI_HIGH_RESOLUTION_IMAGE_TOKENS[model] ?? HIGH_DETAIL_IMAGE_TOKEN_CEILING;
 const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-/** Width and height from a PNG data URL's IHDR chunk; undefined for anything else. */
-function pngDimensions(dataUrl) {
+/** Base64 characters that hold WEBP_HEADER_BYTES, rounded up to whole 3-byte groups. */
+const WEBP_HEADER_CHARS = Math.ceil(WEBP_HEADER_BYTES / 3) * 4;
+/** Width and height from a PNG data URL's IHDR chunk or a lossless WebP's VP8L header. */
+function imageDimensions(dataUrl) {
+    const webp = new RegExp(`^data:image/webp;base64,([A-Za-z0-9+/]{${WEBP_HEADER_CHARS}})`).exec(dataUrl);
+    if (webp)
+        return webpHeaderDimensions(Buffer.from(webp[1], "base64"));
     const match = /^data:image\/png;base64,([A-Za-z0-9+/]{32})/.exec(dataUrl);
     if (!match)
         return undefined;
@@ -53,7 +59,7 @@ export function highDetailImageTokens(model, dataUrl) {
     if (fixed !== undefined)
         return fixed;
     const sizing = HIGH_DETAIL_SIZING[model];
-    const size = sizing === undefined ? undefined : pngDimensions(dataUrl);
+    const size = sizing === undefined ? undefined : imageDimensions(dataUrl);
     if (sizing === undefined || size === undefined)
         return HIGH_DETAIL_IMAGE_TOKEN_CEILING;
     const patches = Math.ceil(size.width / 32) * Math.ceil(size.height / 32);

package/dist/evidence/image.d.ts

@@ -22,3 +22,5 @@ export declare function pngDecodeRefusal(bytes: Buffer): string | null;
 export declare function isRedactedFrameShape(bytes: Buffer): boolean;
 export declare function screenshotEvidenceError(relativePath: string, bytes: Buffer): Promise<string | null>;
 export declare function assertScreenshotEvidence(relativePath: string, bytes: Buffer): Promise<void>;
+/** Why an image of these dimensions is refused before any decode, or null. */
+export declare function imageDimensionsError(format: string, width: number, height: number): string | null;

package/dist/evidence/image.js

@@ -1,5 +1,6 @@
 import { crc32, createInflate } from "node:zlib";
 import { PNG } from "pngjs";
+import { webpStructure } from "./webp.js";
 const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
 const PNG_IHDR_LENGTH = 13;
 // The pixel cap pngDecodeRefusal applies before any decode, for verify and the redactor alike.
@@ -130,8 +131,10 @@ export function isRedactedFrameShape(bytes) {
 }
 export async function screenshotEvidenceError(relativePath, bytes) {
     const extension = relativePath.toLowerCase().split(".").pop() ?? "";
+    if (extension === "webp")
+        return webpEvidenceError(bytes);
     if (extension !== "png") {
-        return `unsupported screenshot extension .${extension || "unknown"}; only decoded PNG evidence is supported`;
+        return `unsupported screenshot extension .${extension || "unknown"}; screenshot evidence is PNG or lossless WebP`;
     }
     const refusal = pngDecodeRefusal(bytes);
     if (refusal)
@@ -150,6 +153,20 @@ export async function screenshotEvidenceError(relativePath, bytes) {
         ? "could not decode PNG evidence"
         : null;
 }
+/**
+ * Why a WebP frame is not screenshot evidence, read from its structure (webpStructure) without
+ * decoding it. A WebP frame is always raw evidence, which verify never grades share-ready, so a
+ * decode would add 17 to 20 ms a frame on the main thread and establish nothing more about bytes
+ * no one reviews.
+ */
+function webpEvidenceError(bytes) {
+    if (bytes.length > SCREENSHOT_MAX_BYTES)
+        return `WebP byte size exceeds ${SCREENSHOT_MAX_BYTES} byte limit`;
+    const structure = webpStructure(bytes);
+    if (structure.error !== null)
+        return structure.error;
+    return imageDimensionsError("WebP", structure.dimensions.width, structure.dimensions.height);
+}
 /** The bit depths PNG allows for each color type. */
 const PNG_BIT_DEPTHS = {
     0: [1, 2, 4, 8, 16],
@@ -254,11 +271,15 @@ export async function assertScreenshotEvidence(relativePath, bytes) {
     }
 }
 function pngDimensionsError(width, height) {
+    return imageDimensionsError("PNG", width, height);
+}
+/** Why an image of these dimensions is refused before any decode, or null. */
+export function imageDimensionsError(format, width, height) {
     if (width === 0 || height === 0) {
-        return "PNG dimensions must be greater than zero";
+        return `${format} dimensions must be greater than zero`;
     }
     if (width * height > SCREENSHOT_MAX_SOURCE_PIXELS) {
-        return `PNG pixel count exceeds ${SCREENSHOT_MAX_SOURCE_PIXELS} pixel limit`;
+        return `${format} pixel count exceeds ${SCREENSHOT_MAX_SOURCE_PIXELS} pixel limit`;
     }
     return null;
 }

package/dist/evidence/webp-encode-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/evidence/webp-encode-worker.js

@@ -0,0 +1,31 @@
+// The worker thread src/evidence/webp-transcoder.ts runs: PNG frames in, lossless WebP out, one at
+// a time. It imports packages only, so Node can run this file from source with its types stripped
+// as well as from dist.
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { parentPort } from "node:worker_threads";
+import encode, { init } from "@jsquash/webp/encode.js";
+import { PNG } from "pngjs";
+/**
+ * Lossless, and `exact` keeps the color under fully transparent pixels, so decoded pixels equal the
+ * PNG's. Method 1 at quality 50 measured 0.47 of the PNG bytes at about 330 ms for a 1440x950
+ * frame; higher efforts saved 2% more at twice the time.
+ */
+const OPTIONS = { lossless: 1, exact: 1, method: 1, quality: 50 };
+const port = parentPort;
+if (port === null)
+    throw new Error("webp-encode-worker runs only as a worker thread.");
+const ready = readFile(createRequire(import.meta.url).resolve("@jsquash/webp/codec/enc/webp_enc_simd.wasm"))
+    .then((wasm) => WebAssembly.compile(wasm))
+    .then(async (module) => void (await init(module)));
+ready.then(() => port.postMessage({ ready: true }), (error) => port.postMessage({ ready: false, error: String(error) }));
+port.on("message", (job) => {
+    void ready
+        .then(async () => {
+        const image = PNG.sync.read(Buffer.from(job.png.buffer, job.png.byteOffset, job.png.length));
+        const data = new Uint8ClampedArray(image.data.buffer, image.data.byteOffset, image.data.length);
+        const webp = await encode({ data, width: image.width, height: image.height, colorSpace: "srgb" }, OPTIONS);
+        port.postMessage({ id: job.id, webp: new Uint8Array(webp) }, [webp]);
+    })
+        .catch((error) => port.postMessage({ id: job.id, error: String(error) }));
+});

package/dist/evidence/webp-transcoder.d.ts

@@ -0,0 +1,15 @@
+export interface WebpTranscoder {
+    /**
+     * The frame's WebP bytes, or undefined when the queue is full or the encoder failed. `abandon`
+     * drops a frame no one waits for any more, so it no longer keeps the process alive.
+     */
+    transcode(png: Buffer): {
+        webp: Promise<Buffer>;
+        abandon: () => void;
+    } | undefined;
+}
+/**
+ * The process's transcoder, started on first use. From source the worker runs as TypeScript, which
+ * Node loads with its types stripped.
+ */
+export declare function webpTranscoder(): WebpTranscoder;

package/dist/evidence/webp-transcoder.js

@@ -0,0 +1,98 @@
+// Turns computer-use frames into lossless WebP in a worker thread, off the turn's path: a frame is
+// written and referenced as PNG first, and only a finished WebP replaces it (see
+// src/routes/computer-use/participant-frames.ts). The process shares one worker, so encoding uses
+// at most one core however many participants run.
+import { Worker } from "node:worker_threads";
+/**
+ * The PNG bytes that may wait for the worker at once. A frame past it stays PNG, so a busy runner
+ * keeps today's format for that frame instead of holding more frames in memory.
+ */
+const QUEUE_BYTE_BUDGET = 64 * 1024 * 1024;
+class WorkerTranscoder {
+    worker;
+    /**
+     * Every frame posted to the worker until it answers. An abandoned frame still holds its bytes
+     * there, so it counts against the budget, but it no longer keeps the process alive.
+     */
+    posted = new Map();
+    queuedBytes = 0;
+    wanted = 0;
+    nextId = 0;
+    failed = false;
+    constructor(entry) {
+        this.worker = new Worker(entry);
+        this.worker.on("message", (message) => {
+            if ("ready" in message) {
+                if (!message.ready)
+                    this.fail(new Error(message.error));
+                return;
+            }
+            const job = this.posted.get(message.id);
+            if (job === undefined)
+                return;
+            this.posted.delete(message.id);
+            this.queuedBytes -= job.size;
+            if (job.abandoned)
+                return;
+            this.release();
+            if ("error" in message)
+                job.reject(new Error(message.error));
+            else
+                job.resolve(Buffer.from(message.webp.buffer, message.webp.byteOffset, message.webp.length));
+        });
+        this.worker.on("error", (error) => this.fail(error));
+        this.worker.on("exit", (code) => this.fail(new Error(`The WebP worker exited with code ${code}.`)));
+        // An idle worker never keeps the process alive; a waiting frame does. Adding a message listener
+        // refs the worker, so this comes after the listeners.
+        this.worker.unref();
+    }
+    transcode(png) {
+        if (this.failed || this.queuedBytes + png.length > QUEUE_BYTE_BUDGET)
+            return undefined;
+        const id = this.nextId++;
+        if (this.wanted++ === 0)
+            this.worker.ref();
+        this.queuedBytes += png.length;
+        const webp = new Promise((resolve, reject) => {
+            this.posted.set(id, { size: png.length, abandoned: false, resolve, reject });
+            this.worker.postMessage({ id, png: new Uint8Array(png) });
+        });
+        return {
+            webp,
+            abandon: () => {
+                const job = this.posted.get(id);
+                if (job === undefined || job.abandoned)
+                    return;
+                job.abandoned = true;
+                this.release();
+                job.reject(new Error("The frame's WebP was abandoned."));
+            },
+        };
+    }
+    /** One frame fewer that someone waits for; with none left the worker stops holding the process. */
+    release() {
+        if (--this.wanted === 0)
+            this.worker.unref();
+    }
+    fail(error) {
+        if (this.failed)
+            return;
+        this.failed = true;
+        for (const job of this.posted.values())
+            if (!job.abandoned)
+                job.reject(error);
+        this.posted.clear();
+        this.queuedBytes = 0;
+        this.wanted = 0;
+        void this.worker.terminate();
+    }
+}
+let shared;
+/**
+ * The process's transcoder, started on first use. From source the worker runs as TypeScript, which
+ * Node loads with its types stripped.
+ */
+export function webpTranscoder() {
+    shared ??= new WorkerTranscoder(new URL(import.meta.url.endsWith(".ts") ? "./webp-encode-worker.ts" : "./webp-encode-worker.js", import.meta.url));
+    return shared;
+}

package/dist/evidence/webp.d.ts

@@ -0,0 +1,31 @@
+export interface WebpDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * Why `bytes` is not a simple-format lossless WebP, or null with its dimensions when it is: RIFF
+ * and WEBP, then one VP8L chunk that ends the file (with its pad byte, zero, when its size is
+ * odd), whose header has the VP8L signature and version 0.
+ */
+export declare function webpStructure(bytes: Buffer): {
+    error: string;
+} | {
+    error: null;
+    dimensions: WebpDimensions;
+};
+/** The bytes webpHeaderDimensions reads: the RIFF header, the VP8L chunk header, the VP8L header. */
+export declare const WEBP_HEADER_BYTES: number;
+/**
+ * Width and height from the first WEBP_HEADER_BYTES of a simple-format lossless WebP: a VP8L
+ * signature and version 0. Undefined for anything else.
+ */
+export declare function webpHeaderDimensions(header: Buffer): WebpDimensions | undefined;
+/**
+ * The RGBA pixels of a WebP frame that webpStructure accepts, whose dimensions the caller has
+ * checked against its pixel cap; the decoder allocates from them.
+ */
+export declare function decodeWebp(bytes: Buffer): Promise<{
+    width: number;
+    height: number;
+    data: Buffer;
+}>;