@mohasinac/appkit 4.52.5 → 4.53.1

package/dist/_internal/shared/features/sticker-trace/trace/line-filter.js

@@ -0,0 +1,138 @@
+/*
+ * WHY: Four measured attempts at art-background sheets all failed the same
+ *      way, and the reason was the primitive rather than its constants. The
+ *      local-range detector in trace/ridge is an EDGE detector, and on an art
+ *      sheet the strongest edges are the artwork — torch-pegases' cut line
+ *      measured +22 against +-1 noise while that sheet's own lettering is far
+ *      higher contrast. No threshold on an edge detector separates the two.
+ * WHAT: A Hessian line filter, which asks a different question entirely.
+ *
+ * The distinction is geometric, not photometric:
+ *
+ *   a LINE (a kiss cut — a groove a few pixels wide) has a large second
+ *   derivative ACROSS it, maximal exactly at its centre;
+ *
+ *   a STEP (an artwork boundary between two printed colours) has a second
+ *   derivative with a ZERO CROSSING at the edge — large on the flanks either
+ *   side, ~0 on the edge itself.
+ *
+ * So evaluating curvature at the feature centre keeps cuts and suppresses
+ * artwork boundaries, which is exactly inverted from what amplitude does.
+ * That is why this is a different detector and not a retuned one.
+ *
+ * EXPORTS: LineFilterResult, detectLines
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:segment
+ * @tag sideEffects:none
+ */
+/** Separable Gaussian. Scale sets which line WIDTH the filter is tuned to. */
+function gaussian(src, width, height, sigma) {
+    const radius = Math.max(1, Math.ceil(sigma * 3));
+    const k = new Float32Array(radius * 2 + 1);
+    const denom = 2 * sigma * sigma;
+    let sum = 0;
+    for (let i = -radius; i <= radius; i++) {
+        const v = Math.exp(-(i * i) / denom);
+        k[i + radius] = v;
+        sum += v;
+    }
+    for (let i = 0; i < k.length; i++)
+        k[i] = k[i] / sum;
+    const tmp = new Float32Array(src.length);
+    const out = new Float32Array(src.length);
+    for (let y = 0; y < height; y++) {
+        const row = y * width;
+        for (let x = 0; x < width; x++) {
+            let acc = 0;
+            for (let d = -radius; d <= radius; d++) {
+                const sx = Math.min(width - 1, Math.max(0, x + d));
+                acc += src[row + sx] * k[d + radius];
+            }
+            tmp[row + x] = acc;
+        }
+    }
+    for (let x = 0; x < width; x++) {
+        for (let y = 0; y < height; y++) {
+            let acc = 0;
+            for (let d = -radius; d <= radius; d++) {
+                const sy = Math.min(height - 1, Math.max(0, y + d));
+                acc += tmp[sy * width + x] * k[d + radius];
+            }
+            out[y * width + x] = acc;
+        }
+    }
+    return out;
+}
+/**
+ * Line-ness at one scale.
+ *
+ * The Hessian eigenvalues are ordered |l1| <= |l2|. For an ideal line l2 is
+ * large and l1 ~ 0; for a blob both are large and similar; for flat ink both
+ * are ~0. So `|l2| * (1 - |l1/l2|)` rewards elongation and penalises
+ * blob-likeness, which is the Frangi criterion reduced to the single term that
+ * matters here — the full vesselness adds exponentials whose constants would
+ * be two more numbers to tune for no gain on this corpus.
+ *
+ * 🛑 Both polarities are kept. A kiss cut scans as a doublet — a shadow beside
+ * a highlight — so along one edge of the groove the line is DARK and along the
+ * other it is BRIGHT. Keeping only one sign finds half of every outline, which
+ * reads as a detector that nearly works and produces open paths.
+ */
+function lineness(luma, width, height, sigma) {
+    const g = gaussian(luma, width, height, sigma);
+    const out = new Float32Array(luma.length);
+    // Normalise by sigma^2 so responses at different scales are comparable —
+    // required for the multi-scale max below to mean anything.
+    const norm = sigma * sigma;
+    for (let y = 1; y < height - 1; y++) {
+        for (let x = 1; x < width - 1; x++) {
+            const i = y * width + x;
+            const c = g[i];
+            const dxx = g[i + 1] - 2 * c + g[i - 1];
+            const dyy = g[i + width] - 2 * c + g[i - width];
+            const dxy = (g[i + width + 1] - g[i + width - 1] - g[i - width + 1] + g[i - width - 1]) / 4;
+            // Closed-form eigenvalues of [[dxx, dxy], [dxy, dyy]].
+            const tr = dxx + dyy;
+            const diff = dxx - dyy;
+            const root = Math.sqrt(diff * diff + 4 * dxy * dxy);
+            const ea = (tr + root) / 2;
+            const eb = (tr - root) / 2;
+            const absA = Math.abs(ea);
+            const absB = Math.abs(eb);
+            const l1 = Math.min(absA, absB);
+            const l2 = Math.max(absA, absB);
+            if (l2 < 1e-6)
+                continue;
+            out[i] = norm * l2 * (1 - l1 / l2);
+        }
+    }
+    return out;
+}
+/**
+ * Multi-scale line detection.
+ *
+ * A scan's cut lines are not all one width — resolution, paper and how hard
+ * the die pressed all vary — so a single scale finds the ones it is tuned to
+ * and misses the rest, producing exactly the broken outlines that make a
+ * region partition collapse. Taking the per-pixel maximum across a few scales
+ * is the standard answer and costs one Gaussian per scale.
+ */
+export function detectLines(luma, width, height, scales = [1, 1.6, 2.4]) {
+    const response = new Float32Array(luma.length);
+    for (const sigma of scales) {
+        const r = lineness(luma, width, height, sigma);
+        for (let i = 0; i < response.length; i++) {
+            if (r[i] > response[i])
+                response[i] = r[i];
+        }
+    }
+    let max = 0;
+    for (let i = 0; i < response.length; i++)
+        if (response[i] > max)
+            max = response[i];
+    return { response, maxResponse: max };
+}

