@discretion/core 0.1.0

package/dist/src/ner/merge.js

@@ -0,0 +1,108 @@
+/**
+ * merge.ts — decode per-token BIO labels into entity spans.
+ *
+ * Handles BOTH tagging conventions the candidate models use:
+ *  • IOB2 (mBERT/distilmBERT NER-HRL): entities start with B-X.
+ *  • IOB1 (XLM-R CoNLL fine-tunes): entities may start with I-X after O
+ *    or at sequence start; B-X appears only to split adjacent same-type
+ *    entities.
+ * Decoding rule that satisfies both: a token starts a NEW entity when its
+ * label is B-X, or when it is I-X and the previous token was not part of
+ * an X entity. Same-type I-X continues; any other label ends the entity.
+ *
+ * Unlocated pieces ([UNK] and friends) inside an entity are BRIDGED: the
+ * entity's span runs from its first located piece to its last located
+ * piece. An entity with no located piece at all is dropped — emitting a
+ * guessed span would violate the exact-offsets contract.
+ *
+ * The entity score is the MINIMUM token score — one uncertain token makes
+ * the whole span uncertain. Scores are uncalibrated model softmax until
+ * Stage 4 (M8) calibrates; the eval buckets measure what they are worth.
+ */
+/** Model label suffix → Discretion entity type. MISC and friends drop. */
+const DEFAULT_LABEL_TYPES = {
+    PER: 'PERSON',
+    PERSON: 'PERSON',
+    ORG: 'ORG',
+    LOC: 'LOCATION',
+    LOCATION: 'LOCATION',
+    GPE: 'LOCATION',
+};
+function labelParts(label) {
+    if (label === 'O' || label === '')
+        return { prefix: 'O' };
+    const dash = label.indexOf('-');
+    const prefix = label.slice(0, dash === -1 ? undefined : dash);
+    const suffix = dash === -1 ? label : label.slice(dash + 1);
+    const type = DEFAULT_LABEL_TYPES[suffix.toUpperCase()];
+    if ((prefix === 'B' || prefix === 'I') && type !== undefined) {
+        return { prefix, type };
+    }
+    return { prefix: 'O' };
+}
+/** Decode predictions + aligned spans into merged entity spans. */
+export function decodeEntities(text, predictions, aligned) {
+    const spans = [];
+    let open = null;
+    const close = () => {
+        if (open !== null && open.located && open.end > open.start) {
+            spans.push({
+                type: open.type,
+                start: open.start,
+                end: open.end,
+                text: text.slice(open.start, open.end),
+                score: open.score,
+            });
+        }
+        open = null;
+    };
+    for (let i = 0; i < predictions.length; i++) {
+        const pred = predictions[i];
+        const span = aligned[i];
+        if (span === undefined)
+            break; // defensive: prediction/alignment mismatch
+        const { prefix, type } = labelParts(pred.label);
+        if (prefix === 'O' || type === undefined) {
+            close();
+            continue;
+        }
+        const continues = open !== null && open.type === type && prefix === 'I';
+        if (continues && open !== null) {
+            if (span.located) {
+                if (!open.located)
+                    open.start = span.start; // first located piece
+                open.end = span.end;
+                open.located = true;
+            }
+            open.score = Math.min(open.score, pred.score);
+        }
+        else {
+            close();
+            open = {
+                type,
+                start: span.start,
+                end: span.end,
+                score: pred.score,
+                located: span.located,
+            };
+        }
+    }
+    close();
+    return spans.map(trimSpan(text)).filter((s) => s !== null);
+}
+/** Trim surrounding whitespace the model occasionally absorbs into a span. */
+function trimSpan(text) {
+    return (s) => {
+        let { start, end } = s;
+        while (start < end && /\s/.test(text[start]))
+            start += 1;
+        while (end > start && /\s/.test(text[end - 1]))
+            end -= 1;
+        if (end <= start)
+            return null;
+        if (start === s.start && end === s.end)
+            return s;
+        return { ...s, start, end, text: text.slice(start, end) };
+    };
+}
+//# sourceMappingURL=merge.js.map

