@mohasinac/appkit 4.52.5 → 4.53.1

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

@@ -0,0 +1,20 @@
+import type { PartGeometry, SheetCluster } from "../types";
+/**
+ * Group parts into physical sheets.
+ *
+ * Single-link (transitive) on purpose: stickers on one sheet form a chain of
+ * near neighbours rather than a tight blob, so requiring every pair in a
+ * cluster to be close would split one sheet into several. The risk of
+ * single-link — a chain of intermediate items merging two genuine groups —
+ * does not arise here, because the gap between sheets is physical empty space
+ * with nothing in it.
+ *
+ * 🛑 With no DPI there is no millimetre, so clustering is SKIPPED and every
+ * part lands in group 0. A pixel threshold would mean something different on
+ * every scan, and a wrong split reads as a fact about the sheet rather than as
+ * a missing measurement.
+ */
+export declare function clusterParts(parts: readonly PartGeometry[], pxPerMm: number | null, gapMm: number): {
+    clusters: SheetCluster[];
+    assigned: PartGeometry[];
+};

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

@@ -0,0 +1,132 @@
+/*
+ * WHY: One scan can hold several physical sheets — the 4948x6955 reference scan
+ *      does. Presenting sixty parts as one flat list loses the fact that they
+ *      came off four different sheets, which is exactly what someone cutting
+ *      them needs to know.
+ * WHAT: Single-link clustering of part bounding boxes by gap distance.
+ *
+ * Gap, not centre distance. Two large stickers can have centres far apart while
+ * touching, and two small ones can have close centres while sitting on
+ * different sheets. The physical question is "how much bare space is between
+ * these", and that is the gap between their boxes.
+ *
+ * EXPORTS: clusterParts
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:index
+ * @tag sideEffects:none
+ */
+/** Axis-aligned gap; 0 when the boxes overlap or touch. */
+function boxGap(a, b) {
+    const dx = Math.max(0, Math.max(a.x - (b.x + b.width), b.x - (a.x + a.width)));
+    const dy = Math.max(0, Math.max(a.y - (b.y + b.height), b.y - (a.y + a.height)));
+    return Math.hypot(dx, dy);
+}
+/**
+ * Group parts into physical sheets.
+ *
+ * Single-link (transitive) on purpose: stickers on one sheet form a chain of
+ * near neighbours rather than a tight blob, so requiring every pair in a
+ * cluster to be close would split one sheet into several. The risk of
+ * single-link — a chain of intermediate items merging two genuine groups —
+ * does not arise here, because the gap between sheets is physical empty space
+ * with nothing in it.
+ *
+ * 🛑 With no DPI there is no millimetre, so clustering is SKIPPED and every
+ * part lands in group 0. A pixel threshold would mean something different on
+ * every scan, and a wrong split reads as a fact about the sheet rather than as
+ * a missing measurement.
+ */
+export function clusterParts(parts, pxPerMm, gapMm) {
+    if (parts.length === 0) {
+        return { clusters: [], assigned: [] };
+    }
+    if (!pxPerMm) {
+        return {
+            clusters: [
+                {
+                    index: 0,
+                    bboxPx: unionBox(parts.map((p) => p.bboxPx)),
+                    partOrdinals: parts.map((p) => p.ordinal),
+                },
+            ],
+            assigned: parts.map((p) => ({ ...p, groupIndex: 0 })),
+        };
+    }
+    const threshold = gapMm * pxPerMm;
+    const n = parts.length;
+    const parent = new Int32Array(n);
+    for (let i = 0; i < n; i++)
+        parent[i] = i;
+    const find = (x) => {
+        let r = x;
+        while (parent[r] !== r) {
+            parent[r] = parent[parent[r]];
+            r = parent[r];
+        }
+        return r;
+    };
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            if (boxGap(parts[i].bboxPx, parts[j].bboxPx) <= threshold) {
+                const a = find(i);
+                const b = find(j);
+                if (a !== b)
+                    parent[b] = a;
+            }
+        }
+    }
+    const groupOf = new Map();
+    const members = new Map();
+    for (let i = 0; i < n; i++) {
+        const root = find(i);
+        let g = groupOf.get(root);
+        if (g === undefined) {
+            g = groupOf.size;
+            groupOf.set(root, g);
+            members.set(g, []);
+        }
+        members.get(g).push(i);
+    }
+    // Order groups top-to-bottom, then left-to-right — reading order, so "sheet 1"
+    // is the one a human would call the first.
+    const order = [...members.entries()].sort((a, b) => {
+        const ba = unionBox(a[1].map((i) => parts[i].bboxPx));
+        const bb = unionBox(b[1].map((i) => parts[i].bboxPx));
+        return ba.y - bb.y || ba.x - bb.x;
+    });
+    const clusters = [];
+    const assigned = [];
+    order.forEach(([, idxs], index) => {
+        const boxes = idxs.map((i) => parts[i].bboxPx);
+        clusters.push({
+            index,
+            bboxPx: unionBox(boxes),
+            partOrdinals: idxs.map((i) => parts[i].ordinal),
+        });
+        for (const i of idxs)
+            assigned.push({ ...parts[i], groupIndex: index });
+    });
+    assigned.sort((a, b) => a.ordinal - b.ordinal);
+    return { clusters, assigned };
+}
+function unionBox(boxes) {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (const b of boxes) {
+        if (b.x < x0)
+            x0 = b.x;
+        if (b.y < y0)
+            y0 = b.y;
+        if (b.x + b.width > x1)
+            x1 = b.x + b.width;
+        if (b.y + b.height > y1)
+            y1 = b.y + b.height;
+    }
+    return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+}

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

