@doccloak/core 0.8.0

package/dist/env.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @doccloak/core - environment abstraction.
+ *
+ * Every host (web app, MV3 extension, tests) supplies a CoreEnv describing how
+ * the engine talks to the outside world. Core code never touches localStorage,
+ * chrome.storage, caches, navigator or import.meta directly.
+ *
+ * Interfaces match architecture doc section 4.2 verbatim.
+ */
+/** Async key-value store for settings. Web: localStorage wrapper. Extension: chrome.storage.local. */
+export interface KVStore {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+}
+/** Blob cache for model files. Web + extension: Cache Storage. Tests: in-memory. */
+export interface BlobCache {
+    match(url: string): Promise<Blob | undefined>;
+    put(url: string, blob: Blob): Promise<boolean>;
+    delete(url: string): Promise<void>;
+}
+export interface HardwareHints {
+    deviceMemoryGB?: number;
+    isMobile?: boolean;
+}
+export interface CoreEnv {
+    kv: KVStore;
+    modelCache: BlobCache;
+    fetch: typeof fetch;
+    wasm: {
+        paths: string;
+        numThreads?: number;
+    };
+    loadTokenizer(hfModelId: string): Promise<unknown>;
+    hardware?: HardwareHints;
+    persistStorage?: () => Promise<boolean>;
+}
+/** In-memory KVStore for tests. */
+export declare function memoryKV(): KVStore;
+export interface MemoryBlobCacheOptions {
+    /**
+     * Simulated storage quota in bytes. A put whose blob would push the total
+     * stored size above this limit is refused (resolves false), mirroring the
+     * best-effort Cache Storage behavior on quota pressure. Unlimited if omitted.
+     */
+    maxBytes?: number;
+}
+/** In-memory BlobCache for tests, with an optional simulated quota. */
+export declare function memoryBlobCache(options?: MemoryBlobCacheOptions): BlobCache;

package/dist/env.js