package/dist/_internal/shared/features/sticker-trace/trace/merge.d.ts

@@ -0,0 +1,27 @@
+export interface MergeResult {
+    /** Region id per pixel after merging; 0 stays background/barrier. */
+    readonly labels: Int32Array;
+    readonly regionCount: number;
+    readonly mergesApplied: number;
+    /** Median boundary strength across the graph — the scale the cut is judged against. */
+    readonly medianStrength: number;
+}
+/**
+ * Merge adjacent regions whose shared boundary is weak.
+ *
+ * `strengthFactor` is a multiple of the MEDIAN boundary strength in this
+ * sheet's own graph, not an absolute response value — for the same reason the
+ * ridge thresholds are local (the response scale varies by two orders of
+ * magnitude across the corpus). A boundary below that multiple is treated as
+ * printing; at or above it, as a cut.
+ *
+ * 🛑 Single-pass greedy, not true hierarchical merging. Pair strengths are
+ * computed once and never recomputed as regions combine, so a chain of weak
+ * links can merge two regions whose own shared boundary was never measured.
+ * That is acceptable HERE and would not be in general: the thing those chains
+ * reunify is precisely the waste matrix, which is the outcome wanted. A proper
+ * recomputing merge would cost a priority queue and a rebuild per step for a
+ * result that is the same on this corpus — revisit only if a real sheet shows
+ * two stickers merging through a chain.
+ */
+export declare function mergeWeakBoundaries(labels: Int32Array, regionCount: number, response: Float32Array, width: number, height: number, strengthFactor: number): MergeResult;

package/dist/_internal/shared/features/sticker-trace/trace/merge.js

