@xprite/pixelate 0.0.0-stage → 0.1.0

package/dist/color-step.js

@@ -0,0 +1,62 @@
+import { UINT8_MAX } from "./base.js";
+const CHANNELS = 4;
+/** `m / 255` for every whole channel difference m, as doubles and as float32. */
+export const OPAQUE_STEPS = Float64Array.from({ length: UINT8_MAX + 1 }, (_, m) => m / UINT8_MAX);
+export const OPAQUE_STEPS_32 = Float32Array.from(OPAQUE_STEPS);
+/** Step code of a pair that is not opaque on both sides: its step is computed in full. */
+export const TRANSLUCENT = UINT8_MAX + 1;
+/**
+ * The colour step (0..1) between two RGBA pixels: the largest premultiplied channel or alpha
+ * difference.
+ */
+export function colorStep(data, first, second) {
+    const a = data[first + 3] / UINT8_MAX, b = data[second + 3] / UINT8_MAX;
+    let difference = Math.abs(a - b);
+    for (let c = 0; c < CHANNELS - 1; c++)
+        difference = Math.max(difference, Math.abs(data[first + c] * a - data[second + c] * b) / UINT8_MAX);
+    return difference;
+}
+let last = null;
+export function neighbourSteps(image) {
+    if (last?.image === image)
+        return last;
+    const { width, height, data } = image;
+    const right = new Uint16Array(width * height), down = new Uint16Array(width * height);
+    const code = (first, second) => data[first + 3] === UINT8_MAX && data[second + 3] === UINT8_MAX
+        ? Math.max(Math.abs(data[first] - data[second]), Math.abs(data[first + 1] - data[second + 1]), Math.abs(data[first + 2] - data[second + 2]))
+        : TRANSLUCENT;
+    const below = width * CHANNELS;
+    for (let y = 0; y < height; y++) {
+        const row = y * width;
+        for (let p = row; p < row + width - 1; p++)
+            right[p] = code(p * CHANNELS, p * CHANNELS + CHANNELS);
+        if (y + 1 < height)
+            for (let p = row; p < row + width; p++)
+                down[p] = code(p * CHANNELS, p * CHANNELS + below);
+    }
+    last = { image, right, down };
+    return last;
+}
+/** Drop the kept codes once the image's edge analysis is done. */
+export function releaseNeighbourSteps(image) {
+    if (last?.image === image)
+        last = null;
+}
+/** Drop the kept codes, whichever image they belong to. */
+export function forgetNeighbourSteps() {
+    last = null;
+}
+/** The step (a double, as {@link colorStep}) of the pair from pixel p to p + offset. */
+export function stepOf(codes, data, p, offset) {
+    const code = codes[p];
+    return code < TRANSLUCENT
+        ? OPAQUE_STEPS[code]
+        : colorStep(data, p * CHANNELS, (p + offset) * CHANNELS);
+}
+/** The same step rounded to float32. */
+export function step32Of(codes, data, p, offset) {
+    const code = codes[p];
+    return code < TRANSLUCENT
+        ? OPAQUE_STEPS_32[code]
+        : Math.fround(colorStep(data, p * CHANNELS, (p + offset) * CHANNELS));
+}

package/dist/contours.d.ts

@@ -0,0 +1,4 @@
+import type { PixelBuffer } from "./base.ts";
+/** Independent thin-ridge filter: opposite neighbors identify narrow light/dark features.
+ * Only RGB is blended into existing visible pixels; the alpha footprint never grows. */
+export declare function protectPixelationContours(image: PixelBuffer, strength: number): PixelBuffer;

package/dist/contours.js