@@ -0,0 +1,28 @@
+import type { DecodedRaster } from "../types";
+/**
+ * Filter a barrier to the pixels whose two sides are the same material.
+ *
+ * `probe` must clear the line's own width — it is sampled from the UNFILTERED
+ * raster, so landing inside the groove reads the shadow rather than the
+ * material and every cut would look like an edge. 4px is comfortable for a
+ * 1-3px kiss cut at the working resolution.
+ *
+ * `tolerance` is a weighted colour distance. Generous on purpose: the two
+ * sides of a real groove differ slightly from lighting and scanner noise, and
+ * a tight tolerance rejects genuine cuts on any gradient — which is most of
+ * this corpus.
+ */
+/**
+ * 🛑 This returns a per-pixel SCORE, and must not be used to filter the
+ * barrier directly. That was tried and measured: hard-dropping every barrier
+ * pixel whose sides differ breaks a cut loop wherever it happens to cross a
+ * colour boundary, the complement stops being enclosed, and the whole sheet
+ * collapses into one region — 0 parts on four of five art scans.
+ *
+ * The score is instead fed to the region merge as its boundary strength, where
+ * a broken run costs a little evidence rather than the entire outline.
+ */
+export declare function sameMaterialScore(raster: DecodedRaster, barrier: Uint8Array, luma: Float32Array, tolerance: number, probe?: number): {
+    score: Float32Array;
+    meanScore: number;
+};

package/dist/_internal/shared/features/sticker-trace/trace/cross-profile.js