package/dist/src/ner/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../../src/ner/merge.ts"],"names":[],"mappings":"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"}

package/dist/src/ner/runStage2.d.ts

@@ -0,0 +1,17 @@
+/**
+ * runStage2.ts — produce Stage 2 candidates in the pipeline's shared shape.
+ *
+ * Mirrors the Stage 1 runner's contract: detection runs on NORMALIZED text
+ * and every candidate carries its exact ORIGINAL span, resolved through the
+ * Stage 0 offset map with mapNormalizedSpan (never raw map indexing — see
+ * the M1 offset-map contract).
+ *
+ * rawConfidence is the model's softmax score, unchanged and explicitly
+ * uncalibrated — the eval measures what those scores are worth per bucket,
+ * and Stage 4 (M8) calibrates. Inventing a mapping here would launder an
+ * unmeasured number into a measured-looking one.
+ */
+import type { NormalizationResult } from '../types.js';
+import type { NerRecognizer, Stage2Candidate } from './types.js';
+export declare function runStage2(normalization: NormalizationResult, engine: NerRecognizer): Promise<Stage2Candidate[]>;
+//# sourceMappingURL=runStage2.d.ts.map

package/dist/src/ner/runStage2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runStage2.d.ts","sourceRoot":"","sources":["../../../src/ner/runStage2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAOjE,wBAAsB,SAAS,CAC7B,aAAa,EAAE,mBAAmB,EAClC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,eAAe,EAAE,CAAC,CAwB5B"}

package/dist/src/ner/runStage2.js