@@ -0,0 +1,66 @@
+import { UINT8_MAX } from "./base.js";
+const CHANNELS = 4;
+const COLOR_CHANNELS = 3;
+const LUMA = [0.2126, 0.7152, 0.0722];
+const MIN_CONTRAST = 0.14;
+const BACKGROUND_TOLERANCE = 0.12;
+const MAX_BLEND = 0.65;
+const PERCENT = 100;
+/** Independent thin-ridge filter: opposite neighbors identify narrow light/dark features.
+ * Only RGB is blended into existing visible pixels; the alpha footprint never grows. */
+export function protectPixelationContours(image, strength) {
+    if (!strength)
+        return image;
+    const count = image.width * image.height;
+    const luminance = new Float32Array(count);
+    const features = new Float32Array(count);
+    const source = image.data;
+    for (let i = 0; i < count; i++) {
+        const offset = i * CHANNELS;
+        luminance[i] =
+            (source[offset] * LUMA[0] + source[offset + 1] * LUMA[1] + source[offset + 2] * LUMA[2]) /
+                UINT8_MAX;
+    }
+    const ridge = (center, first, second) => {
+        if (!source[first * CHANNELS + COLOR_CHANNELS] || !source[second * CHANNELS + COLOR_CHANNELS])
+            return 0;
+        const left = luminance[center] - luminance[first], right = luminance[center] - luminance[second];
+        if (left * right <= 0 || Math.abs(luminance[first] - luminance[second]) > BACKGROUND_TOLERANCE)
+            return 0;
+        return Math.min(Math.abs(left), Math.abs(right));
+    };
+    for (let y = 1; y < image.height - 1; y++)
+        for (let x = 1; x < image.width - 1; x++) {
+            const i = y * image.width + x;
+            if (!source[i * CHANNELS + COLOR_CHANNELS])
+                continue;
+            features[i] = Math.max(ridge(i, i - 1, i + 1), ridge(i, i - image.width, i + image.width));
+        }
+    const data = new Uint8ClampedArray(source);
+    for (let y = 0; y < image.height; y++)
+        for (let x = 0; x < image.width; x++) {
+            const i = y * image.width + x, offset = i * CHANNELS;
+            if (!source[offset + COLOR_CHANNELS] || features[i] >= MIN_CONTRAST)
+                continue;
+            let best = i, score = MIN_CONTRAST;
+            for (let dy = -1; dy <= 1; dy++)
+                for (let dx = -1; dx <= 1; dx++) {
+                    const nx = x + dx, ny = y + dy;
+                    if ((!dx && !dy) || nx < 0 || ny < 0 || nx >= image.width || ny >= image.height)
+                        continue;
+                    const neighbor = ny * image.width + nx;
+                    const coverage = source[neighbor * CHANNELS + COLOR_CHANNELS] / UINT8_MAX;
+                    const candidate = (features[neighbor] * coverage) / Math.max(1, Math.abs(dx) + Math.abs(dy));
+                    if (candidate > score) {
+                        score = candidate;
+                        best = neighbor;
+                    }
+                }
+            if (best === i)
+                continue;
+            const amount = (strength / PERCENT) * MAX_BLEND;
+            for (let c = 0; c < COLOR_CHANNELS; c++)
+                data[offset + c] = Math.round(source[offset + c] * (1 - amount) + source[best * CHANNELS + c] * amount);
+        }
+    return { width: image.width, height: image.height, data };
+}

package/dist/denoise.d.ts

@@ -0,0 +1,3 @@
+import type { PixelBuffer } from "./base.ts";
+/** Light edge-preserving smoothing on the working grid; opacity and contrasting details stay intact. */
+export declare function smoothPixelation(image: PixelBuffer): PixelBuffer;

package/dist/denoise.js

@@ -0,0 +1,37 @@
+const CHANNELS = 4;
+const COLOR_CHANNELS = 3;
+const SIMILARITY_LIMIT = 36;
+const CENTER_WEIGHT = 2;
+/** Light edge-preserving smoothing on the working grid; opacity and contrasting details stay intact. */
+export function smoothPixelation(image) {
+    const data = new Uint8ClampedArray(image.data);
+    for (let y = 0; y < image.height; y++)
+        for (let x = 0; x < image.width; x++) {
+            const offset = (y * image.width + x) * CHANNELS;
+            if (!image.data[offset + COLOR_CHANNELS])
+                continue;
+            const sums = [0, 0, 0];
+            let total = CENTER_WEIGHT;
+            for (let channel = 0; channel < COLOR_CHANNELS; channel++)
+                sums[channel] = image.data[offset + channel] * CENTER_WEIGHT;
+            for (let dy = -1; dy <= 1; dy++)
+                for (let dx = -1; dx <= 1; dx++) {
+                    const nx = x + dx, ny = y + dy;
+                    if ((!dx && !dy) || nx < 0 || ny < 0 || nx >= image.width || ny >= image.height)
+                        continue;
+                    const neighbor = (ny * image.width + nx) * CHANNELS;
+                    let distance = 0;
+                    for (let channel = 0; channel < CHANNELS; channel++)
+                        distance = Math.max(distance, Math.abs(image.data[offset + channel] - image.data[neighbor + channel]));
+                    if (distance >= SIMILARITY_LIMIT)
+                        continue;
+                    const weight = 1 - distance / SIMILARITY_LIMIT;
+                    total += weight;
+                    for (let channel = 0; channel < COLOR_CHANNELS; channel++)
+                        sums[channel] += image.data[neighbor + channel] * weight;
+                }
+            for (let channel = 0; channel < COLOR_CHANNELS; channel++)
+                data[offset + channel] = Math.round(sums[channel] / total);
+        }
+    return { ...image, data };
+}