@@ -0,0 +1,120 @@
+/*
+ * WHY: Two measured failures pointed at the same wrong assumption.
+ *
+ *      (1) On art sheets a threshold sweep never converged — 209 parts at 31%
+ *          barrier coverage, still 36 at 1.0%, monotonic with no minimum.
+ *      (2) The colour-quantisation assist made torch-pegases WORSE (209 -> 257
+ *          at default, 182 vs 36 at high threshold).
+ *
+ *      Both follow from treating AMPLITUDE as the discriminator. It is not.
+ *      The cut line on torch-pegases measured +22 against +-1 noise — moderate
+ *      — while the sheet's own lettering and logos are far higher contrast. So
+ *      raising the bar removes cuts and keeps artwork, which is exactly
+ *      backwards, and a colour-boundary detector marks precisely the artwork.
+ *
+ *      The physics gives the real discriminator. A kiss cut is a groove
+ *      pressed into ONE piece of material: the scanner sees a shadow/highlight
+ *      doublet, and then the colour RETURNS to what it was. An artwork edge
+ *      separates two different colours and does not return.
+ * WHAT: Keep a barrier pixel only when the material either side of it matches.
+ *
+ * This also inverts the quantisation channel's role on art sheets: a colour
+ * boundary is EVIDENCE AGAINST a cut, not for one. The plan's "fusion must
+ * help, never hurt" check is what surfaced that, by running the corpus with
+ * the channel off and on rather than assuming a second signal can only add.
+ *
+ * EXPORTS: keepSameMaterialBarrier
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:segment
+ * @tag sideEffects:none
+ */
+function colourDistance(d, p, q) {
+    const dr = d[p] - d[q];
+    const dg = d[p + 1] - d[q + 1];
+    const db = d[p + 2] - d[q + 2];
+    return Math.sqrt(2 * dr * dr + 4 * dg * dg + 3 * db * db);
+}
+/**
+ * Filter a barrier to the pixels whose two sides are the same material.
+ *
+ * `probe` must clear the line's own width — it is sampled from the UNFILTERED
+ * raster, so landing inside the groove reads the shadow rather than the
+ * material and every cut would look like an edge. 4px is comfortable for a
+ * 1-3px kiss cut at the working resolution.
+ *
+ * `tolerance` is a weighted colour distance. Generous on purpose: the two
+ * sides of a real groove differ slightly from lighting and scanner noise, and
+ * a tight tolerance rejects genuine cuts on any gradient — which is most of
+ * this corpus.
+ */
+/**
+ * 🛑 This returns a per-pixel SCORE, and must not be used to filter the
+ * barrier directly. That was tried and measured: hard-dropping every barrier
+ * pixel whose sides differ breaks a cut loop wherever it happens to cross a
+ * colour boundary, the complement stops being enclosed, and the whole sheet
+ * collapses into one region — 0 parts on four of five art scans.
+ *
+ * The score is instead fed to the region merge as its boundary strength, where
+ * a broken run costs a little evidence rather than the entire outline.
+ */
+export function sameMaterialScore(raster, barrier, luma, tolerance, probe = 4) {
+    const { width, height, data } = raster;
+    const score = new Float32Array(barrier.length);
+    let total = 0;
+    let n = 0;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const i = y * width + x;
+            if (!barrier[i])
+                continue;
+            // Local gradient gives the direction ACROSS the line. Central
+            // differences on the already-prefiltered luminance, which is smooth
+            // enough that a 3-tap estimate is stable.
+            const xm = Math.max(0, x - 1);
+            const xp = Math.min(width - 1, x + 1);
+            const ym = Math.max(0, y - 1);
+            const yp = Math.min(height - 1, y + 1);
+            const gx = luma[y * width + xp] - luma[y * width + xm];
+            const gy = luma[yp * width + x] - luma[ym * width + x];
+            const mag = Math.hypot(gx, gy);
+            if (mag < 1e-3) {
+                // No orientation to sample across — score it neutral-positive rather
+                // than guessing. A barrier pixel with no local gradient is usually the
+                // interior of a thick linked run, which carries no evidence either way.
+                score[i] = 0.5;
+                total += 0.5;
+                n++;
+                continue;
+            }
+            const nx = gx / mag;
+            const ny = gy / mag;
+            const ax = Math.round(x + nx * probe);
+            const ay = Math.round(y + ny * probe);
+            const bx = Math.round(x - nx * probe);
+            const by = Math.round(y - ny * probe);
+            // A probe leaving the raster cannot be judged, so keep rather than drop —
+            // stickers that run to the sheet edge are common and must not lose their
+            // outline to a sampling artefact.
+            if (ax < 0 || ay < 0 || bx < 0 || by < 0 || ax >= width || ay >= height || bx >= width || by >= height) {
+                score[i] = 0.5;
+                total += 0.5;
+                n++;
+                continue;
+            }
+            const dist = colourDistance(data, (ay * width + ax) * 4, (by * width + bx) * 4);
+            // 1 = the two sides are the same material (a groove), 0 = plainly
+            // different colours (an artwork boundary). Continuous rather than a
+            // threshold so a boundary that is mostly groove still outweighs one that
+            // is mostly print when the two are averaged along a shared edge.
+            const v = Math.max(0, 1 - dist / Math.max(1, tolerance));
+            score[i] = v;
+            total += v;
+            n++;
+        }
+    }
+    return { score, meanScore: n > 0 ? total / n : 0 };
+}

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