@@ -0,0 +1,187 @@
+/*
+ * WHY: Measured on the reference corpus, the art-background sheets came back
+ *      with 209 parts against ~12 real ones, and a threshold sweep showed it
+ *      was structural: even at 1.0% barrier coverage the count stayed 3x too
+ *      high, monotonically, with no minimum. Thresholds cannot fix it because
+ *      the extra regions are not noise — they are the sheet's own ARTWORK
+ *      fragmenting the waste matrix into pieces.
+ *
+ *      The physical fact the fix rests on: between the stickers there is ONE
+ *      continuous piece of backing. Artwork printed across it does not cut it.
+ *      So regions separated by a weak boundary belong together, and the matrix
+ *      reunifies into a single large region — which the sheet-fraction rule
+ *      then drops on its own.
+ * WHAT: A region-adjacency merge driven by BOUNDARY STRENGTH rather than by
+ *       region appearance.
+ *
+ * Strength, not length or shape. A long artwork edge is still an artwork edge,
+ * and a short cut line is still a cut. The question "did somebody's blade go
+ * through here" is answered by how hard the ridge detector saw that specific
+ * boundary — which is a number this already has, per pixel, and was throwing
+ * away by reducing the response to a binary barrier.
+ *
+ * EXPORTS: mergeWeakBoundaries
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:segment
+ * @tag sideEffects:none
+ */
+import { edtWithIndices } from "../math/edt.js";
+/**
+ * Merge adjacent regions whose shared boundary is weak.
+ *
+ * `strengthFactor` is a multiple of the MEDIAN boundary strength in this
+ * sheet's own graph, not an absolute response value — for the same reason the
+ * ridge thresholds are local (the response scale varies by two orders of
+ * magnitude across the corpus). A boundary below that multiple is treated as
+ * printing; at or above it, as a cut.
+ *
+ * 🛑 Single-pass greedy, not true hierarchical merging. Pair strengths are
+ * computed once and never recomputed as regions combine, so a chain of weak
+ * links can merge two regions whose own shared boundary was never measured.
+ * That is acceptable HERE and would not be in general: the thing those chains
+ * reunify is precisely the waste matrix, which is the outcome wanted. A proper
+ * recomputing merge would cost a priority queue and a rebuild per step for a
+ * result that is the same on this corpus — revisit only if a real sheet shows
+ * two stickers merging through a chain.
+ */
+export function mergeWeakBoundaries(labels, regionCount, response, width, height, strengthFactor) {
+    if (regionCount < 2) {
+        return { labels, regionCount, mergesApplied: 0, medianStrength: 0 };
+    }
+    // Accumulate, per adjacent region PAIR, the ridge response along the barrier
+    // that separates them. A barrier pixel is attributed to every pair of
+    // distinct regions it touches, so a junction where three regions meet feeds
+    // all three pairs rather than being dropped for ambiguity.
+    const edges = new Map();
+    const key = (a, b) => (a < b ? a * 1e6 + b : b * 1e6 + a);
+    const touch = (a, b, strength) => {
+        if (a === 0 || b === 0 || a === b)
+            return;
+        const k = key(a, b);
+        const e = edges.get(k);
+        if (e) {
+            e.sum += strength;
+            e.count++;
+        }
+        else {
+            edges.set(k, { a: Math.min(a, b), b: Math.max(a, b), sum: strength, count: 1 });
+        }
+    };
+    /*
+     * 🛑 Territory assignment, not a look-across.
+     *
+     * The first version sampled `labels[i-1]` and `labels[i+1]` either side of
+     * each barrier pixel. That records NOTHING whenever the barrier is more than
+     * one pixel thick — both sides are themselves barrier, so both read 0 and the
+     * pair is skipped. The barrier here is hysteresis-GROWN and therefore always
+     * several pixels thick, so the edge set came out empty and the merge silently
+     * performed zero merges on every sheet. It read as "the merge decided not
+     * to" for four measured runs.
+     *
+     * Assigning every barrier pixel to its nearest region first — a watershed by
+     * another name, using the exact EDT that already exists — makes adjacency a
+     * plain neighbour test again, and it is correct for a barrier of any
+     * thickness.
+     */
+    const regionMask = new Uint8Array(labels.length);
+    for (let i = 0; i < labels.length; i++)
+        regionMask[i] = labels[i] !== 0 ? 1 : 0;
+    const { index } = edtWithIndices(regionMask, width, height);
+    const owner = new Int32Array(labels.length);
+    for (let i = 0; i < labels.length; i++) {
+        owner[i] = labels[i] !== 0 ? labels[i] : labels[index[i]];
+    }
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const i = y * width + x;
+            const a = owner[i];
+            if (a === 0)
+                continue;
+            // Strength is sampled from the BARRIER pixels only. A boundary's
+            // evidence is what the detector saw on the line itself, not on the
+            // territory either side of it, which carries no cut signal at all.
+            const s = labels[i] === 0 ? response[i] : 0;
+            const weighted = labels[i] === 0;
+            if (x < width - 1 && owner[i + 1] !== a && weighted)
+                touch(a, owner[i + 1], s);
+            if (y < height - 1 && owner[i + width] !== a && weighted)
+                touch(a, owner[i + width], s);
+        }
+    }
+    if (edges.size === 0) {
+        return { labels, regionCount, mergesApplied: 0, medianStrength: 0 };
+    }
+    const list = [...edges.values()].map((e) => ({ ...e, strength: e.sum / e.count }));
+    const sortedStrengths = list.map((e) => e.strength).sort((a, b) => a - b);
+    const medianStrength = sortedStrengths[sortedStrengths.length >> 1];
+    /*
+     * 🛑 A multiple of the median is wrong when the median is ZERO, and it was
+     * measured doing exactly that: with the same-material score most boundaries
+     * sit at 0, so `median * factor` was 0, the first edge tripped
+     * `strength >= threshold`, and the loop broke having merged nothing — a
+     * silent no-op that looked like "the merge decided not to".
+     *
+     * A PERCENTILE of the edge distribution cannot degenerate that way: it always
+     * names a real position in the list, whatever the values are. `factor` is
+     * reinterpreted as that percentile (1 => merge the weakest half).
+     */
+    const quantile = Math.min(0.98, Math.max(0.02, strengthFactor * 0.5));
+    list.sort((p, q) => p.strength - q.strength);
+    /*
+     * 🛑 Merge a COUNT of the weakest edges, not everything below a value.
+     *
+     * A value threshold still degenerates under TIES, and ties are the normal
+     * case here: the same-material score is 0 for most boundaries, so the median
+     * is 0, and `strength >= 0` tripped on the very first edge — measured as
+     * 2271 -> 2271 regions with zero merges at the default factor, while the
+     * same function at factor 1.9 collapsed 2271 -> 35. A fraction of the sorted
+     * list cannot do that: it always dissolves exactly the weakest share asked
+     * for, whatever the values are.
+     */
+    const mergeBudget = Math.floor(list.length * quantile);
+    const parent = new Int32Array(regionCount + 1);
+    for (let i = 0; i <= regionCount; i++)
+        parent[i] = i;
+    const find = (x) => {
+        let r = x;
+        while (parent[r] !== r) {
+            parent[r] = parent[parent[r]];
+            r = parent[r];
+        }
+        return r;
+    };
+    let merges = 0;
+    let considered = 0;
+    for (const e of list) {
+        if (considered >= mergeBudget)
+            break;
+        considered++;
+        const ra = find(e.a);
+        const rb = find(e.b);
+        if (ra !== rb) {
+            parent[rb] = ra;
+            merges++;
+        }
+    }
+    // Renumber densely so downstream code can size arrays by the count.
+    const remap = new Int32Array(regionCount + 1);
+    let next = 0;
+    for (let r = 1; r <= regionCount; r++) {
+        const root = find(r);
+        if (remap[root] === 0) {
+            next++;
+            remap[root] = next;
+        }
+        remap[r] = remap[root];
+    }
+    const out = new Int32Array(labels.length);
+    for (let i = 0; i < labels.length; i++) {
+        const l = labels[i];
+        out[i] = l === 0 ? 0 : remap[l];
+    }
+    return { labels: out, regionCount: next, mergesApplied: merges, medianStrength };
+}