@@ -0,0 +1,53 @@
+/**
+ * @doccloak/core - environment abstraction.
+ *
+ * Every host (web app, MV3 extension, tests) supplies a CoreEnv describing how
+ * the engine talks to the outside world. Core code never touches localStorage,
+ * chrome.storage, caches, navigator or import.meta directly.
+ *
+ * Interfaces match architecture doc section 4.2 verbatim.
+ */
+/** In-memory KVStore for tests. */
+export function memoryKV() {
+    const store = new Map();
+    return {
+        async get(key) {
+            return store.has(key) ? store.get(key) : null;
+        },
+        async set(key, value) {
+            store.set(key, value);
+        },
+        async remove(key) {
+            store.delete(key);
+        },
+    };
+}
+/** In-memory BlobCache for tests, with an optional simulated quota. */
+export function memoryBlobCache(options = {}) {
+    const { maxBytes } = options;
+    const store = new Map();
+    function usedBytes() {
+        let total = 0;
+        for (const blob of store.values())
+            total += blob.size;
+        return total;
+    }
+    return {
+        async match(url) {
+            return store.get(url);
+        },
+        async put(url, blob) {
+            if (maxBytes !== undefined) {
+                const existing = store.get(url);
+                const sizeAfter = usedBytes() - (existing?.size ?? 0) + blob.size;
+                if (sizeAfter > maxBytes)
+                    return false;
+            }
+            store.set(url, blob);
+            return true;
+        },
+        async delete(url) {
+            store.delete(url);
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @doccloak/core - public API surface.
+ */
+export type { KVStore, BlobCache, HardwareHints, CoreEnv, MemoryBlobCacheOptions, } from './env.js';
+export { memoryKV, memoryBlobCache } from './env.js';
+export declare const CORE_PACKAGE_NAME = "@doccloak/core";
+export { fetchModelBlob, evictModelFromCache, retryAsync } from './model-loader.js';
+export type { ModelLoaderEnv, DownloadProgress, FetchModelOptions } from './model-loader.js';
+export { ALL_REGEX_RULES, REGEX_REGIONS } from './regex/index.js';
+export type { RegexRule, PiiDomain, RegionCode, RegexRegionId } from './regex/index.js';
+export * from './types.js';
+export * from './session.js';
+export * from './doc.js';
+export { GlinerProvider } from './providers/gliner.js';
+export { BardsaiProvider } from './providers/bardsai.js';
+export { detectWithRegex, resolveOverlaps, filterFalsePositives, propagateEntities, detectEntities, } from './pipeline.js';
+export { createEngine, PROVIDERS, pickDefaultProvider, defaultThresholdFor, clampThreshold, ENGINE_SETTINGS_KEYS, } from './engine.js';
+export type { ProviderId, ProviderEntry, ProviderFactory, EngineOptions, EngineSettings, DocCloakEngine, } from './engine.js';
+export { serveEngine, connectEngine } from './worker-protocol.js';
+export type { PortLike, EngineClient, EngineRequest, EngineResponse, } from './worker-protocol.js';

package/dist/index.js

@@ -0,0 +1,29 @@
+/**
+ * @doccloak/core - public API surface.
+ */
+export { memoryKV, memoryBlobCache } from "./env.js";
+export const CORE_PACKAGE_NAME = '@doccloak/core';
+// T006: model loader
+export { fetchModelBlob, evictModelFromCache, retryAsync } from "./model-loader.js";
+// end T006
+// T004: regex rules (REGEX_REGIONS moved here from the web engine in T009)
+export { ALL_REGEX_RULES, REGEX_REGIONS } from "./regex/index.js";
+// end T004
+// T003: types / session / doc
+export * from "./types.js";
+export * from "./session.js";
+export * from "./doc.js";
+// end T003
+// T007: gliner provider
+export { GlinerProvider } from "./providers/gliner.js";
+// end T007
+// T008: bardsai provider
+export { BardsaiProvider } from "./providers/bardsai.js";
+// end T008
+// T005: pipeline
+export { detectWithRegex, resolveOverlaps, filterFalsePositives, propagateEntities, detectEntities, } from "./pipeline.js";
+// end T005
+// T009: engine assembly + worker protocol
+export { createEngine, PROVIDERS, pickDefaultProvider, defaultThresholdFor, clampThreshold, ENGINE_SETTINGS_KEYS, } from "./engine.js";
+export { serveEngine, connectEngine } from "./worker-protocol.js";
+// end T009

package/dist/model-loader.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared model download utility used by all detection providers.
+ *
+ * Designed for large downloads (65-280 MB) on unreliable connections,
+ * especially mobile networks:
+ * - Resumes interrupted downloads with HTTP Range requests instead of
+ *   restarting from zero.
+ * - Retries transient failures (network errors, stalls, 5xx) with
+ *   exponential backoff.
+ * - Aborts stalled connections via a watchdog so a dead socket surfaces
+ *   as a retryable error instead of hanging forever.
+ * - Throttles progress callbacks so the UI thread is not flooded with
+ *   thousands of postMessage/setState calls during the download.
+ * - Serves the model from the injected BlobCache when available and prefers
+ *   the cached (typically disk-backed) copy over the in-memory one to reduce
+ *   peak RAM, which matters on iOS Safari where large tabs get killed.
+ *
+ * Environment-agnostic: all host capabilities (blob cache, fetch, persistent
+ * storage request) are injected via ModelLoaderEnv. This module never touches
+ * caches, navigator or global fetch directly.
+ */
+import type { BlobCache } from './env.js';
+export type DownloadProgress = (downloaded: number, total: number) => void;
+/**
+ * Host capabilities the loader needs. Hosts pass the relevant slice of their
+ * CoreEnv (modelCache as cache, fetch, persistStorage).
+ */
+export interface ModelLoaderEnv {
+    /** Blob cache for downloaded models. Web/extension: Cache Storage adapter. Tests: memoryBlobCache. */
+    cache: BlobCache;
+    /** Network access. Injectable for tests and proxies. */
+    fetch: typeof fetch;
+    /** Best-effort persistent-storage request (navigator.storage.persist() on the web). */
+    persistStorage?: () => Promise<boolean>;
+}
+export interface FetchModelOptions {
+    maxAttempts?: number;
+    retryBaseDelayMs?: number;
+}
+/**
+ * Download a model with progress reporting, resume and retry.
+ * Returns a Blob (served from the injected cache when possible).
+ */
+export declare function fetchModelBlob(env: ModelLoaderEnv, url: string, onProgress?: DownloadProgress, options?: FetchModelOptions): Promise<Blob>;
+/**
+ * Remove a single model from the cache (e.g. when its URL changes).
+ */
+export declare function evictModelFromCache(env: ModelLoaderEnv, url: string): Promise<void>;
+/**
+ * Retry an async operation with exponential backoff. Used for the smaller
+ * companion downloads (tokenizer files) that go through libraries without
+ * their own retry handling - one dropped request on a flaky connection
+ * should not abort the whole model load.
+ */
+export declare function retryAsync<T>(operation: () => Promise<T>, label: string, options?: FetchModelOptions): Promise<T>;

package/dist/model-loader.js

@@ -0,0 +1,253 @@
+/**
+ * Shared model download utility used by all detection providers.
+ *
+ * Designed for large downloads (65-280 MB) on unreliable connections,
+ * especially mobile networks:
+ * - Resumes interrupted downloads with HTTP Range requests instead of
+ *   restarting from zero.
+ * - Retries transient failures (network errors, stalls, 5xx) with
+ *   exponential backoff.
+ * - Aborts stalled connections via a watchdog so a dead socket surfaces
+ *   as a retryable error instead of hanging forever.
+ * - Throttles progress callbacks so the UI thread is not flooded with
+ *   thousands of postMessage/setState calls during the download.
+ * - Serves the model from the injected BlobCache when available and prefers
+ *   the cached (typically disk-backed) copy over the in-memory one to reduce
+ *   peak RAM, which matters on iOS Safari where large tabs get killed.
+ *
+ * Environment-agnostic: all host capabilities (blob cache, fetch, persistent
+ * storage request) are injected via ModelLoaderEnv. This module never touches
+ * caches, navigator or global fetch directly.
+ */
+const MAX_ATTEMPTS = 4;
+const STALL_TIMEOUT_MS = 30000;
+const PROGRESS_INTERVAL_MS = 150;
+const RETRY_BASE_DELAY_MS = 1000;
+class HttpError extends Error {
+    constructor(status, url) {
+        super(`Failed to download model: HTTP ${status} (${url})`);
+        this.name = 'HttpError';
+        this.status = status;
+    }
+}
+function isRetryable(err) {
+    if (err instanceof HttpError) {
+        return err.status === 408 || err.status === 429 || err.status >= 500;
+    }
+    // AbortError comes from our stall watchdog; TypeError is fetch's generic
+    // network failure (connection reset, DNS, CORS transport error, ...).
+    if (err instanceof DOMException && err.name === 'AbortError')
+        return true;
+    if (err instanceof TypeError)
+        return true;
+    return false;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+let persistRequested = false;
+/**
+ * Best-effort request for persistent storage so the browser does not evict
+ * the cached model under storage pressure (common on mobile). Requested at
+ * most once per session, matching the previous web-only behavior.
+ */
+async function requestPersistentStorage(env) {
+    if (persistRequested || !env.persistStorage)
+        return;
+    persistRequested = true;
+    try {
+        await env.persistStorage();
+    }
+    catch { /* not supported or denied - caching still works, just evictable */ }
+}
+async function readFromCache(cache, url) {
+    try {
+        const cached = await cache.match(url);
+        if (cached)
+            return cached;
+    }
+    catch { /* corrupt entry or read failure - fall through to network */ }
+    return null;
+}
+/**
+ * Best-effort cache put - large models can exceed per-origin quota, which
+ * surfaces either as put() resolving false or as a thrown error depending on
+ * the adapter. Caching is an optimisation, not a correctness requirement.
+ */
+async function tryCachePut(cache, url, blob) {
+    try {
+        const stored = await cache.put(url, blob);
+        if (!stored) {
+            console.warn('[DocCloak] Model cache put refused (model still loaded in memory)');
+        }
+    }
+    catch (err) {
+        console.warn('[DocCloak] Model cache put failed (model still loaded in memory):', err);
+    }
+}
+/**
+ * One download attempt. Streams the body through onChunk. A watchdog aborts
+ * the request if no bytes arrive for STALL_TIMEOUT_MS, covering both the
+ * initial connection and mid-body stalls. onHeaders fires as soon as the
+ * response headers are parsed - before the body streams - so callers can
+ * report a correct total alongside per-chunk progress.
+ */
+async function downloadAttempt(fetchFn, url, offset, onChunk, onHeaders) {
+    const controller = new AbortController();
+    let watchdog = setTimeout(() => controller.abort(), STALL_TIMEOUT_MS);
+    const kickWatchdog = () => {
+        clearTimeout(watchdog);
+        watchdog = setTimeout(() => controller.abort(), STALL_TIMEOUT_MS);
+    };
+    try {
+        const headers = {};
+        if (offset > 0)
+            headers['Range'] = `bytes=${offset}-`;
+        const response = await fetchFn(url, { headers, signal: controller.signal });
+        kickWatchdog();
+        if (!response.ok)
+            throw new HttpError(response.status, url);
+        const resumed = response.status === 206;
+        let total = 0;
+        if (resumed) {
+            // Content-Range: bytes <start>-<end>/<total>
+            const contentRange = response.headers.get('content-range');
+            const match = contentRange?.match(/\/(\d+)\s*$/);
+            if (match)
+                total = parseInt(match[1], 10);
+        }
+        else {
+            const contentLength = response.headers.get('content-length');
+            if (contentLength)
+                total = parseInt(contentLength, 10);
+        }
+        onHeaders?.({ total, resumed });
+        if (!response.body) {
+            // No streaming support - read in one shot (no resume possible, but
+            // the retry loop still restarts from scratch on failure).
+            const buffer = await response.arrayBuffer();
+            onChunk(new Uint8Array(buffer));
+            return { total, resumed };
+        }
+        const reader = response.body.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            kickWatchdog();
+            onChunk(value);
+        }
+        return { total, resumed };
+    }
+    finally {
+        clearTimeout(watchdog);
+    }
+}
+/**
+ * Download a model with progress reporting, resume and retry.
+ * Returns a Blob (served from the injected cache when possible).
+ */
+export async function fetchModelBlob(env, url, onProgress, options) {
+    const maxAttempts = options?.maxAttempts ?? MAX_ATTEMPTS;
+    const retryBaseDelayMs = options?.retryBaseDelayMs ?? RETRY_BASE_DELAY_MS;
+    const cache = env.cache;
+    const cachedBlob = await readFromCache(cache, url);
+    if (cachedBlob) {
+        onProgress?.(cachedBlob.size, cachedBlob.size);
+        return cachedBlob;
+    }
+    await requestPersistentStorage(env);
+    let lastProgressAt = 0;
+    const reportProgress = (downloaded, total, force = false) => {
+        const now = Date.now();
+        if (!force && now - lastProgressAt < PROGRESS_INTERVAL_MS)
+            return;
+        lastProgressAt = now;
+        onProgress?.(downloaded, total);
+    };
+    let chunks = [];
+    let downloaded = 0;
+    let total = 0;
+    for (let attempt = 1;; attempt++) {
+        try {
+            const requestedOffset = downloaded;
+            const result = await downloadAttempt(env.fetch, url, requestedOffset, (chunk) => {
+                chunks.push(chunk);
+                downloaded += chunk.length;
+                reportProgress(downloaded, total);
+            }, (info) => {
+                if (info.total > 0)
+                    total = info.resumed ? info.total : Math.max(total, info.total);
+            });
+            if (requestedOffset > 0 && !result.resumed) {
+                // Server ignored the Range header and sent the file from the start.
+                // The freshly received chunks already replace everything, but they
+                // were appended after the stale ones - rebuild keeping only bytes
+                // from this attempt.
+                const freshBytes = downloaded - requestedOffset;
+                const fresh = [];
+                let need = freshBytes;
+                for (let i = chunks.length - 1; i >= 0 && need > 0; i--) {
+                    fresh.unshift(chunks[i]);
+                    need -= chunks[i].length;
+                }
+                chunks = fresh;
+                downloaded = freshBytes;
+            }
+            if (result.total > 0)
+                total = result.resumed ? result.total : Math.max(total, result.total);
+            if (total > 0 && downloaded < total) {
+                // Connection closed early without an error. Treat as retryable.
+                throw new DOMException('Download ended before completion', 'AbortError');
+            }
+            break;
+        }
+        catch (err) {
+            if (!isRetryable(err) || attempt >= maxAttempts) {
+                throw err instanceof Error ? err : new Error(String(err));
+            }
+            console.warn(`[DocCloak] Model download interrupted at ${downloaded} bytes (attempt ${attempt}/${maxAttempts}), retrying...`, err);
+            await delay(retryBaseDelayMs * 2 ** (attempt - 1));
+        }
+    }
+    reportProgress(downloaded, total || downloaded, true);
+    let blob = new Blob(chunks);
+    chunks = [];
+    await tryCachePut(cache, url, blob);
+    // Prefer the cached (disk-backed) copy so the in-memory chunks can be
+    // collected before ONNX Runtime allocates its own copy of the model.
+    const diskBlob = await readFromCache(cache, url);
+    if (diskBlob && diskBlob.size === blob.size)
+        blob = diskBlob;
+    return blob;
+}
+/**
+ * Remove a single model from the cache (e.g. when its URL changes).
+ */
+export async function evictModelFromCache(env, url) {
+    try {
+        await env.cache.delete(url);
+    }
+    catch { /* ignore */ }
+}
+/**
+ * Retry an async operation with exponential backoff. Used for the smaller
+ * companion downloads (tokenizer files) that go through libraries without
+ * their own retry handling - one dropped request on a flaky connection
+ * should not abort the whole model load.
+ */
+export async function retryAsync(operation, label, options) {
+    const maxAttempts = options?.maxAttempts ?? MAX_ATTEMPTS;
+    const retryBaseDelayMs = options?.retryBaseDelayMs ?? RETRY_BASE_DELAY_MS;
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (err) {
+            if (attempt >= maxAttempts)
+                throw err;
+            console.warn(`[DocCloak] ${label} failed (attempt ${attempt}/${maxAttempts}), retrying...`, err);
+            await delay(retryBaseDelayMs * 2 ** (attempt - 1));
+        }
+    }
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pure entity pipeline (T005).
+ *
+ * Extracted verbatim from the web app's detection.worker.ts: text and
+ * entities in, entities out. No worker messaging, no providers, no
+ * environment access. The worker (and any other host) composes these
+ * functions around its own ML provider call.
+ *
+ * Function bodies are byte-identical to the originals by design; only the
+ * signatures of detectWithRegex (regexRegion becomes a parameter instead of
+ * worker module state) and detectEntities (ML results are passed in instead
+ * of fetched from a provider) differ.
+ */
+import type { DetectedEntity } from './types.js';
+export declare function detectWithRegex(text: string, regexRegion?: string): DetectedEntity[];
+export declare function resolveOverlaps(entities: DetectedEntity[]): DetectedEntity[];
+export declare function filterFalsePositives(entities: DetectedEntity[]): DetectedEntity[];
+export declare function propagateEntities(text: string, entities: DetectedEntity[]): DetectedEntity[];
+export declare function detectEntities(text: string, mlEntities: DetectedEntity[], regexEntities: DetectedEntity[]): DetectedEntity[];

package/dist/pipeline.js

@@ -0,0 +1,128 @@
+/**
+ * Pure entity pipeline (T005).
+ *
+ * Extracted verbatim from the web app's detection.worker.ts: text and
+ * entities in, entities out. No worker messaging, no providers, no
+ * environment access. The worker (and any other host) composes these
+ * functions around its own ML provider call.
+ *
+ * Function bodies are byte-identical to the originals by design; only the
+ * signatures of detectWithRegex (regexRegion becomes a parameter instead of
+ * worker module state) and detectEntities (ML results are passed in instead
+ * of fetched from a provider) differ.
+ */
+import { ALL_REGEX_RULES } from "./regex/index.js";
+export function detectWithRegex(text, regexRegion = 'all') {
+    const entities = [];
+    const rules = regexRegion === 'all'
+        ? ALL_REGEX_RULES
+        : ALL_REGEX_RULES.filter((r) => r.region === 'universal' || r.region === regexRegion);
+    for (const rule of rules) {
+        rule.pattern.lastIndex = 0;
+        let match;
+        while ((match = rule.pattern.exec(text)) !== null) {
+            if (rule.validate && !rule.validate(match[0]))
+                continue;
+            entities.push({
+                type: rule.type,
+                value: match[0],
+                start: match.index,
+                end: match.index + match[0].length,
+                confidence: rule.confidence,
+                detector: rule.detector,
+            });
+        }
+    }
+    return entities;
+}
+export function resolveOverlaps(entities) {
+    const sorted = [...entities].sort((a, b) => {
+        if (a.start !== b.start)
+            return a.start - b.start;
+        const aLen = a.end - a.start;
+        const bLen = b.end - b.start;
+        if (aLen !== bLen)
+            return bLen - aLen;
+        return b.confidence - a.confidence;
+    });
+    const resolved = [];
+    for (const entity of sorted) {
+        const overlaps = resolved.some((existing) => entity.start < existing.end && entity.end > existing.start);
+        if (!overlaps) {
+            resolved.push(entity);
+        }
+    }
+    return resolved;
+}
+export function filterFalsePositives(entities) {
+    return entities.filter((e) => {
+        if (e.value.trim().length < 3)
+            return false;
+        return true;
+    });
+}
+export function propagateEntities(text, entities) {
+    const propagated = [];
+    const seen = new Set();
+    for (const e of entities) {
+        seen.add(`${e.start}:${e.end}`);
+    }
+    const terms = [];
+    const addedTerms = new Set();
+    for (const e of entities) {
+        const val = e.value.trim();
+        if (val.length >= 3 && !addedTerms.has(val.toLowerCase())) {
+            addedTerms.add(val.toLowerCase());
+            terms.push({ term: val, type: e.type });
+        }
+        if (val.includes(' ')) {
+            for (const word of val.split(/\s+/)) {
+                const w = word.replace(/[.,;:!?()]+$/, '');
+                if (w.length >= 4 && !addedTerms.has(w.toLowerCase())) {
+                    addedTerms.add(w.toLowerCase());
+                    terms.push({ term: w, type: e.type });
+                }
+            }
+        }
+    }
+    for (const { term, type } of terms) {
+        let searchFrom = 0;
+        const lowerText = text.toLowerCase();
+        const lowerTerm = term.toLowerCase();
+        while (searchFrom < text.length) {
+            const idx = lowerText.indexOf(lowerTerm, searchFrom);
+            if (idx === -1)
+                break;
+            const end = idx + term.length;
+            const key = `${idx}:${end}`;
+            if (!seen.has(key)) {
+                const charBefore = idx > 0 ? text[idx - 1] : ' ';
+                const charAfter = end < text.length ? text[end] : ' ';
+                const isBoundaryBefore = /[\s.,;:!?()"'„"\-–—/]/.test(charBefore);
+                const isBoundaryAfter = /[\s.,;:!?()"'„"\-–—/]/.test(charAfter);
+                if (isBoundaryBefore && isBoundaryAfter) {
+                    seen.add(key);
+                    propagated.push({
+                        type,
+                        value: text.slice(idx, end),
+                        start: idx,
+                        end,
+                        confidence: 0.95,
+                        detector: 'propagated',
+                    });
+                }
+            }
+            searchFrom = idx + 1;
+        }
+    }
+    return propagated;
+}
+export function detectEntities(text, mlEntities, regexEntities) {
+    if (!text.trim())
+        return [];
+    const mlResults = filterFalsePositives(mlEntities);
+    const regexResults = regexEntities;
+    const initial = resolveOverlaps([...mlResults, ...regexResults]);
+    const propagated = propagateEntities(text, initial);
+    return resolveOverlaps([...initial, ...propagated]);
+}

package/dist/providers/bardsai.d.ts

@@ -0,0 +1,38 @@
+/**
+ * BardS.ai EU PII Anonymization Provider
+ *
+ * XLM-RoBERTa-base fine-tuned for EU PII detection (24 EU languages, natively multilingual).
+ * 35 entity types, ~0.3B parameters, quantized ONNX (~279 MB).
+ * Model: bardsai/eu-pii-anonimization-multilang
+ * Runs in-browser via ONNX Runtime WebAssembly.
+ *
+ * Environment-agnostic: wasm paths, model bytes (blob cache + fetch) and the
+ * tokenizer all arrive through the injected CoreEnv. This module never touches
+ * import.meta, caches, navigator or @huggingface/transformers directly.
+ */
+import type { DetectedEntity, DetectionProvider, ProgressCallback } from '../types.js';
+import type { CoreEnv } from '../env.js';
+export declare class BardsaiProvider implements DetectionProvider {
+    private _name;
+    get name(): string;
+    private readonly env;
+    private tokenizer;
+    private session;
+    private loading;
+    private loadError;
+    private loadWaiters;
+    private progressCallback;
+    private threshold;
+    constructor(env: CoreEnv);
+    isLoaded(): boolean;
+    isLoading(): boolean;
+    onProgress(callback: ProgressCallback): void;
+    setThreshold(value: number): void;
+    getThreshold(): number;
+    load(): Promise<void>;
+    release(): void;
+    detect(text: string, onProgress?: (progress: number) => void): Promise<DetectedEntity[]>;
+    private inferChunk;
+    private emitEntity;
+    private deduplicateSpans;
+}