@@ -0,0 +1,21 @@
+export interface FloodResult {
+    /** 1 where the outside reached. */
+    readonly outside: Uint8Array;
+    /** `!outside` — every pixel the flood could not reach. */
+    readonly inside: Uint8Array;
+    /** Fraction of the raster the flood reached; a diagnostic. */
+    readonly reach: number;
+}
+/**
+ * Flood inward from the raster border.
+ *
+ * Seeded from a BAND rather than the single outermost row: a scan frequently
+ * has a dark or ragged outermost pixel line (the scanner lid edge, a crop
+ * artefact), and seeding only there can start the flood on pixels that are not
+ * background-like at all, so it never leaves the edge and the entire sheet is
+ * reported as one sticker.
+ *
+ * Explicit stack, not recursion — a clean paper scan floods millions of pixels
+ * in one connected region.
+ */
+export declare function floodFromBorder(backgroundLike: Uint8Array, barrier: Uint8Array, width: number, height: number, seedBand: number): FloodResult;

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

@@ -0,0 +1,104 @@
+/*
+ * WHY: This is the inversion that fixes the reported bug. The previous tracer
+ *      asked "is this pixel background-COLOURED?" and so made every region
+ *      inside a sticker that happened to match the paper transparent. This asks
+ *      "can the outside REACH this pixel?" — and an enclosed region cannot be
+ *      reached whatever colour it is.
+ * WHAT: A border-seeded flood through pixels that are background-like AND not
+ *       barrier. Everything it fails to reach is sticker.
+ *
+ * The two failures this closes, stated as the properties that now hold:
+ *
+ *   1. A white sticker edge on white paper is still found, because the CUT LINE
+ *      stops the flood even where the colour does not — the barrier is a ridge
+ *      map, not a colour test.
+ *   2. A paper-coloured region INSIDE a sticker stays opaque, because the flood
+ *      would have to cross that sticker's outline to get there.
+ *
+ * EXPORTS: FloodResult, floodFromBorder
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:segment
+ * @tag sideEffects:none
+ */
+/**
+ * Flood inward from the raster border.
+ *
+ * Seeded from a BAND rather than the single outermost row: a scan frequently
+ * has a dark or ragged outermost pixel line (the scanner lid edge, a crop
+ * artefact), and seeding only there can start the flood on pixels that are not
+ * background-like at all, so it never leaves the edge and the entire sheet is
+ * reported as one sticker.
+ *
+ * Explicit stack, not recursion — a clean paper scan floods millions of pixels
+ * in one connected region.
+ */
+export function floodFromBorder(backgroundLike, barrier, width, height, seedBand) {
+    const outside = new Uint8Array(width * height);
+    const stack = [];
+    const passable = (i) => backgroundLike[i] === 1 && barrier[i] === 0;
+    const seed = (x, y) => {
+        const i = y * width + x;
+        if (outside[i] || !passable(i))
+            return;
+        outside[i] = 1;
+        stack.push(i);
+    };
+    const band = Math.max(1, seedBand);
+    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)
+                seed(x, y);
+        }
+    }
+    // 4-connectivity, matching the component labelling. 8-connectivity would let
+    // the flood squeeze through a barrier that touches only diagonally — i.e.
+    // through a cut line the ridge detector drew as a perfect stair-step, which
+    // is most of them.
+    while (stack.length > 0) {
+        const i = stack.pop();
+        const x = i % width;
+        const y = (i / width) | 0;
+        if (x > 0) {
+            const j = i - 1;
+            if (!outside[j] && passable(j)) {
+                outside[j] = 1;
+                stack.push(j);
+            }
+        }
+        if (x < width - 1) {
+            const j = i + 1;
+            if (!outside[j] && passable(j)) {
+                outside[j] = 1;
+                stack.push(j);
+            }
+        }
+        if (y > 0) {
+            const j = i - width;
+            if (!outside[j] && passable(j)) {
+                outside[j] = 1;
+                stack.push(j);
+            }
+        }
+        if (y < height - 1) {
+            const j = i + width;
+            if (!outside[j] && passable(j)) {
+                outside[j] = 1;
+                stack.push(j);
+            }
+        }
+    }
+    const inside = new Uint8Array(width * height);
+    let reached = 0;
+    for (let i = 0; i < outside.length; i++) {
+        if (outside[i])
+            reached++;
+        else
+            inside[i] = 1;
+    }
+    return { outside, inside, reach: reached / outside.length };
+}

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