package/dist/_internal/shared/features/sticker-trace/trace/paper.d.ts

@@ -0,0 +1,32 @@
+import type { DecodedRaster, ScanType } from "../types";
+export interface PaperEstimate {
+    readonly colour: readonly [number, number, number];
+    /**
+     * Spread of the border band around that colour, in the same distance units
+     * as `backgroundLikeMask`. A printed art sheet has a wide spread because its
+     * border is artwork; bare paper has a narrow one.
+     */
+    readonly spread: number;
+    /**
+     * What the border band suggests this scan IS. Only consulted when the caller
+     * asked for `auto` — an explicit choice always wins, because a human looking
+     * at the sheet beats a statistic about its edge.
+     */
+    readonly detectedType: Exclude<ScanType, "auto">;
+}
+/**
+ * Sample the outermost band and take the modal colour.
+ *
+ * The band is 2% of the short edge, floored at 4px: wide enough to carry a
+ * useful sample on a small scan, narrow enough that a sheet filling the frame
+ * still contributes mostly its own margin rather than its artwork.
+ */
+export declare function estimatePaper(raster: DecodedRaster, requested: ScanType): PaperEstimate;
+/**
+ * Pixels the flood may travel through, on colour alone.
+ *
+ * `tolerance` is in the same weighted-distance units as `spread`, and the two
+ * are added: a noisy scan earns a proportionally looser test rather than
+ * needing the caller to notice and compensate.
+ */
+export declare function backgroundLikeMask(raster: DecodedRaster, paper: PaperEstimate, tolerance: number): Uint8Array;