package/dist/deskew.d.ts

@@ -0,0 +1,24 @@
+import type { PixelBuffer } from "./base.ts";
+/** Largest tilt searched (degrees, either direction). Beyond it the image is refused. */
+export declare const MAX_TILT_DEGREES = 10;
+/** Tilts below this are noise or a perfectly aligned image: the image is left untouched. */
+export declare const MIN_TILT_DEGREES = 0.15;
+export interface TiltEstimate {
+    /** Degrees to rotate the content by to straighten it; 0 when it needs none. */
+    angle: number;
+    /** Sharpness at the best angle divided by sharpness unrotated (1 = no evidence of tilt). */
+    gain: number;
+    /** The grid looks tilted by more than the search range: refuse instead of guessing. */
+    extreme: boolean;
+}
+/**
+ * Estimate how far the pixel grid in `image` is tilted. Returns an upright estimate when there is
+ * no convincing evidence, so images without a grid (photos) and aligned images are never touched.
+ */
+export declare function estimateTilt(image: PixelBuffer): TiltEstimate;
+/**
+ * Rotate `image` about its centre by `degrees` so a grid tilted by that angle becomes axis
+ * aligned. Same canvas size; samples outside the source repeat the nearest border pixel, and
+ * colour is interpolated with premultiplied alpha.
+ */
+export declare function straighten(image: PixelBuffer, degrees: number): PixelBuffer;

package/dist/deskew.js

