@doccloak/core 0.9.0 → 0.10.0

package/dist/dom/xlsx.js

@@ -0,0 +1,280 @@
+/**
+ * @doccloak/core/dom - xlsx read/write (T110, file redaction phase 1).
+ *
+ * Minimal zip+XML implementation on the package's existing JSZip + DOMParser
+ * machinery (the same stack the docx module uses). SheetJS was considered and
+ * rejected at claim time: the community edition is Apache-2.0 but is a heavy
+ * dependency distributed outside npm since 0.18.x (vendor CDN), and DocCloak
+ * only needs string-cell rewriting, not formula evaluation or format
+ * conversion. The zip+XML path keeps the dependency surface unchanged.
+ *
+ * Text-bearing locations covered:
+ * - xl/sharedStrings.xml <si> entries (plain and rich-text runs, phonetic runs)
+ * - worksheet inline strings (<c t="inlineStr"><is>...)
+ * - worksheet cached formula string results (<c t="str"><v>)
+ * - worksheet header/footer definitions
+ * - legacy cell comments (xl/comments*.xml) and threaded comments
+ *
+ * Deliberately out of scope in phase 1 (documented for T-later): drawing/chart
+ * text parts (xl/drawings, xl/charts), data connection definitions
+ * (xl/connections.xml) and defined-name formulas. Metadata scrubbing follows
+ * the docx module's policy via the shared OPC helpers.
+ */
+import JSZip from 'jszip';
+import { applyTextReplacements } from "./docx.js";
+import { readXmlPart, writeXmlPart, scrubDocPropsParts, removePackageThumbnail, scrubExternalRelTargets, replaceSensitiveValues, } from "./opc.js";
+import { getFileExtension } from "./docx.js";
+const SS_NS = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+function isSpreadsheetEl(el, localName) {
+    return el.namespaceURI === SS_NS && el.localName === localName;
+}
+/** Collect descendant <t> elements (spreadsheet namespace) in document order. */
+function collectTextLeaves(root) {
+    const result = [];
+    const all = root.getElementsByTagName('*');
+    for (let i = 0; i < all.length; i++) {
+        if (isSpreadsheetEl(all[i], 't'))
+            result.push(all[i]);
+    }
+    return result;
+}
+/** String units in xl/sharedStrings.xml: one per <si>. */
+function sharedStringUnits(xmlDoc) {
+    const units = [];
+    const sis = xmlDoc.getElementsByTagNameNS(SS_NS, 'si');
+    for (let i = 0; i < sis.length; i++) {
+        units.push(collectTextLeaves(sis[i]));
+    }
+    return units;
+}
+const HEADER_FOOTER_NAMES = new Set([
+    'oddHeader', 'oddFooter', 'evenHeader', 'evenFooter', 'firstHeader', 'firstFooter',
+]);
+/**
+ * String units in a worksheet: inline-string cells, cached string formula
+ * results and header/footer definitions, in document order.
+ */
+function worksheetUnits(xmlDoc) {
+    const units = [];
+    const all = xmlDoc.getElementsByTagName('*');
+    for (let i = 0; i < all.length; i++) {
+        const el = all[i];
+        if (el.namespaceURI !== SS_NS)
+            continue;
+        if (el.localName === 'c') {
+            const type = el.getAttribute('t');
+            if (type === 'inlineStr') {
+                const leaves = collectTextLeaves(el);
+                if (leaves.length > 0)
+                    units.push(leaves);
+            }
+            else if (type === 'str') {
+                // Cached formula result; the <f> formula itself is scrubbed by value.
+                for (let c = 0; c < el.children.length; c++) {
+                    const child = el.children[c];
+                    if (isSpreadsheetEl(child, 'v'))
+                        units.push([child]);
+                }
+            }
+        }
+        else if (HEADER_FOOTER_NAMES.has(el.localName)) {
+            units.push([el]);
+        }
+    }
+    return units;
+}
+/**
+ * String units in a comments part. Legacy comments keep text in <t> leaves
+ * under each <comment><text>; threaded comments keep plain text in a <text>
+ * element (Microsoft threadedComments namespace, matched by local name).
+ */
+function commentUnits(xmlDoc) {
+    const units = [];
+    const root = xmlDoc.documentElement;
+    if (root.localName === 'comments') {
+        const texts = xmlDoc.getElementsByTagNameNS(SS_NS, 'text');
+        for (let i = 0; i < texts.length; i++) {
+            const leaves = collectTextLeaves(texts[i]);
+            if (leaves.length > 0)
+                units.push(leaves);
+        }
+    }
+    else {
+        // threadedComments (or any other vendor comments schema): plain-text
+        // <text> leaves, matched leniently by local name.
+        const all = xmlDoc.getElementsByTagName('*');
+        for (let i = 0; i < all.length; i++) {
+            const el = all[i];
+            if (el.localName === 'text' && el.childElementCount === 0) {
+                units.push([el]);
+            }
+        }
+    }
+    return units;
+}
+/**
+ * Read a .xlsx file and extract its text content with position mapping.
+ */
+export async function readXlsx(file) {
+    const arrayBuffer = await file.arrayBuffer();
+    const zip = await JSZip.loadAsync(arrayBuffer);
+    if (!zip.file('xl/workbook.xml')) {
+        throw new Error('Invalid .xlsx file: missing xl/workbook.xml');
+    }
+    // Deterministic part order so load-time and export-time extractions produce
+    // identical offsets: sharedStrings, then worksheets, then comment parts.
+    const worksheetPaths = [];
+    const commentPaths = [];
+    zip.forEach((relativePath) => {
+        if (/^xl\/worksheets\/[^/]+\.xml$/.test(relativePath)) {
+            worksheetPaths.push(relativePath);
+        }
+        else if (/^xl\/comments\d*\.xml$/.test(relativePath) ||
+            /^xl\/threadedComments\/[^/]+\.xml$/.test(relativePath)) {
+            commentPaths.push(relativePath);
+        }
+    });
+    worksheetPaths.sort();
+    commentPaths.sort();
+    const partPlans = [
+        { path: 'xl/sharedStrings.xml', unitsOf: sharedStringUnits },
+        ...worksheetPaths.map((path) => ({ path, unitsOf: worksheetUnits })),
+        ...commentPaths.map((path) => ({ path, unitsOf: commentUnits })),
+    ];
+    let flatText = '';
+    const contentParts = [];
+    for (const plan of partPlans) {
+        const xmlDoc = await readXmlPart(zip, plan.path);
+        if (!xmlDoc)
+            continue;
+        const textNodes = [];
+        for (const unit of plan.unitsOf(xmlDoc)) {
+            const nodes = [];
+            let unitLength = 0;
+            for (const element of unit) {
+                const text = element.textContent ?? '';
+                if (text.length === 0)
+                    continue;
+                nodes.push({ element, flatStart: unitLength, flatEnd: unitLength + text.length });
+                unitLength += text.length;
+            }
+            if (unitLength === 0)
+                continue;
+            const base = flatText.length === 0 ? 0 : flatText.length + 1;
+            if (flatText.length > 0)
+                flatText += '\n';
+            for (const node of nodes) {
+                node.flatStart += base;
+                node.flatEnd += base;
+                flatText += node.element.textContent ?? '';
+                textNodes.push(node);
+            }
+        }
+        contentParts.push({ path: plan.path, xmlDoc, textNodes });
+    }
+    return {
+        plainText: flatText,
+        zip,
+        contentParts,
+        textNodes: contentParts.flatMap((part) => part.textNodes),
+    };
+}
+/**
+ * Scrub identity-bearing attributes inside a worksheet or comments part:
+ * hyperlink display/tooltip strings, legacy comment author registry, and
+ * literal strings inside formulas (<f>), which offset replacement cannot
+ * reach because formulas are not part of the flat text.
+ */
+function sanitizeXlsxPart(xmlDoc, valueReplacements) {
+    const all = xmlDoc.getElementsByTagName('*');
+    for (let i = 0; i < all.length; i++) {
+        const el = all[i];
+        if (el.localName === 'hyperlink') {
+            for (const attr of ['display', 'tooltip', 'location']) {
+                const value = el.getAttribute(attr);
+                if (value)
+                    el.setAttribute(attr, replaceSensitiveValues(value, valueReplacements, false));
+            }
+        }
+        else if (isSpreadsheetEl(el, 'f')) {
+            const formula = el.textContent ?? '';
+            const scrubbed = replaceSensitiveValues(formula, valueReplacements, false);
+            if (scrubbed !== formula)
+                el.textContent = scrubbed;
+        }
+        else if (el.localName === 'author' && el.parentElement?.localName === 'authors') {
+            // Legacy comments author registry (indexes must stay stable)
+            el.textContent = 'Redacted';
+        }
+    }
+}
+/**
+ * Scrub metadata parts that survive text replacement untouched: docProps,
+ * the package thumbnail, the workbook's absolute-path fingerprint and
+ * file-sharing identity, the threaded-comment person registry, and external
+ * relationship targets (hyperlink mailto:/URLs).
+ */
+async function sanitizeXlsxMetadata(zip, valueReplacements) {
+    await scrubDocPropsParts(zip);
+    await removePackageThumbnail(zip);
+    // Workbook: x15ac:absPath records the full local path the file was saved
+    // from (user name, client folders); fileSharing records the reserving user.
+    const workbook = await readXmlPart(zip, 'xl/workbook.xml');
+    if (workbook) {
+        const all = workbook.getElementsByTagName('*');
+        const doomed = [];
+        for (let i = 0; i < all.length; i++) {
+            if (all[i].localName === 'absPath' || all[i].localName === 'fileSharing') {
+                doomed.push(all[i]);
+            }
+        }
+        for (const el of doomed)
+            el.parentNode?.removeChild(el);
+        writeXmlPart(zip, 'xl/workbook.xml', workbook);
+    }
+    // Threaded-comment person registry: display names and provider user ids
+    const personsPaths = [];
+    zip.forEach((relativePath) => {
+        if (/^xl\/persons\/[^/]+\.xml$/.test(relativePath))
+            personsPaths.push(relativePath);
+    });
+    for (const path of personsPaths.sort()) {
+        const persons = await readXmlPart(zip, path);
+        if (!persons)
+            continue;
+        const all = persons.getElementsByTagName('*');
+        for (let i = 0; i < all.length; i++) {
+            const attrs = all[i].attributes;
+            for (let a = 0; a < attrs.length; a++) {
+                if (attrs[a].localName === 'displayName' || attrs[a].localName === 'userId') {
+                    attrs[a].value = 'Redacted';
+                }
+            }
+        }
+        writeXmlPart(zip, path, persons);
+    }
+    await scrubExternalRelTargets(zip, /^xl\/(?:[^/]+\/)*_rels\/[^/]+\.rels$/, valueReplacements);
+}
+/**
+ * Apply text replacements to the xlsx XML, preserving formatting, then scrub
+ * metadata. Returns a new .xlsx file as a Blob; the input file is untouched.
+ */
+export async function writeAnonymizedXlsx(extraction, replacements, valueReplacements = []) {
+    applyTextReplacements(extraction.textNodes, replacements);
+    for (const part of extraction.contentParts) {
+        sanitizeXlsxPart(part.xmlDoc, valueReplacements);
+        writeXmlPart(extraction.zip, part.path, part.xmlDoc);
+    }
+    await sanitizeXlsxMetadata(extraction.zip, valueReplacements);
+    return extraction.zip.generateAsync({
+        type: 'blob',
+        mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    });
+}
+/**
+ * Check if a file is a supported Excel workbook (.xlsx only; the legacy
+ * binary .xls format is not supported in phase 1).
+ */
+export function isExcelFile(filename) {
+    return getFileExtension(filename) === 'xlsx';
+}