package/dist/_internal/shared/features/sticker-trace/trace/paper.js

@@ -0,0 +1,147 @@
+/*
+ * WHY: The flood fill has to start somewhere it is certain is OUTSIDE every
+ *      sticker, and it has to know what "outside" looks like so it can travel.
+ *      Both answers come from the sheet's border band — the one region of a
+ *      scan that is background by construction.
+ * WHAT: Modal background colour from the border, plus a per-pixel
+ *       "is this background-like" test in a perceptually sane colour space.
+ *
+ * 🛑 It estimates a MODE, not a mean. Averaging the border band over a scan
+ * whose sheet runs near the edge mixes paper with sticker ink and yields a
+ * colour that is neither — and then nothing matches it. A histogram peak is
+ * unmoved by a minority of contaminating pixels, which is exactly the property
+ * needed when "most of the border is background" is the only guarantee.
+ *
+ * EXPORTS: PaperEstimate, estimatePaper, backgroundLikeMask
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:flood,segment
+ * @tag sideEffects:none
+ */
+/**
+ * Squared distance in a cheap perceptual weighting.
+ *
+ * Plain RGB Euclidean treats a blue shift as being as visible as a green one,
+ * which it is not — so a tolerance loose enough to accept real paper variation
+ * in green also accepts colours a human reads as plainly different. The 2/4/3
+ * weighting is the standard low-cost approximation and costs two multiplies.
+ */
+function colourDistanceSq(r1, g1, b1, r2, g2, b2) {
+    const dr = r1 - r2;
+    const dg = g1 - g2;
+    const db = b1 - b2;
+    return 2 * dr * dr + 4 * dg * dg + 3 * db * db;
+}
+/**
+ * Sample the outermost band and take the modal colour.
+ *
+ * The band is 2% of the short edge, floored at 4px: wide enough to carry a
+ * useful sample on a small scan, narrow enough that a sheet filling the frame
+ * still contributes mostly its own margin rather than its artwork.
+ */
+export function estimatePaper(raster, requested) {
+    const { width, height, data } = raster;
+    const band = Math.max(4, Math.round(Math.min(width, height) * 0.02));
+    // 5 bits per channel — 32768 bins. Fine enough to separate cream from white,
+    // coarse enough that scanner noise lands in one bin rather than smearing the
+    // peak across a dozen.
+    const BITS = 5;
+    const SHIFT = 8 - BITS;
+    const SIZE = 1 << BITS;
+    const hist = new Int32Array(SIZE * SIZE * SIZE);
+    const samples = [];
+    const visit = (x, y) => {
+        const p = (y * width + x) * 4;
+        const r = data[p];
+        const g = data[p + 1];
+        const b = data[p + 2];
+        const bin = ((r >> SHIFT) << (BITS * 2)) | ((g >> SHIFT) << BITS) | (b >> SHIFT);
+        hist[bin] = hist[bin] + 1;
+        samples.push(p);
+    };
+    for (let y = 0; y < height; y++) {
+        const edgeRow = y < band || y >= height - band;
+        for (let x = 0; x < width; x++) {
+            if (edgeRow || x < band || x >= width - band)
+                visit(x, y);
+        }
+    }
+    let peak = 0;
+    let peakBin = 0;
+    for (let i = 0; i < hist.length; i++) {
+        if (hist[i] > peak) {
+            peak = hist[i];
+            peakBin = i;
+        }
+    }
+    // Refine: average the real pixels that fell in the winning bin, so the result
+    // is a true colour rather than the bin's centre.
+    const binR = (peakBin >> (BITS * 2)) & (SIZE - 1);
+    const binG = (peakBin >> BITS) & (SIZE - 1);
+    const binB = peakBin & (SIZE - 1);
+    let sr = 0;
+    let sg = 0;
+    let sb = 0;
+    let n = 0;
+    for (const p of samples) {
+        const r = data[p];
+        const g = data[p + 1];
+        const b = data[p + 2];
+        if ((r >> SHIFT) === binR && (g >> SHIFT) === binG && (b >> SHIFT) === binB) {
+            sr += r;
+            sg += g;
+            sb += b;
+            n++;
+        }
+    }
+    const colour = n > 0 ? [sr / n, sg / n, sb / n] : [binR << SHIFT, binG << SHIFT, binB << SHIFT];
+    // Spread: median distance of the band from that colour. Median rather than
+    // mean for the same reason the mode was chosen over the mean above — a
+    // sticker intruding into the band must not widen the tolerance for everything.
+    const distances = new Float64Array(samples.length);
+    for (let i = 0; i < samples.length; i++) {
+        const p = samples[i];
+        distances[i] = Math.sqrt(colourDistanceSq(data[p], data[p + 1], data[p + 2], colour[0], colour[1], colour[2]));
+    }
+    distances.sort();
+    const spread = distances.length > 0 ? distances[distances.length >> 1] : 0;
+    /*
+     * A bare-paper scan has a tight border: most of it is the same colour, so the
+     * modal bin dominates and the median distance from it is small. A printed
+     * art sheet's border is artwork, so neither holds.
+     *
+     * The threshold is deliberately generous toward `art`. Misreading paper as
+     * art costs some flood reach, which the ridge barrier still bounds; misreading
+     * art as paper lets the flood treat a printed field as background and eat the
+     * stickers sitting on it, which is the failure that has no recovery.
+     */
+    const dominance = samples.length > 0 ? peak / samples.length : 0;
+    const detectedType = dominance > 0.25 && spread < 40 ? "paper" : "art";
+    return {
+        colour,
+        spread,
+        detectedType: requested === "auto" ? detectedType : requested,
+    };
+}
+/**
+ * Pixels the flood may travel through, on colour alone.
+ *
+ * `tolerance` is in the same weighted-distance units as `spread`, and the two
+ * are added: a noisy scan earns a proportionally looser test rather than
+ * needing the caller to notice and compensate.
+ */
+export function backgroundLikeMask(raster, paper, tolerance) {
+    const { width, height, data } = raster;
+    const out = new Uint8Array(width * height);
+    const [pr, pg, pb] = paper.colour;
+    const limit = tolerance + paper.spread;
+    const limitSq = limit * limit * 9; // weights sum to 9; keep the comparison squared
+    for (let i = 0, p = 0; i < out.length; i++, p += 4) {
+        out[i] =
+            colourDistanceSq(data[p], data[p + 1], data[p + 2], pr, pg, pb) <= limitSq ? 1 : 0;
+    }
+    return out;
+}