@@ -0,0 +1,202 @@
+import { neighbourSteps, stepOf } from "./color-step.js";
+/**
+ * Tilt estimation and straightening for pixel grids that were photographed, scanned or rotated a
+ * little before they reached the importer. The tilt is the angle that makes the projection
+ * profiles of the vertical and horizontal edges sharpest: for the right angle every grid line
+ * collapses into one histogram bin, for any other angle the lines smear across many bins.
+ */
+const CHANNELS = 4;
+/** Largest tilt searched (degrees, either direction). Beyond it the image is refused. */
+export const MAX_TILT_DEGREES = 10;
+/** Tilts below this are noise or a perfectly aligned image: the image is left untouched. */
+export const MIN_TILT_DEGREES = 0.15;
+/** The tilted profile must be at least this much sharper than the unrotated one. */
+const MIN_SHARPNESS_GAIN = 1.25;
+/** Colour step (0..1) that counts as an edge; keeps JPEG noise and soft gradients out. */
+const EDGE_STEP = 0.1;
+const MAX_POINTS = 90_000;
+const COARSE_SIZE = 512;
+const COARSE_STEP = 0.1;
+const FINE_SPAN = 0.15;
+const DEGREES = Math.PI / 180;
+const MIN_EDGE_POINTS = 64;
+/** A best angle this close to the search limit means the real tilt is probably outside it. */
+const LIMIT_MARGIN = 0.35;
+const UPRIGHT = { angle: 0, gain: 1, extreme: false };
+const VERTICAL_EDGE = 1;
+const HORIZONTAL_EDGE = 2;
+/**
+ * Every `stride`-th of the `count` pixels flagged with `bit` (stride chosen to keep at most `limit`),
+ * in row order, as x, y pairs offset by (dx, dy).
+ */
+function thin(flags, width, bit, count, limit, dx, dy) {
+    const stride = Math.max(1, Math.ceil(count / limit));
+    const kept = new Float32Array(2 * Math.ceil(count / stride));
+    for (let p = 0, seen = 0, n = 0; n < kept.length; p++) {
+        if (!(flags[p] & bit))
+            continue;
+        if (seen++ % stride)
+            continue;
+        kept[n++] = (p % width) + dx;
+        kept[n++] = Math.floor(p / width) + dy;
+    }
+    return kept;
+}
+function collectEdges(image) {
+    const { width, height, data } = image;
+    const { right, down } = neighbourSteps(image);
+    const flags = new Uint8Array(width * height);
+    let vertical = 0, horizontal = 0;
+    for (let y = 0, p = 0; y < height; y++)
+        for (let x = 0; x < width; x++, p++) {
+            if (x + 1 < width && stepOf(right, data, p, 1) > EDGE_STEP) {
+                flags[p] |= VERTICAL_EDGE;
+                vertical++;
+            }
+            if (y + 1 < height && stepOf(down, data, p, width) > EDGE_STEP) {
+                flags[p] |= HORIZONTAL_EDGE;
+                horizontal++;
+            }
+        }
+    return {
+        vertical: thin(flags, width, VERTICAL_EDGE, vertical, MAX_POINTS, 1, 0.5),
+        horizontal: thin(flags, width, HORIZONTAL_EDGE, horizontal, MAX_POINTS, 0.5, 1),
+    };
+}
+/**
+ * Sum of squared histogram counts of the edge positions projected on the rotated axes. A larger
+ * value means the edges line up into fewer, taller bars.
+ */
+function sharpness(points, degrees, scale, bins, offset) {
+    const cos = Math.cos(degrees * DEGREES) * scale, sin = Math.sin(degrees * DEGREES) * scale;
+    const { vertical, horizontal } = points;
+    // Vertical edges project on u = x cos + y sin, horizontal edges on v = -x sin + y cos.
+    bins.fill(0);
+    for (let i = 0; i < vertical.length; i += 2)
+        bins[Math.floor(vertical[i] * cos + vertical[i + 1] * sin + offset)]++;
+    let total = squaredCounts(bins);
+    bins.fill(0);
+    for (let i = 0; i < horizontal.length; i += 2)
+        bins[Math.floor(-horizontal[i] * sin + horizontal[i + 1] * cos + offset)]++;
+    total += squaredCounts(bins);
+    return total / Math.max(1, (vertical.length + horizontal.length) / 2);
+}
+function squaredCounts(bins) {
+    let sum = 0;
+    for (let i = 0; i < bins.length; i++)
+        sum += bins[i] * bins[i];
+    return sum;
+}
+function scaled(points, scale) {
+    if (scale === 1)
+        return points;
+    return {
+        vertical: points.vertical.map((value) => value * scale),
+        horizontal: points.horizontal.map((value) => value * scale),
+    };
+}
+const cache = new WeakMap();
+/**
+ * Estimate how far the pixel grid in `image` is tilted. Returns an upright estimate when there is
+ * no convincing evidence, so images without a grid (photos) and aligned images are never touched.
+ */
+export function estimateTilt(image) {
+    const known = cache.get(image);
+    if (known)
+        return known;
+    const result = measureTilt(image);
+    cache.set(image, result);
+    return result;
+}
+function measureTilt(image) {
+    const longest = Math.max(image.width, image.height);
+    if (longest < 16)
+        return UPRIGHT;
+    const edges = collectEdges(image);
+    if (edges.vertical.length / 2 + edges.horizontal.length / 2 < MIN_EDGE_POINTS)
+        return UPRIGHT;
+    const bins = new Int32Array(Math.ceil(3 * longest) + 8);
+    const offset = longest;
+    const evaluate = (points, degrees, scale) => sharpness(points, degrees, scale, bins, offset * scale);
+    // Coarse pass on a shrunken copy of the coordinates so the narrow peak is not stepped over.
+    const coarseScale = Math.min(1, COARSE_SIZE / longest);
+    const coarsePoints = scaled(edges, coarseScale);
+    let best = 0, bestScore = -Infinity;
+    const scores = new Map();
+    for (let step = -MAX_TILT_DEGREES / COARSE_STEP; step <= MAX_TILT_DEGREES / COARSE_STEP; step++) {
+        const degrees = Math.round(step * COARSE_STEP * 1000) / 1000;
+        const score = evaluate(coarsePoints, degrees, coarseScale);
+        scores.set(degrees, score);
+        if (score > bestScore) {
+            bestScore = score;
+            best = degrees;
+        }
+    }
+    // Fine pass at full resolution: one pixel of drift across the image per step.
+    const fineStep = Math.max(0.005, Math.min(0.05, 1 / longest / DEGREES / 2));
+    let fine = best, fineScore = -Infinity;
+    for (let degrees = best - FINE_SPAN; degrees <= best + FINE_SPAN + 1e-9; degrees += fineStep) {
+        const score = evaluate(edges, degrees, 1);
+        if (score > fineScore) {
+            fineScore = score;
+            fine = degrees;
+        }
+    }
+    const upright = evaluate(edges, 0, 1);
+    const gain = upright > 0 ? fineScore / upright : 1;
+    const angle = Math.round(fine * 1000) / 1000;
+    if (Math.abs(angle) < MIN_TILT_DEGREES || gain < MIN_SHARPNESS_GAIN)
+        return { angle: 0, gain, extreme: false };
+    if (Math.abs(angle) > MAX_TILT_DEGREES - LIMIT_MARGIN)
+        return { angle: 0, gain, extreme: true };
+    return { angle, gain, extreme: false };
+}
+/**
+ * Rotate `image` about its centre by `degrees` so a grid tilted by that angle becomes axis
+ * aligned. Same canvas size; samples outside the source repeat the nearest border pixel, and
+ * colour is interpolated with premultiplied alpha.
+ */
+export function straighten(image, degrees) {
+    if (!degrees)
+        return image;
+    const { width, height, data } = image;
+    const out = new Uint8ClampedArray(data.length);
+    const cos = Math.cos(degrees * DEGREES), sin = Math.sin(degrees * DEGREES);
+    const cx = width / 2, cy = height / 2;
+    const pick = (x, y) => (Math.max(0, Math.min(height - 1, y)) * width + Math.max(0, Math.min(width - 1, x))) * CHANNELS;
+    const corners = new Int32Array(4);
+    const weights = new Float64Array(4);
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++) {
+            const u = x + 0.5 - cx, v = y + 0.5 - cy;
+            const sx = u * cos - v * sin + cx - 0.5, sy = u * sin + v * cos + cy - 0.5;
+            const x0 = Math.floor(sx), y0 = Math.floor(sy);
+            const fx = sx - x0, fy = sy - y0;
+            // The four corners in order, accumulated from zero.
+            corners[0] = pick(x0, y0);
+            corners[1] = pick(x0 + 1, y0);
+            corners[2] = pick(x0, y0 + 1);
+            corners[3] = pick(x0 + 1, y0 + 1);
+            weights[0] = (1 - fx) * (1 - fy);
+            weights[1] = fx * (1 - fy);
+            weights[2] = (1 - fx) * fy;
+            weights[3] = fx * fy;
+            let alpha = 0, r = 0, g = 0, b = 0;
+            for (let corner = 0; corner < 4; corner++) {
+                const at = corners[corner];
+                const a = data[at + 3] * weights[corner];
+                alpha += a;
+                r += data[at] * a;
+                g += data[at + 1] * a;
+                b += data[at + 2] * a;
+            }
+            const o = (y * width + x) * CHANNELS;
+            if (alpha > 0) {
+                out[o] = r / alpha;
+                out[o + 1] = g / alpha;
+                out[o + 2] = b / alpha;
+                out[o + 3] = alpha;
+            }
+        }
+    return { width, height, data: out };
+}

