@doccloak/core 0.9.0 → 0.11.0

package/dist/dom/opc.js

@@ -0,0 +1,159 @@
+/**
+ * @doccloak/core/dom - shared OPC (Open Packaging Conventions) helpers (T110).
+ *
+ * Both .docx and .xlsx are OPC packages: a zip with XML parts, docProps
+ * metadata, relationship files and an optional thumbnail. The metadata
+ * scrubbing that is format-independent lives here so the xlsx module does not
+ * duplicate the docx module's logic. The docx module keeps its historical
+ * implementation untouched (behavior-preservation for existing callers); new
+ * code paths use these helpers.
+ */
+/** Parse one XML part from the zip; null when absent or malformed. */
+export async function readXmlPart(zip, path) {
+    const file = zip.file(path);
+    if (!file)
+        return null;
+    const xmlStr = await file.async('string');
+    const doc = new DOMParser().parseFromString(xmlStr, 'application/xml');
+    if (doc.getElementsByTagName('parsererror').length > 0)
+        return null;
+    return doc;
+}
+/** Serialize an XML document back into the zip at the given path. */
+export function writeXmlPart(zip, path, doc) {
+    zip.file(path, new XMLSerializer().serializeToString(doc));
+}
+/** Blank the text content of every element whose local name is in the set. */
+export function blankElementsByLocalName(doc, names) {
+    const all = doc.getElementsByTagName('*');
+    for (let i = 0; i < all.length; i++) {
+        if (names.has(all[i].localName))
+            all[i].textContent = '';
+    }
+}
+/**
+ * Replace every occurrence of each sensitive value (case-insensitive) in a
+ * string. A replacer function keeps '$' sequences in values/placeholders inert.
+ *
+ * Longer values are applied first so a name variant ("Kowalski") can never
+ * pre-empt the fuller form it is part of ("Jan Kowalski") and leave the rest
+ * of it behind. When the input is a URL (urlEncode), the percent-encoded form
+ * of each value is matched too, so "Jan%20Kowalski" in a hyperlink target is
+ * scrubbed as a whole.
+ */
+export function replaceSensitiveValues(input, valueReplacements, urlEncode) {
+    let result = input;
+    const ordered = [...valueReplacements]
+        .filter(({ value }) => value)
+        .sort((a, b) => b.value.length - a.value.length);
+    for (const { value, replacement } of ordered) {
+        const forms = [value];
+        if (urlEncode) {
+            const encoded = encodeURIComponent(value);
+            if (encoded !== value)
+                forms.push(encoded);
+        }
+        const pattern = forms.map((form) => form.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+        const substitute = urlEncode ? encodeURIComponent(replacement) : replacement;
+        result = result.replace(new RegExp(pattern, 'gi'), () => substitute);
+    }
+    return result;
+}
+/**
+ * Scrub the shared docProps parts:
+ * - core.xml: author identities and content-describing fields
+ * - app.xml: organization and template/path hints
+ * - custom.xml: every leaf value (property names/structure kept)
+ */
+export async function scrubDocPropsParts(zip) {
+    const core = await readXmlPart(zip, 'docProps/core.xml');
+    if (core) {
+        blankElementsByLocalName(core, new Set([
+            'creator', 'lastModifiedBy', 'title', 'subject', 'description', 'keywords', 'category',
+        ]));
+        writeXmlPart(zip, 'docProps/core.xml', core);
+    }
+    const app = await readXmlPart(zip, 'docProps/app.xml');
+    if (app) {
+        blankElementsByLocalName(app, new Set(['Company', 'Manager', 'HyperlinkBase', 'Template']));
+        writeXmlPart(zip, 'docProps/app.xml', app);
+    }
+    const custom = await readXmlPart(zip, 'docProps/custom.xml');
+    if (custom) {
+        const props = custom.getElementsByTagName('*');
+        for (let i = 0; i < props.length; i++) {
+            const el = props[i];
+            if (el.localName !== 'property' && el.childElementCount === 0 && (el.textContent ?? '') !== '') {
+                el.textContent = '';
+            }
+        }
+        writeXmlPart(zip, 'docProps/custom.xml', custom);
+    }
+}
+/**
+ * Remove the package thumbnail (a rendered image of page/sheet one leaks
+ * content wholesale) together with its package relationship and content-type
+ * override.
+ */
+export async function removePackageThumbnail(zip) {
+    const thumbnailPaths = [];
+    zip.forEach((relativePath) => {
+        if (/^docProps\/thumbnail\.[a-z]+$/i.test(relativePath)) {
+            thumbnailPaths.push(relativePath);
+        }
+    });
+    if (thumbnailPaths.length === 0)
+        return;
+    for (const path of thumbnailPaths)
+        zip.remove(path);
+    const rootRels = await readXmlPart(zip, '_rels/.rels');
+    if (rootRels) {
+        const relationships = rootRels.getElementsByTagName('Relationship');
+        for (let i = relationships.length - 1; i >= 0; i--) {
+            const type = relationships[i].getAttribute('Type') ?? '';
+            if (type.endsWith('/thumbnail')) {
+                relationships[i].parentNode?.removeChild(relationships[i]);
+            }
+        }
+        writeXmlPart(zip, '_rels/.rels', rootRels);
+    }
+    const contentTypes = await readXmlPart(zip, '[Content_Types].xml');
+    if (contentTypes) {
+        const overrides = contentTypes.getElementsByTagName('Override');
+        for (let i = overrides.length - 1; i >= 0; i--) {
+            const partName = overrides[i].getAttribute('PartName') ?? '';
+            if (thumbnailPaths.some((p) => partName === '/' + p)) {
+                overrides[i].parentNode?.removeChild(overrides[i]);
+            }
+        }
+        writeXmlPart(zip, '[Content_Types].xml', contentTypes);
+    }
+}
+/**
+ * Scrub external relationship targets (mailto:/https: hyperlinks keep the raw
+ * sensitive value even when the display text was redacted) in every .rels file
+ * matched by the given pattern.
+ */
+export async function scrubExternalRelTargets(zip, relsPattern, valueReplacements) {
+    const relsPaths = [];
+    zip.forEach((relativePath) => {
+        if (relsPattern.test(relativePath))
+            relsPaths.push(relativePath);
+    });
+    for (const relsPath of relsPaths.sort()) {
+        const rels = await readXmlPart(zip, relsPath);
+        if (!rels)
+            continue;
+        const relationships = rels.getElementsByTagName('Relationship');
+        for (let i = relationships.length - 1; i >= 0; i--) {
+            const rel = relationships[i];
+            if (rel.getAttribute('TargetMode') === 'External') {
+                const target = rel.getAttribute('Target') ?? '';
+                const scrubbed = replaceSensitiveValues(target, valueReplacements, true);
+                if (scrubbed !== target)
+                    rel.setAttribute('Target', scrubbed);
+            }
+        }
+        writeXmlPart(zip, relsPath, rels);
+    }
+}

package/dist/dom/xlsx.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @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 type { ValueReplacement } from '../docx.js';
+import type { TextNodeMapping } from './docx.js';
+interface XlsxContentPart {
+    path: string;
+    xmlDoc: Document;
+    textNodes: TextNodeMapping[];
+}
+/**
+ * Result of extracting text from an xlsx file. Mirrors DocxExtraction: a flat
+ * plain text plus a mapping from flat positions back to XML text elements, so
+ * detection offsets can be applied surgically without touching formatting.
+ */
+export interface XlsxExtraction {
+    /** Flat plain text: one line per string unit (shared string, cell, comment) */
+    plainText: string;
+    /** The JSZip instance for re-packaging */
+    zip: JSZip;
+    /** All text-bearing parts with their per-part node mappings */
+    contentParts: XlsxContentPart[];
+    /** All text node mappings across parts, in flat-text order */
+    textNodes: TextNodeMapping[];
+}
+/**
+ * Read a .xlsx file and extract its text content with position mapping.
+ */
+export declare function readXlsx(file: File): Promise<XlsxExtraction>;
+/**
+ * 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 declare function writeAnonymizedXlsx(extraction: XlsxExtraction, replacements: Array<{
+    start: number;
+    end: number;
+    replacement: string;
+}>, valueReplacements?: ValueReplacement[]): Promise<Blob>;
+/**
+ * Check if a file is a supported Excel workbook (.xlsx only; the legacy
+ * binary .xls format is not supported in phase 1).
+ */
+export declare function isExcelFile(filename: string): boolean;
+export {};

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)