package/dist/_internal/shared/features/sticker-trace/trace/prefilter.d.ts

@@ -0,0 +1,30 @@
+import type { DecodedRaster, PrefilterKind } from "../types";
+/**
+ * Rec. 601 luma. The ridge detector works on a single channel because the
+ * emboss signature is a brightness doublet — it appears in all three channels
+ * at once, so running the detector three times would triple the cost to find
+ * the same edge.
+ */
+export declare function toLuminance(raster: DecodedRaster): Float32Array;
+/**
+ * Median over a (2r+1)^2 window.
+ *
+ * Median rather than mean because a rosette is an impulse pattern: the mean of
+ * a dot and its surround is a grey that still carries the dot's energy, while
+ * the median discards it outright. The cut line survives because it is a
+ * CONTINUOUS feature — more than half the window sits on it when the window is
+ * centred there — which is precisely the property a median preserves and a
+ * blur does not.
+ */
+export declare function medianFilter(src: Float32Array, width: number, height: number, radius: number): Float32Array;
+/**
+ * Edge-preserving smoothing: weight neighbours by both distance and intensity
+ * similarity.
+ *
+ * This is the `precise`/`max` choice because it suppresses the rosette like a
+ * blur while refusing to average across a step — and the cut line IS a step.
+ * A plain Gaussian at the radius needed to kill a rosette also halves the
+ * doublet amplitude, which on the ~3x scan is the whole signal.
+ */
+export declare function bilateralFilter(src: Float32Array, width: number, height: number, radius: number, sigmaSpace?: number, sigmaRange?: number): Float32Array;
+export declare function applyPrefilter(luma: Float32Array, width: number, height: number, kind: PrefilterKind, radius: number): Float32Array;