package/dist/grid-ac-rl-consensus.d.ts

@@ -0,0 +1,127 @@
+/**
+ * AC+RL consensus detector via Fixer Rust WASM.
+ *
+ * Returns grid dimensions when autocorrelation and run-lengths agree
+ * on pixel grid size (consensus="fast:ac+rl(S)").
+ *
+ * Overlap modes:
+ * - Node (pixelbench / Vite SSR): worker_threads — beginAcRlConsensusJob + sync
+ *   finishAcRlConsensusJob via receiveMessageOnPort (existing Exact harness path).
+ * - Browser product (import-worker): nested Worker + Promise join via
+ *   beginAcRlConsensusJobAsync / finishAcRlConsensusJobAsync — no COOP/COEP /
+ *   SharedArrayBuffer required (sync Atomics.wait join is what needed isolation).
+ * - Fallback: on-thread detectAcRlConsensus (sync job).
+ *
+ * Set XPRITE_AC_RL_WORKER=0 to force sync detect on Node. Product registers a
+ * browser worker factory with setAcRlBrowserWorkerFactory from import-worker.
+ */
+/**
+ * Minimal messaging / Node shapes used by this file only.
+ * editor-core tsconfig keeps lib=["ES2020"] and types=[] (no DOM / @types/node),
+ * so we must not rely on ambient MessagePort/Worker/process names.
+ */
+type AcRlTransferable = ArrayBufferLike | AcRlMessagePort;
+type AcRlMessagePort = {
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    postMessage(message: unknown, transfer?: AcRlTransferable[]): void;
+    start?: () => void;
+    close?: () => void;
+    on?: (event: "message", cb: (msg: unknown) => void) => void;
+    off?: (event: "message", cb: (msg: unknown) => void) => void;
+};
+type Consensus = {
+    cols: number;
+    rows: number;
+};
+export type AcRlConsensusJob = {
+    mode: "worker";
+    port1: {
+        onmessage: ((ev: {
+            data: unknown;
+        }) => void) | null;
+        postMessage(message: unknown, transfer?: AcRlTransferable[]): void;
+        start?: () => void;
+        close?: () => void;
+        on?: (event: "message", cb: (msg: unknown) => void) => void;
+        off?: (event: "message", cb: (msg: unknown) => void) => void;
+    };
+} | {
+    mode: "sync";
+    imageData: {
+        data: Uint8ClampedArray | Uint8Array;
+        width: number;
+        height: number;
+    };
+};
+export type AcRlConsensusAsyncJob = {
+    mode: "async";
+    promise: Promise<Consensus | null>;
+} | {
+    mode: "sync";
+    imageData: {
+        data: Uint8ClampedArray | Uint8Array;
+        width: number;
+        height: number;
+    };
+};
+/**
+ * Product import-worker: register nested Worker factory (Vite `new URL(..., import.meta.url)`).
+ * Param is `() => unknown` so DOM `Worker` from apps/editor assigns without sharing DOM libs.
+ */
+export declare function setAcRlBrowserWorkerFactory(factory: (() => unknown) | null): void;
+/**
+ * Preload WASM module asynchronously (call during app/worker initialization).
+ * After this completes, detectAcRlConsensus will work synchronously without load overhead.
+ *
+ * Best practice: Call this during app startup or worker ready event, NOT on first recover call.
+ * Reduces first-image latency by ~5-10ms and eliminates async overhead from hot path.
+ *
+ * Also warms the Node AC+RL detect worker when worker_threads overlap is available,
+ * and the browser nested Worker when a factory was registered.
+ *
+ * @example
+ * // In worker initialization:
+ * await preloadWasm();
+ *
+ * // Or in app init:
+ * preloadWasm().catch(console.error);
+ */
+export declare function preloadWasm(): Promise<void>;
+/**
+ * Start AC+RL detect on a Node worker_threads worker (copy + postMessage).
+ * Run proposers on the calling thread, then finishAcRlConsensusJob.
+ * Falls back to deferred sync detect when workers are unavailable (browser / disable flag).
+ */
+export declare function beginAcRlConsensusJob(imageData: {
+    data: Uint8ClampedArray | Uint8Array;
+    width: number;
+    height: number;
+}): AcRlConsensusJob;
+/**
+ * Join a job started by beginAcRlConsensusJob. Same consensus semantics as detectAcRlConsensus.
+ */
+export declare function finishAcRlConsensusJob(job: AcRlConsensusJob): Consensus | null;
+/**
+ * Start AC+RL detect for async Auto: Node worker_threads or browser nested Worker.
+ * Promise is attached before proposers run; finishAcRlConsensusJobAsync awaits it
+ * (no SAB / COOP/COEP). Falls back to deferred sync detect when no worker is available.
+ * Async so browser nested Worker can be warmed on first use.
+ */
+export declare function beginAcRlConsensusJobAsync(imageData: {
+    data: Uint8ClampedArray | Uint8Array;
+    width: number;
+    height: number;
+}): Promise<AcRlConsensusAsyncJob>;
+/**
+ * Await a job from beginAcRlConsensusJobAsync. Same consensus semantics as detectAcRlConsensus.
+ */
+export declare function finishAcRlConsensusJobAsync(job: AcRlConsensusAsyncJob): Promise<Consensus | null>;
+/** Kick off browser nested Worker warm-up after setAcRlBrowserWorkerFactory (non-blocking OK). */
+export declare function warmAcRlBrowserWorker(): Promise<boolean>;
+/** Test/harness: whether Node worker overlap is active after preload. */
+export declare function acRlWorkerOverlapActive(): boolean;
+/** Test/harness: whether browser nested-Worker async overlap is ready. */
+export declare function acRlBrowserWorkerOverlapActive(): boolean;
+export {};