@stabrise/scaledp 0.1.0

package/README.md

@@ -0,0 +1,218 @@
+<p align="center">
+  <br/>
+    <a href="https://stabrise.com/scaledp/" target="_blank"><img alt="ScaleDP" src="https://stabrise.com/static/images/projects/scaledp.webp" width="450" style="max-width: 100%;"></a>
+  <br/>
+</p>
+
+<p align="center">
+    <i>Process documents using AI/ML in the browser. No server, no upload.</i>
+</p>
+
+<p align="center">
+    <a href="https://www.npmjs.com/package/@stabrise/scaledp" alt="Package on npm"><img src="https://img.shields.io/npm/v/@stabrise/scaledp.svg" /></a>
+    <a href="https://github.com/StabRise/scaledp-ts/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/npm/l/@stabrise/scaledp.svg?color=blue"></a>
+    <a href="https://stabrise.com"><img alt="StabRise" src="https://img.shields.io/badge/powered%20by-StabRise-orange.svg?style=flat&colorA=E1523D&colorB=blue"></a>
+</p>
+
+---
+
+**Source Code**: <a href="https://github.com/StabRise/scaledp-ts/" target="_blank">https://github.com/StabRise/scaledp-ts</a>
+
+**Python sibling**: <a href="https://github.com/StabRise/ScaleDP/" target="_blank">ScaleDP</a> — the same pipeline model, on Apache Spark
+
+---
+
+# scaledp-ts
+
+`@stabrise/scaledp` processes PDFs and images entirely in the browser: PDF
+rendering, text detection, OCR and named-entity recognition, composed as a
+pipeline. Inference runs on [onnxruntime-web](https://onnxruntime.ai/docs/tutorials/web/)
+over WebAssembly or WebGPU.
+
+It mirrors the [ScaleDP](https://github.com/StabRise/ScaleDP) Python library —
+same stages, same parameter names, same schemas — so a pipeline reads the same
+in both. What differs is the runtime: no Spark, no server, and **no document
+ever leaves the browser**, which is the point for anything sensitive.
+
+## Key features
+
+### Document processing
+
+- Load PDFs and images from a `File`, `Blob`, `ArrayBuffer` or URL
+- Render PDF pages, or read an existing text layer and skip OCR entirely
+- Word-level bounding boxes throughout, so every result maps back to the page
+
+### OCR
+
+- **PaddleOCR** (PP-OCRv5/v6) via [ppu-paddle-ocr](https://www.npmjs.com/package/ppu-paddle-ocr) — 13 language presets
+- **DBNet ONNX** — the same detection model ScaleDP uses server-side
+- **Tesseract** via [tesseract-wasm](https://www.npmjs.com/package/tesseract-wasm), with independent script detection
+
+### NLP
+
+- **GLiNER** zero-shot NER: entity types are plain-language labels given at call time, not fixed by the model
+- Both GLiNER1 and GLiNER2 architectures
+- Entities carry the boxes they came from, ready to highlight or redact
+
+### CV
+
+- YOLO object detection, including signature and face detectors
+
+### Displaying results
+
+- `ImageDrawBoxes` / `ImageCropBoxes` stages, as in ScaleDP
+- `showText`, `showNer`, `visualizeNer`, `showImage`, `showBoxes` -- the browser
+  equivalents of ScaleDP's notebook helpers
+
+## Installation
+
+```bash
+npm install @stabrise/scaledp
+```
+
+Engines are optional peer dependencies — install only what you use:
+
+```bash
+npm install pdfjs-dist                        # PDF reading
+npm install onnxruntime-web ppu-paddle-ocr    # PaddleOCR
+npm install onnxruntime-web @huggingface/transformers  # GLiNER NER
+npm install tesseract-wasm tesseract.js       # Tesseract + script detection
+```
+
+## Quickstart
+
+```ts
+import { Pipeline, configure } from '@stabrise/scaledp'
+import { PdfToImage } from '@stabrise/scaledp/pdf'
+import { PaddleTextRecognizer } from '@stabrise/scaledp/ocr'
+import { GlinerNer } from '@stabrise/scaledp/ner'
+
+configure({
+  cache: 'indexeddb',
+  pdf: { workerSrc: '/pdf.worker.min.mjs' },
+  onProgress: (p) => console.log(`${p.file}: ${p.loaded}/${p.total}`),
+})
+
+const pipeline = new Pipeline([
+  new PdfToImage({ resolution: 300 }),
+  new PaddleTextRecognizer({ preset: 'v6-small', keepFormatting: true }),
+  new GlinerNer({ labels: ['person', 'organization', 'email', 'phone'] }),
+])
+
+const rows = await pipeline.transform(file)
+
+for (const row of rows) {
+  console.log(row.page, row.text.text)
+  for (const entity of row.ner.entities) {
+    console.log(entity.entity_group, entity.word, entity.boxes)
+  }
+}
+```
+
+### Show the results
+
+```ts
+import { ImageDrawBoxes } from '@stabrise/scaledp'
+import { renderInto, showText, showNer, visualizeNer } from '@stabrise/scaledp/display'
+
+// Annotating the page is a pipeline stage, as in ScaleDP -- the result is
+// just another image column.
+pipeline.stages.push(
+  new ImageDrawBoxes({ inputCols: ['image', 'text', 'ner'], outputCol: 'annotated' })
+)
+
+renderInto('#text', showText(row.text))            // layout-preserving text
+renderInto('#entities', showNer(row.ner))          // table of entities
+renderInto('#inline', visualizeNer(row.text, row.ner))  // highlighted inline
+```
+
+Compare with the Python original:
+
+```python
+pipeline = PipelineModel(stages=[
+    PdfDataToImage(resolution=300),
+    TesseractOcr(inputCol="image", outputCol="text", keepFormatting=True),
+    Ner(inputCol="text", outputCol="ner"),
+])
+result = pipeline.transform(df)
+```
+
+### Skip OCR when the PDF already has text
+
+```ts
+import { PdfToDocument, hasUsableTextLayer } from '@stabrise/scaledp/pdf'
+
+const pipeline = new Pipeline([new PdfToDocument({ resolution: 300 })])
+const rows = await pipeline.transform(file)
+
+// Only pages without a text layer need the OCR pipeline.
+const needsOcr = rows.filter((r) => !hasUsableTextLayer(r.document))
+```
+
+### Run off the main thread
+
+```ts
+// worker.ts
+import { registerStages, startScaleDpWorker } from '@stabrise/scaledp/worker'
+import { PdfToImage } from '@stabrise/scaledp/pdf'
+import { PaddleTextRecognizer } from '@stabrise/scaledp/ocr'
+
+registerStages({ PdfToImage, PaddleTextRecognizer })
+startScaleDpWorker()
+```
+
+```ts
+// main.ts
+import { createScaleDpWorker } from '@stabrise/scaledp/worker'
+
+const client = createScaleDpWorker({
+  worker: new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' }),
+  onProgress: (p) => console.log(p),
+})
+
+const rows = await client.transform(
+  [{ type: 'PdfToImage' }, { type: 'PaddleTextRecognizer' }],
+  [{ content: bytes, path: 'invoice.pdf' }]
+)
+```
+
+## Errors never abort a pipeline
+
+Every output schema carries an `exception` field. A stage that fails records the
+message there and the pipeline continues, so one bad page does not lose the
+other forty. Pass `propagateError: true` to a stage to make it throw instead.
+
+```ts
+const row = rows[0]
+if (row.text.exception) console.warn('OCR failed:', row.text.exception)
+```
+
+## OCR engines
+
+|                    | Box level | Models fetched | WebGPU | Notes |
+|--------------------|-----------|----------------|--------|-------|
+| PaddleOCR (default)| word      | ~6 MB          | yes    | 13 language presets, best all-rounder |
+| DBNet ONNX         | word      | ~5 MB          | yes    | Detection only; mirrors ScaleDP server-side |
+| Tesseract          | word      | ~15 MB / lang  | no     | No ONNX; good for clean Latin scans |
+
+## Documentation
+
+The docs are a site at **[scaledp-ts.stabrise.com](https://scaledp-ts.stabrise.com)**,
+built with [Fumadocs](https://fumadocs.dev) and served next to a live pipeline
+builder — every stage page has an **Open in builder** link that seeds it with a
+working pipeline you can run on your own file.
+
+```bash
+cd examples/vite-demo && npm install && npm run dev
+```
+
+- [Quickstart](examples/vite-demo/content/docs/quickstart.mdx)
+- [Stage reference](examples/vite-demo/content/docs/stages/) — one page per stage, with parameter tables generated from the stage registry
+- [Concepts](examples/vite-demo/content/docs/concepts/) — rows and columns, the stage lifecycle, the error contract, schemas, models and caching, workers
+- [Recipes](examples/vite-demo/content/docs/recipes/) — complete pipelines for OCR, redaction, detection and workers
+- [Porting from Python ScaleDP](examples/vite-demo/content/docs/porting-from-python.mdx)
+
+## License
+
+AGPL-3.0-or-later, matching the Python library. Contact
+[StabRise](https://stabrise.com) for commercial licensing.

package/dist/box-DAfzwfhA.d.ts

@@ -0,0 +1,119 @@
+//#region src/core/geometry.d.ts
+/**
+ * OpenCV-compatible planar geometry, hand-ported so the browser build needs no
+ * opencv.js. Conventions match cv2 exactly — `Box.from_polygon` and the DBNet
+ * post-processor both depend on that, and a divergence here shifts every box.
+ */
+type Point = [number, number];
+interface RotatedRect {
+  /** Centre of the rectangle. */
+  center: Point;
+  /** Side lengths along the rect's own axes. */
+  size: [number, number];
+  /**
+   * Degrees in (0, 90], with `size[0]` (the width) lying along that direction.
+   *
+   * Verified against cv2 4.11 across 18 orientations. One caveat: for a
+   * perfectly axis-aligned rect cv2 itself is inconsistent, returning either
+   * `-0.0` or `90` depending on which hull edge its scan lands on. Those two
+   * describe the same rectangle (a rectangle is invariant under a 180-degree
+   * rotation once the sides are swapped), so we always report the `90` form.
+   * Nothing downstream can distinguish them -- ImageDrawBoxes renders angle
+   * and angle+180 identically.
+   */
+  angle: number;
+}
+/**
+ * Monotone-chain convex hull. Returns hull points counter-clockwise in a
+ * y-down image coordinate system, without the duplicated closing point.
+ */
+declare function convexHull(points: readonly Point[]): Point[];
+/**
+ * Minimum-area enclosing rectangle via rotating calipers.
+ *
+ * The minimum-area rectangle always has a side flush with a convex-hull edge,
+ * so testing one orientation per hull edge is exhaustive.
+ */
+declare function minAreaRect(points: readonly Point[]): RotatedRect;
+/**
+ * The 4 corners of a rotated rect, in cv2.boxPoints order.
+ * For an upright rect in image coordinates that is: BL, TL, TR, BR.
+ */
+declare function boxPoints(rect: RotatedRect): [Point, Point, Point, Point];
+/** Shoelace area of a simple polygon; always non-negative. */
+declare function polygonArea(points: readonly Point[]): number;
+/** Perimeter of a closed polygon. */
+declare function polygonPerimeter(points: readonly Point[]): number;
+//#endregion
+//#region src/schemas/box.d.ts
+interface Box {
+  text: string;
+  score: number;
+  /** Top-left x of the axis-aligned box of size width x height centred on the rect centre. */
+  x: number;
+  y: number;
+  /** Always the longer side. */
+  width: number;
+  height: number;
+  /** Degrees about the box centre, normalised to (-90, 270]. */
+  angle: number;
+}
+/** Two-corner shape: [[x0, y0], [x1, y1]]. */
+type BoxShape = [[number, number], [number, number]];
+/** Axis-aligned bounds: [x0, y0, x1, y1]. */
+type BBox = [number, number, number, number];
+/** `abs(angle) >= 3` — matches Python's `is_rotated`, which tolerates OCR jitter. */
+declare const ROTATION_EPSILON_DEGREES = 3;
+declare function createBox(init?: Partial<Box>): Box;
+declare function isRotated(box: Box): boolean;
+declare function bbox(box: Box, padding?: number): BBox;
+declare function shape(box: Box, padding?: number): BoxShape;
+/**
+ * Scale a box, then apply padding.
+ *
+ * Note the padding is asymmetric, and deliberately so: Python subtracts it from
+ * the origin and adds it to the size, so the box grows by `padding` on its left
+ * and top while its right and bottom edges stay put. Growing all four sides
+ * would need `padding * 2` on the size.
+ */
+declare function scaleBox(box: Box, factor: number, padding?: number): Box;
+declare function boxFromBBox(box: BBox, opts?: {
+  angle?: number;
+  text?: string;
+  score?: number;
+}): Box;
+/**
+ * Build a Box from exactly 4 polygon points — port of Python `Box.from_polygon`.
+ *
+ * `width` is forced to be the longer side (subtracting 90 degrees from the angle
+ * to compensate), then the angle is normalised to (-90, 270]. `x`/`y` are derived
+ * from the centre, NOT from the polygon's bounding box.
+ */
+declare function boxFromPolygon(points: readonly Point[], opts?: {
+  text?: string;
+  score?: number;
+  padding?: number;
+}): Box;
+/** Axis-aligned intersection-over-union. Ignores `angle`, exactly as Python does. */
+declare function boxIou(a: Box, b: Box): number;
+/** Union of two boxes. Merging discards rotation — Python resets `angle` to 0. */
+declare function mergeBoxes(a: Box, b: Box): Box;
+/**
+ * Whether two boxes sit on the same text line.
+ *
+ * For near-horizontal boxes this compares vertical centres against the average
+ * height. For rotated boxes it projects the centre offset onto the line's normal
+ * (dx = -sin, dy = cos), so the test follows the text's own baseline.
+ */
+declare function isOnSameLine(a: Box, b: Box, angleThresh?: number, lineThresh?: number): boolean;
+/**
+ * Greedily merge boxes that overlap and share a line. Port of Python
+ * `Box.merge_overlapping_boxes`.
+ *
+ * Restarts the scan after each merge so a chain of boxes collapses fully in one
+ * call, matching Python's behaviour.
+ */
+declare function mergeOverlappingBoxes(boxes: readonly Box[], iouThreshold?: number, angleThresh?: number, lineThresh?: number): Box[];
+//#endregion
+export { polygonPerimeter as S, RotatedRect as _, bbox as a, minAreaRect as b, boxIou as c, isRotated as d, mergeBoxes as f, Point as g, shape as h, ROTATION_EPSILON_DEGREES as i, createBox as l, scaleBox as m, Box as n, boxFromBBox as o, mergeOverlappingBoxes as p, BoxShape as r, boxFromPolygon as s, BBox as t, isOnSameLine as u, boxPoints as v, polygonArea as x, convexHull as y };
+//# sourceMappingURL=box-DAfzwfhA.d.ts.map

package/dist/config-g6IrKlDC.d.ts

@@ -0,0 +1,80 @@
+//#region src/core/config.d.ts
+/**
+ * Global configuration. Everything an application owns -- asset URLs, model
+ * hosts, auth -- is injected here rather than hardcoded, which is the main
+ * structural difference from the pdftools prototype this library supersedes.
+ */
+interface ModelProgress {
+  repo: string;
+  file: string;
+  /** Bytes fetched so far across the request set. */
+  loaded: number;
+  /** Total bytes expected; 0 when the server sent no content-length. */
+  total: number;
+  phase: 'downloading' | 'initializing' | 'ready';
+}
+interface ScaleDpConfig {
+  /** Base URL models resolve against. Point at an origin you control to self-host. */
+  modelHost: string;
+  /** Where downloaded model files are kept between page loads. */
+  cache: 'indexeddb' | 'none';
+  /** IndexedDB database name, so consumers can isolate or purge their own store. */
+  cacheDbName: string;
+  /**
+   * Bearer token supplier for private model repos. Returning `undefined`
+   * means "fetch anonymously".
+   */
+  auth?: (repo: string) => Promise<string | undefined> | string | undefined;
+  /** Reports download progress for every model file. */
+  onProgress?: (progress: ModelProgress) => void;
+  /** Execution providers, in priority order, for ONNX sessions. */
+  executionProviders: readonly string[];
+  /**
+   * WASM threads. `0` lets onnxruntime-web choose from hardwareConcurrency.
+   * Threading only engages on a cross-origin-isolated page (COOP/COEP);
+   * without that ORT silently falls back to the single-threaded build.
+   */
+  numThreads: number;
+  /**
+   * Directory holding the onnxruntime-web `.wasm`/`.mjs` pair. The loader and
+   * the binary must come from the same build variant AND the same version --
+   * a mismatch fails at init with an opaque error. Leave unset to let
+   * onnxruntime-web resolve its own default.
+   */
+  ortWasmPaths?: string;
+  /** pdf.js assets. All must be served by the consuming application. */
+  pdf: {
+    workerSrc?: string;
+    cMapUrl?: string;
+    standardFontDataUrl?: string;
+    wasmUrl?: string;
+  };
+  /** Tesseract assets. */
+  tesseract: {
+    workerUrl?: string;
+    /** Base URL for `<lang>.traineddata` files. */
+    dataUrl?: string;
+  };
+  /** Hugging Face host overrides, for proxying gated repos through your origin. */
+  hf: {
+    remoteHost?: string;
+    /** e.g. 'api/hf-model/{model}/resolve/{revision}/' */
+    remotePathTemplate?: string;
+  };
+}
+/** Merge `patch` into the global config. Nested asset maps merge per key. */
+declare function configure(patch: Partial<ScaleDpConfig>): ScaleDpConfig;
+declare function getConfig(): Readonly<ScaleDpConfig>;
+/** Restore defaults. Primarily for tests. */
+declare function resetConfig(): void;
+/**
+ * Threads to request from onnxruntime-web.
+ *
+ * Leaves one core for the UI and caps at 4 -- past that, ORT's own
+ * synchronisation overhead outweighs the gain on these model sizes.
+ */
+declare function defaultNumThreads(): number;
+declare function resolveNumThreads(): number;
+//#endregion
+export { getConfig as a, defaultNumThreads as i, ScaleDpConfig as n, resetConfig as o, configure as r, resolveNumThreads as s, ModelProgress as t };
+//# sourceMappingURL=config-g6IrKlDC.d.ts.map

package/dist/data-to-image-DoZ4jQ3R.js

@@ -0,0 +1,54 @@
+import { c as ImageError, i as Stage } from "./pipeline-DACqGkpN.js";
+import { d as probeImageSize } from "./image-CAH2rLv9.js";
+import { i as resolveParams, t as BASE_STAGE_DEFAULTS } from "./params-DapwK9Ns.js";
+import { t as createImage } from "./image-DoZDJkcR.js";
+//#region src/stages/data-to-image.ts
+/**
+* Port of `scaledp/image/DataToImage.py`: raw bytes -> an `Image` record.
+*
+* Dimensions are probed without retaining the decoded bitmap, mirroring
+* Python's use of `imagesize.get` rather than a full PIL decode.
+*/
+const DATA_TO_IMAGE_DEFAULTS = Object.freeze({
+	...BASE_STAGE_DEFAULTS,
+	inputCol: "content",
+	outputCol: "image",
+	imageType: "png",
+	resolution: 0
+});
+var DataToImage = class extends Stage {
+	name = "DataToImage";
+	constructor(options = {}) {
+		super(resolveParams(DATA_TO_IMAGE_DEFAULTS, options));
+	}
+	async apply(input, row) {
+		const data = toBytes(input);
+		if (data.byteLength === 0) throw new ImageError("Empty image data", this.name);
+		const { width, height } = await probeImageSize(data);
+		return createImage({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			resolution: Number(row.resolution ?? this.params.resolution) || 0,
+			data,
+			imageType: this.params.imageType,
+			width,
+			height
+		});
+	}
+	onError(message, row) {
+		return createImage({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			exception: message
+		});
+	}
+};
+/** Coerce any accepted binary representation into bytes. */
+function toBytes(input) {
+	if (input instanceof Uint8Array) return input;
+	if (input instanceof ArrayBuffer) return new Uint8Array(input);
+	if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+	throw new ImageError(`Expected binary image data, received ${typeof input}`, "toBytes");
+}
+//#endregion
+export { DataToImage as n, toBytes as r, DATA_TO_IMAGE_DEFAULTS as t };
+
+//# sourceMappingURL=data-to-image-DoZ4jQ3R.js.map

package/dist/data-to-image-DoZ4jQ3R.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-to-image-DoZ4jQ3R.js","names":[],"sources":["../src/stages/data-to-image.ts"],"sourcesContent":["/**\n * Port of `scaledp/image/DataToImage.py`: raw bytes -> an `Image` record.\n *\n * Dimensions are probed without retaining the decoded bitmap, mirroring\n * Python's use of `imagesize.get` rather than a full PIL decode.\n */\n\nimport { ImageError } from '../core/errors.js'\nimport { probeImageSize } from '../core/image.js'\nimport { BASE_STAGE_DEFAULTS, type BaseStageParams, resolveParams } from '../core/params.js'\nimport { type Row, Stage } from '../core/pipeline.js'\nimport { createImage, type ImageFormat, type ScaleDpImage } from '../schemas/image.js'\n\nexport interface DataToImageParams extends BaseStageParams {\n    /** Encoding recorded on the output; the bytes are passed through unchanged. */\n    imageType: ImageFormat\n    /** DPI to record when the row carries no `resolution` field. */\n    resolution: number\n}\n\nexport const DATA_TO_IMAGE_DEFAULTS: DataToImageParams = Object.freeze({\n    ...BASE_STAGE_DEFAULTS,\n    inputCol: 'content',\n    outputCol: 'image',\n    imageType: 'png' as ImageFormat,\n    resolution: 0,\n})\n\nexport class DataToImage extends Stage<DataToImageParams> {\n    readonly name = 'DataToImage'\n\n    constructor(options: Partial<DataToImageParams> = {}) {\n        super(resolveParams(DATA_TO_IMAGE_DEFAULTS, options))\n    }\n\n    protected async apply(input: unknown, row: Row): Promise<ScaleDpImage> {\n        const data = toBytes(input)\n        if (data.byteLength === 0) {\n            throw new ImageError('Empty image data', this.name)\n        }\n        const { width, height } = await probeImageSize(data)\n        return createImage({\n            path: String(row[this.params.pathCol] ?? 'memory'),\n            resolution: Number(row.resolution ?? this.params.resolution) || 0,\n            data,\n            imageType: this.params.imageType,\n            width,\n            height,\n        })\n    }\n\n    protected onError(message: string, row: Row): ScaleDpImage {\n        return createImage({\n            path: String(row[this.params.pathCol] ?? 'memory'),\n            exception: message,\n        })\n    }\n}\n\n/** Coerce any accepted binary representation into bytes. */\nexport function toBytes(input: unknown): Uint8Array {\n    if (input instanceof Uint8Array) return input\n    if (input instanceof ArrayBuffer) return new Uint8Array(input)\n    if (ArrayBuffer.isView(input)) {\n        return new Uint8Array(input.buffer, input.byteOffset, input.byteLength)\n    }\n    throw new ImageError(`Expected binary image data, received ${typeof input}`, 'toBytes')\n}\n"],"mappings":";;;;;;;;;;;AAoBA,MAAa,yBAA4C,OAAO,OAAO;CACnE,GAAG;CACH,UAAU;CACV,WAAW;CACX,WAAW;CACX,YAAY;AAChB,CAAC;AAED,IAAa,cAAb,cAAiC,MAAyB;CACtD,OAAgB;CAEhB,YAAY,UAAsC,CAAC,GAAG;EAClD,MAAM,cAAc,wBAAwB,OAAO,CAAC;CACxD;CAEA,MAAgB,MAAM,OAAgB,KAAiC;EACnE,MAAM,OAAO,QAAQ,KAAK;EAC1B,IAAI,KAAK,eAAe,GACpB,MAAM,IAAI,WAAW,oBAAoB,KAAK,IAAI;EAEtD,MAAM,EAAE,OAAO,WAAW,MAAM,eAAe,IAAI;EACnD,OAAO,YAAY;GACf,MAAM,OAAO,IAAI,KAAK,OAAO,YAAY,QAAQ;GACjD,YAAY,OAAO,IAAI,cAAc,KAAK,OAAO,UAAU,KAAK;GAChE;GACA,WAAW,KAAK,OAAO;GACvB;GACA;EACJ,CAAC;CACL;CAEA,QAAkB,SAAiB,KAAwB;EACvD,OAAO,YAAY;GACf,MAAM,OAAO,IAAI,KAAK,OAAO,YAAY,QAAQ;GACjD,WAAW;EACf,CAAC;CACL;AACJ;;AAGA,SAAgB,QAAQ,OAA4B;CAChD,IAAI,iBAAiB,YAAY,OAAO;CACxC,IAAI,iBAAiB,aAAa,OAAO,IAAI,WAAW,KAAK;CAC7D,IAAI,YAAY,OAAO,KAAK,GACxB,OAAO,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;CAE1E,MAAM,IAAI,WAAW,wCAAwC,OAAO,SAAS,SAAS;AAC1F"}

package/dist/detect/index.d.ts

@@ -0,0 +1,71 @@
+import { l as Stage, m as BaseStageParams, s as Row } from "../pipeline-DeLO-OCE.js";
+import { t as DetectorOutput } from "../detector-output-C0Qt-jEq.js";
+//#region src/detect/yolo-onnx.d.ts
+/** Fallback when the graph declares a symbolic input size. */
+declare const DEFAULT_YOLO_INPUT = 960;
+interface YoloOnnxDetectorParams extends BaseStageParams {
+  model: string;
+  /** Class index -> label. An empty list falls back to `class_<n>`. */
+  labels: readonly string[];
+  scoreThreshold: number;
+  /** IoU above which two same-class boxes are considered duplicates. */
+  iouThreshold: number;
+  /** Grow each box by this fraction of its size, to avoid clipping edges. */
+  padding: number;
+  /** Emitted as DetectorOutput.type. */
+  outputType: string;
+}
+declare const YOLO_DETECTOR_DEFAULTS: YoloOnnxDetectorParams;
+interface Detection {
+  /** [x0, y0, x1, y1] in source-image coordinates. */
+  bbox: [number, number, number, number];
+  score: number;
+  classId: number;
+  label: string;
+}
+/** Axis-aligned IoU over xyxy boxes. */
+declare function iou(a: readonly number[], b: readonly number[]): number;
+/** Per-class non-maximum suppression; different classes never suppress each other. */
+declare function nonMaximumSuppression(detections: readonly Detection[], iouThreshold: number): Detection[];
+/**
+ * Decode a YOLO output tensor.
+ *
+ * Two layouts are handled, because exports differ:
+ *  - [1, 4 + numClasses, numAnchors] -- the classic v8/v11 transposed form,
+ *    with cx,cy,w,h then per-class scores.
+ *  - [1, numDetections, 6] -- an end-to-end NMS export: x0,y0,x1,y1,score,class.
+ */
+declare function decodeYoloOutput(data: Float32Array, dims: readonly number[], scoreThreshold: number): {
+  bbox: [number, number, number, number];
+  score: number;
+  classId: number;
+}[];
+declare class YoloOnnxDetector extends Stage<YoloOnnxDetectorParams> {
+  readonly name: string;
+  private session;
+  private loading;
+  private inputSize;
+  constructor(options?: Partial<YoloOnnxDetectorParams>);
+  init(): Promise<void>;
+  private getSession;
+  dispose(): Promise<void>;
+  protected apply(input: unknown, row: Row): Promise<DetectorOutput>;
+  /** Run the model over one decoded image, returning source-space detections. */
+  detect(source: ImageBitmap | OffscreenCanvas): Promise<Detection[]>;
+  protected onError(message: string, row: Row): DetectorOutput;
+}
+//#endregion
+//#region src/detect/index.d.ts
+/** Signature detection, mirroring ScaleDP's `SignatureDetector`. */
+declare class SignatureDetector extends YoloOnnxDetector {
+  readonly name = "SignatureDetector";
+  constructor(options?: Partial<YoloOnnxDetectorParams>);
+}
+/** Face detection, mirroring ScaleDP's `FaceDetector`. */
+declare class FaceDetector extends YoloOnnxDetector {
+  readonly name = "FaceDetector";
+  constructor(options?: Partial<YoloOnnxDetectorParams>);
+}
+//#endregion
+export { DEFAULT_YOLO_INPUT, type Detection, FaceDetector, SignatureDetector, YOLO_DETECTOR_DEFAULTS, YoloOnnxDetector, type YoloOnnxDetectorParams, decodeYoloOutput, iou, nonMaximumSuppression };
+//# sourceMappingURL=index.d.ts.map

package/dist/detect/index.js

@@ -0,0 +1,2 @@
+import { a as YoloOnnxDetector, c as nonMaximumSuppression, i as YOLO_DETECTOR_DEFAULTS, n as SignatureDetector, o as decodeYoloOutput, r as DEFAULT_YOLO_INPUT, s as iou, t as FaceDetector } from "../detect-q8AI_Jdj.js";
+export { DEFAULT_YOLO_INPUT, FaceDetector, SignatureDetector, YOLO_DETECTOR_DEFAULTS, YoloOnnxDetector, decodeYoloOutput, iou, nonMaximumSuppression };