@@ -0,0 +1,43 @@
+/**
+ * runStage2.ts — produce Stage 2 candidates in the pipeline's shared shape.
+ *
+ * Mirrors the Stage 1 runner's contract: detection runs on NORMALIZED text
+ * and every candidate carries its exact ORIGINAL span, resolved through the
+ * Stage 0 offset map with mapNormalizedSpan (never raw map indexing — see
+ * the M1 offset-map contract).
+ *
+ * rawConfidence is the model's softmax score, unchanged and explicitly
+ * uncalibrated — the eval measures what those scores are worth per bucket,
+ * and Stage 4 (M8) calibrates. Inventing a mapping here would launder an
+ * unmeasured number into a measured-looking one.
+ */
+import { mapNormalizedSpan } from '../offsetMap.js';
+/** Collapse interior whitespace so trivial layout variants share a key. */
+function canonicalName(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+export async function runStage2(normalization, engine) {
+    const { normalizedText, offsetMap } = normalization;
+    const spans = await engine.recognize(normalizedText);
+    return spans.map((span) => {
+        const original = mapNormalizedSpan(offsetMap, span.start, span.end);
+        return {
+            text: span.text,
+            type: span.type,
+            start: span.start,
+            end: span.end,
+            originalStart: original.start,
+            originalEnd: original.end,
+            rawConfidence: span.score,
+            stage: 'stage2-ner',
+            detectorId: `ner:${engine.id}`,
+            sensitive: true,
+            canonical: canonicalName(span.text),
+            metadata: { model: engine.id },
+            // Carried rather than re-looked-up: the hit was computed where the
+            // gazetteers live, which may be a different process from this one.
+            ...(span.gazetteer === undefined ? {} : { gazetteer: span.gazetteer }),
+        };
+    });
+}
+//# sourceMappingURL=runStage2.js.map

package/dist/src/ner/runStage2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runStage2.js","sourceRoot":"","sources":["../../../src/ner/runStage2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGpD,2EAA2E;AAC3E,SAAS,aAAa,CAAC,IAAY;IACjC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;AAC1C,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,aAAkC,EAClC,MAAqB;IAErB,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,GAAG,aAAa,CAAC;IACpD,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IAErD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,MAAM,QAAQ,GAAG,iBAAiB,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QACpE,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,aAAa,EAAE,QAAQ,CAAC,KAAK;YAC7B,WAAW,EAAE,QAAQ,CAAC,GAAG;YACzB,aAAa,EAAE,IAAI,CAAC,KAAK;YACzB,KAAK,EAAE,YAAqB;YAC5B,UAAU,EAAE,OAAO,MAAM,CAAC,EAAE,EAAE;YAC9B,SAAS,EAAE,IAAI;YACf,SAAS,EAAE,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;YACnC,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE;YAC9B,mEAAmE;YACnE,mEAAmE;YACnE,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC;SACvE,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/src/ner/stage2b.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Stage 2b — gazetteer corroboration, attached to the spans it corroborates.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * WHY THIS FILE EXISTS, WHICH IS A CORRECTION RATHER THAN A NEW FEATURE
+ *
+ * SPEC.md places the gazetteers in STAGE 2: "Bundled compressed lookup sets,
+ * checked in parallel with the model." The lookup had drifted into Stage 3's
+ * scorer, where it ran as one context signal among many.
+ *
+ * That placement was invisible until the extension was built, and then it was
+ * expensive in a way nothing else made visible. Stage 3 runs in the CONTENT
+ * SCRIPT. Its scorer statically imported the gazetteer module, so 3.4 MB of
+ * base64 Bloom filters were linked into a bundle that is parsed on every page
+ * load of all three sites — to serve PERSON, ORG and LOCATION candidates,
+ * which only Stage 2 produces, and which cannot exist at all in a build with
+ * no model attached.
+ *
+ * Moving the lookup here is not a size optimisation. It restores the stage
+ * boundary SPEC drew, and the size follows from that: the gazetteers now live
+ * on the same side of the process boundary as the model, because they answer
+ * questions only the model can ask.
+ *
+ * BEHAVIOUR IS UNCHANGED, and that is checkable rather than asserted: no
+ * Stage 1 detector declares PERSON, ORG or LOCATION (31 types, verified by
+ * enumeration), so no Stage 1 candidate could ever have reached the lookup in
+ * Stage 3. The contribution Stage 3 emits is byte-identical; it is now built
+ * from a hit computed here instead of one computed there.
+ * ─────────────────────────────────────────────────────────────────────────
+ */
+import type { GazetteerType } from '../gazetteer/index.js';
+import type { NerEntityType, NerSpan } from './types.js';
+/**
+ * The model's label set and the gazetteer's are the same three types.
+ *
+ * Asserted at COMPILE time rather than guarded at run time. The obvious
+ * implementation calls `isGazetteerType(span.type)` before each lookup - but
+ * `NerSpan.type` is already exactly those three, so that branch can never be
+ * false. A check that cannot fail reads as a safety property and is not one;
+ * this fails the BUILD if either union ever gains a member the other lacks,
+ * which is the moment the guard would have started mattering.
+ */
+type MissingFromGazetteer = Exclude<NerEntityType, GazetteerType>;
+type MissingFromNer = Exclude<GazetteerType, NerEntityType>;
+export type Stage2bTypesAgree = [MissingFromGazetteer, MissingFromNer] extends [never, never] ? true : never;
+/**
+ * Attach gazetteer corroboration to each span.
+ *
+ * A miss attaches nothing rather than attaching an absent hit: "not in the
+ * gazetteer" is not evidence against a name — the sets are large but nowhere
+ * near complete — and a field distinguishing "looked and found nothing" from
+ * "did not look" would invite a caller to treat the first as a negative
+ * signal. `useGazetteers: false` and a genuine miss are meant to be
+ * indistinguishable downstream, because they justify the same conclusion:
+ * nothing was corroborated.
+ */
+export declare function attachGazetteerHits(spans: readonly NerSpan[]): NerSpan[];
+export {};
+//# sourceMappingURL=stage2b.d.ts.map

package/dist/src/ner/stage2b.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage2b.d.ts","sourceRoot":"","sources":["../../../src/ner/stage2b.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;;;;GASG;AACH,KAAK,oBAAoB,GAAG,OAAO,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;AAClE,KAAK,cAAc,GAAG,OAAO,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;AAI5D,MAAM,MAAM,iBAAiB,GAAG,CAAC,oBAAoB,EAAE,cAAc,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,GACzF,IAAI,GACJ,KAAK,CAAC;AAIV;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,CAKxE"}

package/dist/src/ner/stage2b.js

@@ -0,0 +1,51 @@
+/**
+ * Stage 2b — gazetteer corroboration, attached to the spans it corroborates.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * WHY THIS FILE EXISTS, WHICH IS A CORRECTION RATHER THAN A NEW FEATURE
+ *
+ * SPEC.md places the gazetteers in STAGE 2: "Bundled compressed lookup sets,
+ * checked in parallel with the model." The lookup had drifted into Stage 3's
+ * scorer, where it ran as one context signal among many.
+ *
+ * That placement was invisible until the extension was built, and then it was
+ * expensive in a way nothing else made visible. Stage 3 runs in the CONTENT
+ * SCRIPT. Its scorer statically imported the gazetteer module, so 3.4 MB of
+ * base64 Bloom filters were linked into a bundle that is parsed on every page
+ * load of all three sites — to serve PERSON, ORG and LOCATION candidates,
+ * which only Stage 2 produces, and which cannot exist at all in a build with
+ * no model attached.
+ *
+ * Moving the lookup here is not a size optimisation. It restores the stage
+ * boundary SPEC drew, and the size follows from that: the gazetteers now live
+ * on the same side of the process boundary as the model, because they answer
+ * questions only the model can ask.
+ *
+ * BEHAVIOUR IS UNCHANGED, and that is checkable rather than asserted: no
+ * Stage 1 detector declares PERSON, ORG or LOCATION (31 types, verified by
+ * enumeration), so no Stage 1 candidate could ever have reached the lookup in
+ * Stage 3. The contribution Stage 3 emits is byte-identical; it is now built
+ * from a hit computed here instead of one computed there.
+ * ─────────────────────────────────────────────────────────────────────────
+ */
+import { lookupGazetteer } from '../gazetteer/index.js';
+const _typesAgree = true;
+void _typesAgree;
+/**
+ * Attach gazetteer corroboration to each span.
+ *
+ * A miss attaches nothing rather than attaching an absent hit: "not in the
+ * gazetteer" is not evidence against a name — the sets are large but nowhere
+ * near complete — and a field distinguishing "looked and found nothing" from
+ * "did not look" would invite a caller to treat the first as a negative
+ * signal. `useGazetteers: false` and a genuine miss are meant to be
+ * indistinguishable downstream, because they justify the same conclusion:
+ * nothing was corroborated.
+ */
+export function attachGazetteerHits(spans) {
+    return spans.map((span) => {
+        const hit = lookupGazetteer(span.text, span.type);
+        return hit === undefined ? span : { ...span, gazetteer: hit };
+    });
+}
+//# sourceMappingURL=stage2b.js.map

package/dist/src/ner/stage2b.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage2b.js","sourceRoot":"","sources":["../../../src/ner/stage2b.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAsBxD,MAAM,WAAW,GAAsB,IAAI,CAAC;AAC5C,KAAK,WAAW,CAAC;AAEjB;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAyB;IAC3D,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAClD,OAAO,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;IAChE,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/src/ner/transformersClassifier.d.ts

@@ -0,0 +1,45 @@
+/**
+ * transformersClassifier.ts — the Transformers.js/ONNX-backed
+ * TokenClassifier. Runs identically in Node (onnxruntime-node) and in a
+ * browser Web Worker (onnxruntime-web/WASM); hosting it in a worker is the
+ * consumer's concern (extension, M9), which keeps this module free of any
+ * environment-specific API.
+ *
+ * ZERO NETWORK BY DEFAULT: remote model fetching is opt-in
+ * (`allowRemoteModels`), used only by build-time tooling (today the eval
+ * benchmark and CLI; the extension's bundling step at M9). Production
+ * consumers load from the bundled cache and never touch the network — the
+ * SPEC non-negotiable.
+ *
+ * This module is exported through the dedicated `./ner-transformers` entry
+ * point, NOT the package root, so consumers who never run Stage 2 never
+ * load the ONNX runtime.
+ */
+import type { TokenClassifier } from './types.js';
+export interface TransformersClassifierOptions {
+    /** HF repo id, e.g. 'Xenova/distilbert-base-multilingual-cased-ner-hrl'. */
+    readonly model: string;
+    /** Weight precision: 'fp32' | 'fp16' | 'q8' | 'int8' | 'uint8' | …. */
+    readonly dtype?: string;
+    /** Where model files live (bundle dir in production, cache in tooling). */
+    readonly cacheDir?: string;
+    /** Allow downloading missing models. Build-time tooling ONLY. */
+    readonly allowRemoteModels?: boolean;
+    /**
+     * Pinned repo revision (commit hash). HF commits are content-addressed,
+     * so a pinned revision pins the exact model bytes — the integrity story
+     * for build-time bundling. Default 'main' is acceptable only in
+     * exploratory tooling.
+     */
+    readonly revision?: string;
+    /** Short id for candidate metadata; defaults to model@dtype. */
+    readonly id?: string;
+    /**
+     * Per-window character budget. Default 400: the models' 512-token limit
+     * divided by the worst-case one-token-per-character ratio (CJK), with
+     * headroom for specials and subword expansion of unusual codepoints.
+     */
+    readonly maxInputChars?: number;
+}
+export declare function createTransformersClassifier(options: TransformersClassifierOptions): Promise<TokenClassifier>;
+//# sourceMappingURL=transformersClassifier.d.ts.map

package/dist/src/ner/transformersClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformersClassifier.d.ts","sourceRoot":"","sources":["../../../src/ner/transformersClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,YAAY,CAAC;AAEnE,MAAM,WAAW,6BAA6B;IAC5C,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAUD,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,eAAe,CAAC,CAqB1B"}

package/dist/src/ner/transformersClassifier.js

@@ -0,0 +1,40 @@
+/**
+ * transformersClassifier.ts — the Transformers.js/ONNX-backed
+ * TokenClassifier. Runs identically in Node (onnxruntime-node) and in a
+ * browser Web Worker (onnxruntime-web/WASM); hosting it in a worker is the
+ * consumer's concern (extension, M9), which keeps this module free of any
+ * environment-specific API.
+ *
+ * ZERO NETWORK BY DEFAULT: remote model fetching is opt-in
+ * (`allowRemoteModels`), used only by build-time tooling (today the eval
+ * benchmark and CLI; the extension's bundling step at M9). Production
+ * consumers load from the bundled cache and never touch the network — the
+ * SPEC non-negotiable.
+ *
+ * This module is exported through the dedicated `./ner-transformers` entry
+ * point, NOT the package root, so consumers who never run Stage 2 never
+ * load the ONNX runtime.
+ */
+import { env, pipeline } from '@huggingface/transformers';
+const DEFAULT_MAX_INPUT_CHARS = 400;
+export async function createTransformersClassifier(options) {
+    if (options.cacheDir !== undefined)
+        env.cacheDir = options.cacheDir;
+    env.allowRemoteModels = options.allowRemoteModels ?? false;
+    const dtype = options.dtype ?? 'q8';
+    const nerPipeline = await pipeline('token-classification', options.model, {
+        dtype: dtype, // the runtime validates; its literal union lags its own docs
+        ...(options.revision !== undefined ? { revision: options.revision } : {}),
+    });
+    const id = options.id ?? `${options.model.split('/').pop() ?? options.model}@${dtype}`;
+    const maxInputChars = options.maxInputChars ?? DEFAULT_MAX_INPUT_CHARS;
+    return {
+        id,
+        maxInputChars,
+        async classify(text) {
+            const raw = (await nerPipeline(text, { ignore_labels: [] }));
+            return raw.map((t) => ({ label: t.entity, score: t.score, piece: t.word }));
+        },
+    };
+}
+//# sourceMappingURL=transformersClassifier.js.map

package/dist/src/ner/transformersClassifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformersClassifier.js","sourceRoot":"","sources":["../../../src/ner/transformersClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAmC1D,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAEpC,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,OAAsC;IAEtC,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS;QAAE,GAAG,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IACpE,GAAG,CAAC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,IAAI,KAAK,CAAC;IAE3D,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC;IACpC,MAAM,WAAW,GAAG,MAAM,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC,KAAK,EAAE;QACxE,KAAK,EAAE,KAAc,EAAE,6DAA6D;QACpF,GAAG,CAAC,OAAO,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC1E,CAAC,CAAC;IAEH,MAAM,EAAE,GAAG,OAAO,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,OAAO,CAAC,KAAK,IAAI,KAAK,EAAE,CAAC;IACvF,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,uBAAuB,CAAC;IAEvE,OAAO;QACL,EAAE;QACF,aAAa;QACb,KAAK,CAAC,QAAQ,CAAC,IAAY;YACzB,MAAM,GAAG,GAAG,CAAC,MAAM,WAAW,CAAC,IAAI,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC,CAA8B,CAAC;YAC1F,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAC9E,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/src/ner/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Stage 2 (multilingual NER) — shared types.
+ *
+ * The model runtime is INJECTED behind `TokenClassifier`, so the pure parts
+ * of Stage 2 (piece→character alignment, BIO decoding, chunking, timeout
+ * discipline, candidate shaping) are testable without a model and the
+ * engine stays environment-agnostic. The Transformers.js-backed classifier
+ * lives in `transformersClassifier.ts`, exported through its own package
+ * entry point so that consumers who never run NER never load the runtime.
+ */
+import type { Stage1Candidate } from '../detect/types.js';
+import type { GazetteerHit } from '../gazetteer/index.js';
+/** One model token prediction, in input order, special tokens excluded. */
+export interface TokenPrediction {
+    /** Raw model label, e.g. 'B-PER', 'I-ORG', 'O'. */
+    readonly label: string;
+    /** Model softmax score for that label. */
+    readonly score: number;
+    /**
+     * The token's surface piece as the runtime reports it: WordPiece
+     * continuations keep their '##' prefix; SentencePiece markers ('▁') may
+     * or may not be present — the aligner handles both.
+     */
+    readonly piece: string;
+}
+/** The injected model runtime. */
+export interface TokenClassifier {
+    /** Identifies the model in candidate metadata, e.g. 'distilmbert-ner-hrl@q8'. */
+    readonly id: string;
+    /**
+     * Safe per-call input size in CHARACTERS. Text longer than this must be
+     * windowed by the caller: transformer runtimes silently truncate past
+     * their token limit, and silent truncation would be silent fail-open.
+     * The floor of one token per character (CJK) makes chars the safe unit.
+     */
+    readonly maxInputChars: number;
+    /** Classify one window of text. Pieces arrive in input order. */
+    classify(text: string): Promise<readonly TokenPrediction[]>;
+}
+export type NerEntityType = 'PERSON' | 'ORG' | 'LOCATION';
+/** A merged entity span in NORMALIZED-text coordinates. */
+export interface NerSpan {
+    readonly type: NerEntityType;
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+    /** Minimum token score across the entity — the conservative aggregate. */
+    readonly score: number;
+    /**
+     * Stage 2b corroboration, when the gazetteer knows this name.
+     *
+     * Attached HERE rather than looked up in Stage 3 because SPEC places the
+     * gazetteers in Stage 2 — "checked in parallel with the model" — and
+     * because the sets are only meaningful for the types the model produces.
+     * See ner/stage2b.ts for what that placement was costing.
+     *
+     * Absent on a miss. "Not in the gazetteer" is not evidence against a name.
+     */
+    readonly gazetteer?: GazetteerHit;
+}
+/**
+ * What Stage 2 needs from whatever performs recognition.
+ *
+ * An interface rather than the concrete `NerEngine` because the engine may not
+ * be in the same PROCESS as the pipeline. The extension runs the model in an
+ * offscreen document - a content script cannot compile WebAssembly under the
+ * host page's policy - so its Stage 2 is a proxy that forwards `recognize`
+ * across a message port and returns the spans that come back.
+ *
+ * Declared here, next to the span it returns, so that `runStage2` and
+ * `detect` can name it without importing `engine.ts`. That matters: engine.ts
+ * pulls in Stage 2b and therefore the gazetteers, and a value import of it
+ * from the pipeline would link 3.4 MB of Bloom filters into every bundle that
+ * runs detection, including the one that has no model at all.
+ */
+export interface NerRecognizer {
+    /** Model identity, recorded on every candidate this produces. */
+    readonly id: string;
+    /** Pay initialization cost before first real use. */
+    warmup(): Promise<void>;
+    /** Spans in the given text's own coordinates. */
+    recognize(text: string): Promise<NerSpan[]>;
+}
+/**
+ * Stage 2 candidates share Stage 1's shape (SPEC: one candidate contract
+ * for the whole pipeline), differing only in the stage tag.
+ */
+export interface Stage2Candidate extends Omit<Stage1Candidate, 'stage'> {
+    readonly stage: 'stage2-ner';
+    /** Stage 2b corroboration, carried through to Stage 3's scorer. */
+    readonly gazetteer?: GazetteerHit;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/ner/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/ner/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC9B,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,kCAAkC;AAClC,MAAM,WAAW,eAAe;IAC9B,iFAAiF;IACjF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC,CAAC;CAC7D;AAED,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,KAAK,GAAG,UAAU,CAAC;AAE1D,2DAA2D;AAC3D,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;;;;;OASG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,YAAY,CAAC;CACnC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,iDAAiD;IACjD,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CAC7C;AAED;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC;IACrE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,SAAS,CAAC,EAAE,YAAY,CAAC;CACnC"}

package/dist/src/ner/types.js

@@ -0,0 +1,12 @@
+/**
+ * Stage 2 (multilingual NER) — shared types.
+ *
+ * The model runtime is INJECTED behind `TokenClassifier`, so the pure parts
+ * of Stage 2 (piece→character alignment, BIO decoding, chunking, timeout
+ * discipline, candidate shaping) are testable without a model and the
+ * engine stays environment-agnostic. The Transformers.js-backed classifier
+ * lives in `transformersClassifier.ts`, exported through its own package
+ * entry point so that consumers who never run NER never load the runtime.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/ner/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/ner/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/src/normalization.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Stage 0 normalization: the composed transform pipeline.
+ *
+ * Order (each step optional via NormalizationOptions, all on by default):
+ *
+ *   1. strip invisibles      — zero-width & bidi controls are pure noise and
+ *                              interfere with everything downstream
+ *   2. NFKC (per grapheme)   — compatibility folding with an exact map
+ *   3. selective homoglyph   — fold ONLY script-anomalous characters
+ *      folding                 (see homoglyphFold.ts for the full rationale)
+ *   3b. NFKC again, only when folding changed something: a folded character
+ *       must compose with a following combining mark exactly as a native one
+ *       would (e.g. Cyrillic а + U+0301 → folded "a" + U+0301 → "á"),
+ *       otherwise normalizing already-normalized text would not be a no-op
+ *   4. whitespace/punct      — exotic spaces, dashes, quotes → ASCII forms
+ *
+ * Each transform independently produces { text, map }; the final offset map
+ * is the COMPOSITION of the per-stage maps (see offsetMap.ts for the map
+ * format and its invariants). Composing small verified maps is far easier to
+ * get right than building one map through four simultaneous transforms.
+ */
+import type { NormalizationOptions, NormalizationResult } from './types.js';
+export declare function normalize(text: string, options?: NormalizationOptions): NormalizationResult;
+//# sourceMappingURL=normalization.d.ts.map

package/dist/src/normalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalization.d.ts","sourceRoot":"","sources":["../../src/normalization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAwB,MAAM,YAAY,CAAC;AAelG,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,mBAAmB,CAkF3F"}

package/dist/src/normalization.js

@@ -0,0 +1,92 @@
+import { composeMaps, identityMap, buildReverseMap, mapNormalizedSpan, } from './offsetMap.js';
+import { detectScripts } from './scripts.js';
+import { stripInvisibles } from './transforms/stripInvisibles.js';
+import { nfkcByGrapheme } from './transforms/nfkc.js';
+import { foldHomoglyphs } from './transforms/homoglyphFold.js';
+import { normalizeWhitespacePunct } from './transforms/whitespacePunct.js';
+import { foldDigits } from './transforms/foldDigits.js';
+export function normalize(text, options) {
+    const opts = {
+        stripInvisibles: true,
+        nfkc: true,
+        homoglyphFold: true,
+        whitespacePunct: true,
+        foldDigits: true,
+        ...options,
+    };
+    /** The text after the transforms applied so far. */
+    let current = text;
+    /**
+     * Composed map: current index → ORIGINAL index. null means "identity so
+     * far" — kept symbolic so untouched text (the common case) never pays for
+     * map allocation or composition.
+     */
+    let cumulative = null;
+    const transformations = [];
+    const apply = (step) => {
+        const result = step(current);
+        if (result === null)
+            return false;
+        for (const change of result.changes) {
+            // The step reports ranges in ITS input's coordinates; map them back to
+            // original-text coordinates through the maps of the earlier steps.
+            // mapNormalizedSpan (not plain lookup) so a change inside an earlier
+            // expansion widens to the whole original cluster.
+            const span = cumulative
+                ? mapNormalizedSpan(cumulative, change.start, change.end)
+                : { start: change.start, end: change.end };
+            transformations.push({
+                kind: change.kind,
+                originalStart: span.start,
+                originalEnd: span.end,
+                original: text.slice(span.start, span.end),
+                replacement: change.after,
+            });
+        }
+        cumulative = cumulative ? composeMaps(cumulative, result.map) : result.map;
+        current = result.text;
+        return true;
+    };
+    // Per-cluster NFKC must run to a FIXPOINT: one pass's output can contain
+    // clusters that only became composable by being placed next to each other
+    // (the canonical case is Hangul compatibility jamo — ㅍ and ㅓ are separate
+    // clusters, normalize to the conjoining jamo ᄑ + ᅥ, and only THOSE form a
+    // single cluster that composes to 퍼 on the next look). One extra pass
+    // settles it in practice; the cap is a defensive bound, and the fuzz suite
+    // asserts both termination and idempotency.
+    const applyNfkcToFixpoint = () => {
+        for (let i = 0; i < 8 && apply(nfkcByGrapheme); i++) {
+            // apply() advanced the pipeline; loop until it reports no change.
+        }
+    };
+    if (opts.stripInvisibles)
+        apply(stripInvisibles);
+    if (opts.nfkc)
+        applyNfkcToFixpoint();
+    if (opts.homoglyphFold) {
+        const folded = apply(foldHomoglyphs);
+        // 3b — see the file header. Only needed when a fold actually happened,
+        // and only meaningful when the NFKC step is enabled at all.
+        if (folded && opts.nfkc)
+            applyNfkcToFixpoint();
+    }
+    if (opts.whitespacePunct)
+        apply(normalizeWhitespacePunct);
+    // Last, and after homoglyph folding on purpose: folding digits changes a
+    // token's script census, and doing it earlier would alter the
+    // dominant-script decision homoglyph folding depends on. ASCII digits are
+    // NFKC-stable, so no further normalization pass is owed.
+    if (opts.foldDigits)
+        apply(foldDigits);
+    const offsetMap = cumulative ?? identityMap(text.length);
+    return {
+        normalizedText: current,
+        offsetMap,
+        reverseMap: buildReverseMap(offsetMap, text.length),
+        scripts: detectScripts(current),
+        transformations,
+        originalLength: text.length,
+        normalizedLength: current.length,
+    };
+}
+//# sourceMappingURL=normalization.js.map