@@ -0,0 +1,3 @@
+import type { ComponentStats } from "../math/label";
+import type { PartGeometry, TraceParams } from "../types";
+export declare function buildPartGeometry(labels: Int32Array, width: number, height: number, stat: ComponentStats, ordinal: number, params: TraceParams, pxPerMm: number | null, subPixel: boolean): PartGeometry | null;

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

@@ -0,0 +1,140 @@
+/*
+ * WHY: A labelled component is a bag of pixels; a cutter needs one closed
+ *      curve. This is the conversion, and it is also where every millimetre
+ *      figure is either computed honestly or withheld.
+ * WHAT: Per component — isolate, offset by the cut border, trace, simplify,
+ *       fit cubics, and measure.
+ *
+ * Each component is processed inside its own PADDED bounding box rather than
+ * over the whole raster. On a 9 MP sheet with sixty stickers the full-raster
+ * form would allocate sixty 9 MP masks; this allocates sixty small ones. The
+ * padding exists because the border offset and the contour both need room to
+ * step outside the component, and a contour clipped by the box edge is an open
+ * path — which is a cut the machine starts and never finishes.
+ *
+ * EXPORTS: buildPartGeometry
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:index
+ * @tag sideEffects:none
+ */
+import { catmullRomToBezier } from "../math/catmull-rom.js";
+import { traceContours } from "../math/marching-squares.js";
+import { dilate, minFeatureRadius } from "../math/morphology.js";
+import { simplifyRdp } from "../math/rdp.js";
+/**
+ * Extract one component into its own buffer, padded on every side.
+ *
+ * Padding must exceed the border offset, or the dilation runs into the box
+ * wall and the outline comes back with a flat edge where the sticker is
+ * actually round.
+ */
+function isolate(labels, width, height, label, bbox, pad) {
+    const x0 = Math.max(0, bbox.x - pad);
+    const y0 = Math.max(0, bbox.y - pad);
+    const x1 = Math.min(width, bbox.x + bbox.width + pad);
+    const y1 = Math.min(height, bbox.y + bbox.height + pad);
+    const w = x1 - x0;
+    const h = y1 - y0;
+    const mask = new Uint8Array(w * h);
+    for (let y = 0; y < h; y++) {
+        const src = (y0 + y) * width + x0;
+        const dst = y * w;
+        for (let x = 0; x < w; x++) {
+            if (labels[src + x] === label)
+                mask[dst + x] = 1;
+        }
+    }
+    return { mask, w, h, originX: x0, originY: y0 };
+}
+export function buildPartGeometry(labels, width, height, stat, ordinal, params, pxPerMm, subPixel) {
+    const borderPx = pxPerMm ? params.borderMm * pxPerMm : 0;
+    const pad = Math.max(3, Math.ceil(borderPx) + 3);
+    const { mask, w, h, originX, originY } = isolate(labels, width, height, stat.label, stat.bbox, pad);
+    // The CUT outline, which is the silhouette offset outward by the white
+    // border the sticker is meant to carry. With borderMm at 0 this is the
+    // silhouette itself — cut exactly on the art edge.
+    const cutMask = borderPx > 0 ? dilate(mask, w, h, borderPx) : mask;
+    /*
+     * Sub-pixel tracing needs a CONTINUOUS field to interpolate; on a binary mask
+     * every crossing lands at the midpoint and the "sub-pixel" tier buys nothing.
+     * A light blur is what makes the iso-crossing meaningful — which is why the
+     * precise/max tiers blur before tracing rather than tracing harder.
+     */
+    const field = subPixel ? softenForSubPixel(cutMask, w, h) : cutMask;
+    const rings = traceContours(field, w, h, 0.5);
+    if (rings.length === 0)
+        return null;
+    // Outer boundary only. A kiss-cut sheet never cuts interior holes — doing so
+    // would drop the middle out of every ring-shaped sticker — so the largest
+    // ring by absolute area is the one and only path.
+    let outer = rings[0];
+    for (const ring of rings) {
+        if (Math.abs(ring.signedArea) > Math.abs(outer.signedArea))
+            outer = ring;
+    }
+    if (!outer.closed || outer.points.length < 8)
+        return null;
+    const simplifyPx = pxPerMm ? params.simplifyMm * pxPerMm : 0.6;
+    const simplified = simplifyRdp(outer.points, simplifyPx);
+    // Translate back into raster coordinates before fitting, so the emitted path
+    // is in the same space as everything else and no consumer has to know this
+    // function worked in a local box.
+    const absolute = simplified.map((p) => ({
+        x: p.x + originX,
+        y: p.y + originY,
+    }));
+    const path = catmullRomToBezier(absolute);
+    if (!path)
+        return null;
+    const featurePx = minFeatureRadius(cutMask, w, h) * 2;
+    const bboxPx = stat.bbox;
+    return {
+        ordinal,
+        groupIndex: 0,
+        bboxPx,
+        areaPx: stat.area,
+        bboxMm: pxPerMm
+            ? {
+                x: bboxPx.x / pxPerMm,
+                y: bboxPx.y / pxPerMm,
+                width: bboxPx.width / pxPerMm,
+                height: bboxPx.height / pxPerMm,
+            }
+            : null,
+        areaMm2: pxPerMm ? stat.area / (pxPerMm * pxPerMm) : null,
+        minFeatureMm: pxPerMm ? featurePx / pxPerMm : null,
+        path,
+    };
+}
+/**
+ * A 3x3 binary-average, turning a hard mask into a field whose 0.5 crossing
+ * sits between pixels rather than on one. Deliberately tiny: a wider kernel
+ * would start moving the edge rather than merely locating it more precisely.
+ */
+function softenForSubPixel(mask, width, height) {
+    const out = new Float32Array(mask.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let sum = 0;
+            let n = 0;
+            for (let dy = -1; dy <= 1; dy++) {
+                const sy = y + dy;
+                if (sy < 0 || sy >= height)
+                    continue;
+                for (let dx = -1; dx <= 1; dx++) {
+                    const sx = x + dx;
+                    if (sx < 0 || sx >= width)
+                        continue;
+                    sum += mask[sy * width + sx];
+                    n++;
+                }
+            }
+            out[y * width + x] = n > 0 ? sum / n : 0;
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,15 @@
+export interface LineFilterResult {
+    /** Line-ness per pixel. Large on a groove, ~0 on a step edge or flat ink. */
+    readonly response: Float32Array;
+    readonly maxResponse: number;
+}
+/**
+ * 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 declare function detectLines(luma: Float32Array, width: number, height: number, scales?: readonly number[]): LineFilterResult;