package/dist/engine.d.ts

@@ -16,7 +16,7 @@
 import type { CoreEnv, HardwareHints } from './env.js';
 import type { DetectedEntity, DetectionProvider } from './types.js';
 import { type RegexRegionId } from './regex/index.js';
-export type ProviderId = 'gliner' | 'bardsai';
+export type ProviderId = 'gliner' | 'gliner-base' | 'bardsai';
 export interface ProviderEntry {
     id: ProviderId;
     label: string;
@@ -72,10 +72,13 @@ export declare function defaultThresholdFor(id: ProviderId): number;
 export declare function clampThreshold(value: number): number;
 /**
  * Default-model heuristic for devices without a saved provider choice.
- * The BardS.ai model (~279 MB download, ~500+ MB peak RAM while loading)
- * routinely gets the tab killed on mobile browsers, so constrained devices
- * default to the lightweight GLiNER model (~65 MB). Hosts feed the hints
- * (userAgent/deviceMemory sniffing stays host-side).
+ * Large models (~200-500+ MB peak RAM while loading) routinely get the tab
+ * killed on mobile browsers, so constrained devices default to the
+ * lightweight GLiNER Small model (~83 MB). Desktop-class devices default
+ * to GLiNER PII Base (~197 MB, higher accuracy, zero-shot custom labels;
+ * T122 - previously BardS.ai, which stays selectable as legacy). A saved
+ * provider choice always wins over this heuristic (existing behavior).
+ * Hosts feed the hints (userAgent/deviceMemory sniffing stays host-side).
  */
 export declare function pickDefaultProvider(hardware?: HardwareHints): ProviderId;
 export declare function createEngine(env: CoreEnv, initial?: Partial<EngineSettings>, options?: EngineOptions): DocCloakEngine;

package/dist/engine.js

@@ -15,19 +15,25 @@
  */
 import { detectWithRegex, detectEntities } from "./pipeline.js";
 import { GlinerProvider } from "./providers/gliner.js";
+import { GlinerBaseProvider } from "./providers/gliner-base.js";
 import { BardsaiProvider } from "./providers/bardsai.js";
 import { REGEX_REGIONS } from "./regex/index.js";
 /** Catalog of the built-in providers (labels/descriptions shown by hosts). */
 export const PROVIDERS = [
     {
         id: 'gliner',
-        label: 'GLiNER PII Edge',
-        description: 'Lightweight, multi-language, supports custom labels (~65 MB)',
+        label: 'GLiNER PII Small',
+        description: 'Lightweight, multi-language, supports custom labels (~83 MB)',
+    },
+    {
+        id: 'gliner-base',
+        label: 'GLiNER PII Base',
+        description: 'May be better for English and dates, supports custom labels (~197 MB)',
     },
     {
         id: 'bardsai',
         label: 'BardS.ai EU PII',
-        description: '24 EU languages, 35 PII types, high accuracy (~279 MB)',
+        description: 'Best multilingual accuracy, 24+ EU languages, 35 PII types (~279 MB)',
     },
 ];
 // ── Settings ───────────────────────────────────────────────
@@ -53,16 +59,23 @@ export function clampThreshold(value) {
 }
 /**
  * Default-model heuristic for devices without a saved provider choice.
- * The BardS.ai model (~279 MB download, ~500+ MB peak RAM while loading)
- * routinely gets the tab killed on mobile browsers, so constrained devices
- * default to the lightweight GLiNER model (~65 MB). Hosts feed the hints
- * (userAgent/deviceMemory sniffing stays host-side).
+ * Large models (~200-500+ MB peak RAM while loading) routinely get the tab
+ * killed on mobile browsers, so constrained devices default to the
+ * lightweight GLiNER Small model (~83 MB). Desktop-class devices default
+ * to GLiNER PII Base (~197 MB, higher accuracy, zero-shot custom labels;
+ * T122 - previously BardS.ai, which stays selectable as legacy). A saved
+ * provider choice always wins over this heuristic (existing behavior).
+ * Hosts feed the hints (userAgent/deviceMemory sniffing stays host-side).
  */
 export function pickDefaultProvider(hardware) {
     if (hardware?.isMobile)
         return 'gliner';
     if (typeof hardware?.deviceMemoryGB === 'number' && hardware.deviceMemoryGB <= 4)
         return 'gliner';
+    // T127: the 2026-08 benchmark (documentation/model-comparison-2026-08.md)
+    // showed bardsai is the strongest and most uniform across languages, so it
+    // is the capable-device default again; gliner-base stays selectable as the
+    // English/dates/custom-labels alternative.
     return 'bardsai';
 }
 function isProviderId(value) {
@@ -78,6 +91,7 @@ function supportsCustomLabels(p) {
 export function createEngine(env, initial, options) {
     const factories = {
         gliner: (e) => new GlinerProvider(e),
+        'gliner-base': (e) => new GlinerBaseProvider(e),
         bardsai: (e) => new BardsaiProvider(e),
         ...options?.providers,
     };

package/dist/index.d.ts

@@ -14,6 +14,8 @@ export * from './doc.js';
 export { generateSurrogate, generateUniqueSurrogate, generateSessionSalt, sessionDayOffset, FAKE_EMAIL_DOMAINS, } from './surrogates.js';
 export type { SurrogateContext } from './surrogates.js';
 export { GlinerProvider, GLINER_MODEL_URL, GLINER_MODEL_REVISION, GLINER_MODEL_SHA256 } from './providers/gliner.js';
+export { GlinerBaseProvider, GLINER_BASE_MODEL_URL, GLINER_BASE_MODEL_REVISION, GLINER_BASE_MODEL_SHA256, GLINER_BASE_MAX_WIDTH, buildSpanIndices, decodeSpanLogits, } from './providers/gliner-base.js';
+export type { SpanIndices } from './providers/gliner-base.js';
 export { BardsaiProvider, BARDSAI_MODEL_URL, BARDSAI_MODEL_REVISION, BARDSAI_MODEL_SHA256 } 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';

package/dist/index.js

@@ -20,6 +20,9 @@ export { generateSurrogate, generateUniqueSurrogate, generateSessionSalt, sessio
 // T007: gliner provider
 export { GlinerProvider, GLINER_MODEL_URL, GLINER_MODEL_REVISION, GLINER_MODEL_SHA256 } from "./providers/gliner.js";
 // end T007
+// T122: gliner base provider (markerV0 span mode)
+export { GlinerBaseProvider, GLINER_BASE_MODEL_URL, GLINER_BASE_MODEL_REVISION, GLINER_BASE_MODEL_SHA256, GLINER_BASE_MAX_WIDTH, buildSpanIndices, decodeSpanLogits, } from "./providers/gliner-base.js";
+// end T122
 // T008: bardsai provider
 export { BardsaiProvider, BARDSAI_MODEL_URL, BARDSAI_MODEL_REVISION, BARDSAI_MODEL_SHA256 } from "./providers/bardsai.js";
 // end T008

package/dist/providers/bardsai.js

@@ -10,7 +10,10 @@
  * tokenizer all arrive through the injected CoreEnv. This module never touches
  * import.meta, caches, navigator or @huggingface/transformers directly.
  */
-import * as ort from 'onnxruntime-web';
+// ort 1.29: the /webgpu entry is the non-deprecated build (native WebGPU EP +
+// wasm fallback, asyncify binary). The bare entry resolves the deprecated JSEP
+// bundle whose wasm exceeds Cloudflare Pages' 25 MiB per-file limit.
+import * as ort from 'onnxruntime-web/webgpu';
 import { evictModelFromCache, fetchModelBlob, retryAsync } from "../model-loader.js";
 // ── Model config ──────────────────────────────────────────
 // Supply-chain pinning (T116): the model is fetched from an immutable
@@ -231,13 +234,11 @@ export class BardsaiProvider {
         }
         if (words.length === 0)
             return [];
-        // Tokenize full text once to count subtokens per word via ▁ prefix
+        // Tokenize full text once to count subtokens per word via ▁ prefix.
+        // transformers.js 4.x removed tokenizer.model.convert_ids_to_tokens;
+        // tokenize() returns the same SentencePiece token strings directly.
         onProgress?.(0);
-        const fullEncoded = await this.tokenizer(words.map((w) => w.word).join(' '), {
-            add_special_tokens: false,
-        });
-        const tokenIds = Array.from(fullEncoded.input_ids.data);
-        const tokenStrings = this.tokenizer.model.convert_ids_to_tokens(tokenIds.map(Number));
+        const tokenStrings = this.tokenizer.tokenize(words.map((w) => w.word).join(' '));
         // Count subtokens per word: ▁ prefix marks word boundaries (SentencePiece)
         const subtokenCounts = [];
         let currentCount = 0;
@@ -317,16 +318,15 @@ export class BardsaiProvider {
         const attentionMask = encoded.attention_mask.data;
         const seqLen = encoded.input_ids.dims[1];
         // Build word→subtoken alignment via ▁ prefix (no per-word tokenization needed)
-        const chunkTokenIds = Array.from(inputIds);
-        const chunkTokenStrings = this.tokenizer.model.convert_ids_to_tokens(chunkTokenIds.map(Number));
+        // transformers.js 4.x removed tokenizer.model.convert_ids_to_tokens;
+        // tokenize() returns the token strings without specials, so positions are
+        // offset by 1 for the leading <s> in the encoded sequence and the seqLen
+        // guard stops at the truncation boundary.
+        const chunkTokenStrings = this.tokenizer.tokenize(chunkText);
         const wordSubtokenStart = [];
-        // Skip <s> at position 0; first real token at position 1
-        for (let t = 1; t < seqLen - 1; t++) {
-            const tok = chunkTokenStrings[t];
-            if (!tok || tok === '</s>')
-                break;
-            if (tok.startsWith('\u2581')) {
-                wordSubtokenStart.push(t);
+        for (let i = 0; i < chunkTokenStrings.length && i + 1 < seqLen - 1; i++) {
+            if (chunkTokenStrings[i].startsWith('\u2581')) {
+                wordSubtokenStart.push(i + 1);
             }
         }
         // XLM-RoBERTa: only input_ids + attention_mask (no token_type_ids)

package/dist/providers/gliner-base.d.ts

@@ -0,0 +1,92 @@
+/**
+ * GLiNER PII Base provider (T122).
+ *
+ * knowledgator/gliner-pii-base-v1.0: deberta-v3-small backbone, zero-shot
+ * custom labels, span_mode "markerV0". Unlike the token_level small/edge
+ * models (gliner.ts), the ONNX graph takes span enumeration inputs
+ * (span_idx + span_mask) and emits span-level logits shaped
+ * [batch, num_words, max_width, num_classes] - one score per candidate
+ * (start word, width) pair per label. Verified against the pinned model in
+ * Node WASM: inputs [input_ids, attention_mask, words_mask, text_lengths,
+ * span_idx (int64), span_mask (bool)], output [logits].
+ *
+ * Environment-agnostic: wasm paths, custom-label persistence (KV), model
+ * bytes (blob cache + fetch) and the tokenizer all arrive through the
+ * injected CoreEnv. This module never touches import.meta, localStorage,
+ * caches, navigator or @huggingface/transformers directly.
+ */
+import type { DetectedEntity, DetectionProvider, ProgressCallback } from '../types.js';
+import type { CoreEnv } from '../env.js';
+import type { ModelVerification } from '../model-loader.js';
+import { type RawSpan } from './gliner.js';
+export declare const GLINER_BASE_MODEL_REVISION = "61726e0ad791dcab3e29339bbec3ad42ded65641";
+/** SHA-256 of onnx/model_quint8.onnx (196,757,174 bytes) at GLINER_BASE_MODEL_REVISION. */
+export declare const GLINER_BASE_MODEL_SHA256 = "0514c8fd86d0513ce5351a3267f132b57d5bcd8f99a90d43cde1228092881d19";
+export declare const GLINER_BASE_MODEL_URL = "https://huggingface.co/knowledgator/gliner-pii-base-v1.0/resolve/61726e0ad791dcab3e29339bbec3ad42ded65641/onnx/model_quint8.onnx";
+/** max_width from the repo's gliner_config.json: spans cover 1..12 words. */
+export declare const GLINER_BASE_MAX_WIDTH = 12;
+export interface SpanIndices {
+    /** Flattened (start, end) word pairs, shape [1, numSpans, 2]. */
+    spanIdx: BigInt64Array;
+    /** 1 for valid spans (end < textLength), 0 for padding, shape [1, numSpans]. */
+    spanMask: Uint8Array;
+    numSpans: number;
+}
+/**
+ * Enumerate all candidate word spans exactly like the python GLiNER
+ * SpanProcessor: start-major, width-minor - for every start word i, the
+ * pairs (i, i+0) .. (i, i+maxWidth-1). Spans that would run past the end
+ * of the text are masked out and their indices zeroed (mirroring
+ * span_idx * span_mask in the python collate).
+ */
+export declare function buildSpanIndices(textLength: number, maxWidth?: number): SpanIndices;
+/**
+ * Decode markerV0 span logits (shape [1, numWords, maxWidth, numClasses])
+ * into raw character spans: sigmoid per (start, width, class) cell,
+ * threshold, then map word indices to character offsets. Non-overlap
+ * selection (greedySelect) happens at the caller across chunks.
+ */
+export declare function decodeSpanLogits(logits: Float32Array, dims: readonly number[], textLength: number, labels: string[], threshold: number, charStarts: number[], charEnds: number[], fullText: string): RawSpan[];
+export declare class GlinerBaseProvider implements DetectionProvider {
+    private _name;
+    get name(): string;
+    private env;
+    private tokenizer;
+    private session;
+    private loading;
+    private loadError;
+    private loadWaiters;
+    private progressCallback;
+    private threshold;
+    private customLabels;
+    private verification;
+    constructor(env: CoreEnv);
+    /**
+     * SHA-256 verification result of the served model blob (null until the
+     * model has been verified against the pinned hash). Surfaced so the
+     * model-status UI can show the positive "Model verified" state.
+     */
+    getVerification(): ModelVerification | null;
+    isLoaded(): boolean;
+    isLoading(): boolean;
+    onProgress(callback: ProgressCallback): void;
+    setThreshold(value: number): void;
+    getThreshold(): number;
+    /** Get the combined list of all active labels (built-in + custom). */
+    private getActiveLabels;
+    /** Get user-defined custom labels. */
+    getCustomLabels(): string[];
+    /**
+     * Set custom labels and persist through the injected KV store. The
+     * in-memory list updates synchronously (before the first await), so
+     * fire-and-forget callers keep the previous behavior.
+     */
+    setCustomLabels(labels: string[]): Promise<void>;
+    /** Restore custom labels from the injected KV store on startup. */
+    restoreCustomLabels(): Promise<void>;
+    load(): Promise<void>;
+    release(): void;
+    detect(text: string, onProgress?: (progress: number) => void): Promise<DetectedEntity[]>;
+    private buildPromptTokens;
+    private inferChunk;
+}