@raeven-co/sether-ner 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# @raeven-co/sether-ner
+
+> Free-text NER redaction — **names, organisations, locations** — for
+> [Sether](https://www.npmjs.com/package/@raeven-co/sether). The part regex
+> can't do, shipped as a separate, lazy-loaded package so the core stays ~35 KB.
+
+The core Sether detectors catch *structured* PII (emails, cards, SSNs, keys) and
+*label-anchored* identity (`Name:`, `DOB:`). This package adds the hard part:
+unlabelled people, companies, and places in running prose — the thing a
+customer's own weekend build and the regex-only competitors can't replicate.
+
+## Why a separate package
+
+- The model + ONNX runtime is ~30 MB+. Keeping it out of the core means
+  `new Sether()` stays tiny and dependency-light.
+- NER is **async** and runs on **full outbound text** (the prompt you're about to
+  send), not the streaming response — so it's a different integration point than
+  the sync, chunk-boundary-safe core detectors. This package is honest about that.
+- `@huggingface/transformers` is an **optional peer dependency** — install it only
+  if you use the default model. Bring your own inferer (e.g. GLiNER) and you don't
+  need it at all.
+
+## Install
+
+```bash
+npm install @raeven-co/sether-ner @huggingface/transformers
+```
+
+## Use
+
+```ts
+import { Sether, redactSync, basicDetectors } from '@raeven-co/sether';
+import { createNerRedactor } from '@raeven-co/sether-ner';
+
+const sether = new Sether();
+const ner = createNerRedactor();          // Xenova/bert-base-NER, lazy-loaded on first call
+
+// Outbound path: NER first (names/orgs/locations), then structured PII — one vault.
+const { redacted } = await ner.redact(userPrompt, { vault: sether.vault });
+const safe = redactSync(redacted, { detectors: basicDetectors, vault: sether.vault });
+
+// Send `safe` to the LLM. On the reply, sether.restore() swaps BOTH token sets
+// back, because NER tokens use the same `<TYPE_uuid>` format the core restores.
+```
+
+NER tokens look like `<NAME_…>`, `<ORG_…>`, `<LOCATION_…>` and restore through the
+core's `restore()` / `createRestoreStream()` with no extra wiring.
+
+## Options
+
+```ts
+createNerRedactor({
+  model: 'Xenova/bert-base-NER',  // any transformers.js token-classification model
+  threshold: 0.6,                 // min confidence
+  labels: ['NAME', 'ORG'],        // restrict which types to redact
+  infer: myGlinerInferer,         // bring your own model / service / mock
+});
+```
+
+### Bring your own model (e.g. GLiNER)
+
+`infer` is `(text) => Promise<RawEntity[]>` where each entity has
+`{ entity_group, score, start, end }` (absolute char offsets). Map your model's
+output to that shape and the rest of the pipeline is identical — which also makes
+the whole redactor unit-testable without downloading a model.
+
+## Honest limitations
+
+- **First call is slow** — the model downloads (~30 MB+) and warms up. Call
+  `ner.warmup()` at boot. ONNX inference runs ~50% slower than PyTorch.
+- **Not on the streaming hot path.** NER is a batched forward pass; it runs on the
+  outbound prompt, not per-chunk on the response. Restoration of the response is
+  the core's job (sync, chunk-boundary-safe).
+- **Accuracy is model-bound.** `bert-base-NER` is solid for Western names/orgs;
+  multilingual and domain names need a better model (swap via `model`/`infer`).
+  We'd rather you know that than oversell it.
+
+## License
+
+MIT © Godfrey Lebo / Raeven, Inc.

package/dist/index.cjs

@@ -0,0 +1,148 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  NER_LABELS: () => NER_LABELS,
+  buildRedactor: () => buildRedactor,
+  createNerRedactor: () => createNerRedactor,
+  createTransformersInfer: () => createTransformersInfer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/redactor.ts
+var import_node_crypto = require("crypto");
+
+// src/types.ts
+var NER_LABELS = ["NAME", "ORG", "LOCATION"];
+
+// src/redactor.ts
+var LABEL_MAP = {
+  PER: "NAME",
+  PERSON: "NAME",
+  NAME: "NAME",
+  ORG: "ORG",
+  ORGANIZATION: "ORG",
+  ORGANISATION: "ORG",
+  LOC: "LOCATION",
+  LOCATION: "LOCATION",
+  GPE: "LOCATION"
+};
+function mapLabel(group) {
+  return LABEL_MAP[group.toUpperCase().replace(/^[BI]-/, "")] ?? null;
+}
+function buildRedactor(infer, options = {}) {
+  const threshold = options.threshold ?? 0.6;
+  const enabled = new Set(options.labels ?? NER_LABELS);
+  const uuid = options.uuid ?? import_node_crypto.randomUUID;
+  async function detect(text) {
+    if (!text.trim()) return [];
+    const raw = await infer(text);
+    return resolveOverlaps(toMatches(raw, text, threshold, enabled));
+  }
+  async function redact(text, opts) {
+    const matches = await detect(text);
+    if (matches.length === 0) return { redacted: text, matches };
+    let out = "";
+    let pos = 0;
+    for (const m of matches) {
+      out += text.slice(pos, m.start);
+      const token = `<${m.type}_${uuid()}>`;
+      opts.vault.set(token, m.value);
+      out += token;
+      pos = m.end;
+    }
+    out += text.slice(pos);
+    return { redacted: out, matches };
+  }
+  async function warmup() {
+    await infer("Warm up the model.");
+  }
+  return { detect, redact, warmup };
+}
+function toMatches(raw, text, threshold, enabled) {
+  const out = [];
+  for (const e of raw) {
+    if (e.score < threshold) continue;
+    if (e.start == null || e.end == null || e.end <= e.start) continue;
+    const type = mapLabel(e.entity_group);
+    if (!type || !enabled.has(type)) continue;
+    const value = text.slice(e.start, e.end);
+    if (!value.trim()) continue;
+    out.push({ type, value, start: e.start, end: e.end, score: e.score });
+  }
+  return out;
+}
+function resolveOverlaps(matches) {
+  matches.sort((a, b) => a.start - b.start || b.score - a.score || b.end - b.start - (a.end - a.start));
+  const out = [];
+  for (const m of matches) {
+    if (!out.some((o) => m.start < o.end && o.start < m.end)) out.push(m);
+  }
+  return out.sort((a, b) => a.start - b.start);
+}
+
+// src/infer.ts
+var dynamicImport = (specifier) => Function("s", "return import(s)")(specifier);
+function createTransformersInfer(options = {}) {
+  const model = options.model ?? "Xenova/bert-base-NER";
+  let pipePromise = null;
+  async function getPipe() {
+    if (!pipePromise) {
+      pipePromise = (async () => {
+        let mod;
+        try {
+          mod = await dynamicImport("@huggingface/transformers");
+        } catch {
+          throw new Error(
+            "@raeven-co/sether-ner: install the optional peer '@huggingface/transformers' to use the default model, or pass your own { infer } to createNerRedactor()."
+          );
+        }
+        return mod.pipeline("token-classification", model);
+      })();
+    }
+    return pipePromise;
+  }
+  return async (text) => {
+    const pipe = await getPipe();
+    const out = await pipe(text, { aggregation_strategy: "simple" });
+    return out.map((e) => ({
+      entity_group: e.entity_group ?? e.entity ?? "MISC",
+      score: typeof e.score === "number" ? e.score : 0,
+      start: e.start,
+      end: e.end,
+      word: e.word
+    }));
+  };
+}
+
+// src/index.ts
+function createNerRedactor(options = {}) {
+  const infer = options.infer ?? createTransformersInfer(options);
+  return buildRedactor(infer, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NER_LABELS,
+  buildRedactor,
+  createNerRedactor,
+  createTransformersInfer
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/redactor.ts","../src/types.ts","../src/infer.ts"],"sourcesContent":["import { buildRedactor } from './redactor.js';\nimport { createTransformersInfer } from './infer.js';\nimport type { NerOptions, NerRedactor } from './types.js';\n\n/**\n * Create a free-text NER redactor for names, organisations, and locations.\n *\n * ```ts\n * import { Sether, redactSync, basicDetectors } from '@raeven-co/sether';\n * import { createNerRedactor } from '@raeven-co/sether-ner';\n *\n * const sether = new Sether();\n * const ner = createNerRedactor();            // uses Xenova/bert-base-NER, lazy-loaded\n *\n * // Outbound: NER first (names/orgs/locations), then structured PII — same vault.\n * const { redacted } = await ner.redact(prompt, { vault: sether.vault });\n * const safe = redactSync(redacted, { detectors: basicDetectors, vault: sether.vault });\n * // ...send `safe` to the LLM. sether.restore() then swaps BOTH token sets back,\n * //    because NER tokens use the same `<TYPE_uuid>` format.\n * ```\n *\n * Pass `{ infer }` to use GLiNER or any other model. NER runs on the full\n * outbound text — not the streaming response.\n */\nexport function createNerRedactor(options: NerOptions = {}): NerRedactor {\n  const infer = options.infer ?? createTransformersInfer(options);\n  return buildRedactor(infer, options);\n}\n\nexport { buildRedactor } from './redactor.js';\nexport { createTransformersInfer } from './infer.js';\nexport { NER_LABELS } from './types.js';\nexport type {\n  NerLabel,\n  NerMatch,\n  NerOptions,\n  NerRedactor,\n  InferFn,\n  RawEntity,\n  VaultLike,\n  RedactResult,\n} from './types.js';\n","import { randomUUID } from 'node:crypto';\nimport {\n  NER_LABELS,\n  type InferFn,\n  type NerLabel,\n  type NerMatch,\n  type NerOptions,\n  type NerRedactor,\n  type RawEntity,\n  type RedactResult,\n  type VaultLike,\n} from './types.js';\n\n// Map model label groups (and B-/I- prefixes) to Sether's three NER types.\nconst LABEL_MAP: Record<string, NerLabel> = {\n  PER: 'NAME',\n  PERSON: 'NAME',\n  NAME: 'NAME',\n  ORG: 'ORG',\n  ORGANIZATION: 'ORG',\n  ORGANISATION: 'ORG',\n  LOC: 'LOCATION',\n  LOCATION: 'LOCATION',\n  GPE: 'LOCATION',\n};\n\nfunction mapLabel(group: string): NerLabel | null {\n  return LABEL_MAP[group.toUpperCase().replace(/^[BI]-/, '')] ?? null;\n}\n\n/**\n * Build a redactor from an injected inferer. This is the pure, model-free core —\n * fully unit-testable with a mock `infer`. The default model wiring lives in\n * index.ts so this module carries no heavy dependency.\n */\nexport function buildRedactor(infer: InferFn, options: NerOptions = {}): NerRedactor {\n  const threshold = options.threshold ?? 0.6;\n  const enabled = new Set<NerLabel>(options.labels ?? NER_LABELS);\n  const uuid = options.uuid ?? randomUUID;\n\n  async function detect(text: string): Promise<NerMatch[]> {\n    if (!text.trim()) return [];\n    const raw = await infer(text);\n    return resolveOverlaps(toMatches(raw, text, threshold, enabled));\n  }\n\n  async function redact(text: string, opts: { vault: VaultLike }): Promise<RedactResult> {\n    const matches = await detect(text);\n    if (matches.length === 0) return { redacted: text, matches };\n\n    let out = '';\n    let pos = 0;\n    for (const m of matches) {\n      out += text.slice(pos, m.start);\n      const token = `<${m.type}_${uuid()}>`;\n      opts.vault.set(token, m.value);\n      out += token;\n      pos = m.end;\n    }\n    out += text.slice(pos);\n    return { redacted: out, matches };\n  }\n\n  async function warmup(): Promise<void> {\n    await infer('Warm up the model.');\n  }\n\n  return { detect, redact, warmup };\n}\n\nfunction toMatches(raw: RawEntity[], text: string, threshold: number, enabled: Set<NerLabel>): NerMatch[] {\n  const out: NerMatch[] = [];\n  for (const e of raw) {\n    if (e.score < threshold) continue;\n    if (e.start == null || e.end == null || e.end <= e.start) continue;\n    const type = mapLabel(e.entity_group);\n    if (!type || !enabled.has(type)) continue;\n    const value = text.slice(e.start, e.end);\n    if (!value.trim()) continue;\n    out.push({ type, value, start: e.start, end: e.end, score: e.score });\n  }\n  return out;\n}\n\n// Keep the higher-score (then longer) match when spans overlap.\nfunction resolveOverlaps(matches: NerMatch[]): NerMatch[] {\n  matches.sort((a, b) => a.start - b.start || b.score - a.score || b.end - b.start - (a.end - a.start));\n  const out: NerMatch[] = [];\n  for (const m of matches) {\n    if (!out.some((o) => m.start < o.end && o.start < m.end)) out.push(m);\n  }\n  return out.sort((a, b) => a.start - b.start);\n}\n","export type NerLabel = 'NAME' | 'ORG' | 'LOCATION';\n\nexport const NER_LABELS: readonly NerLabel[] = ['NAME', 'ORG', 'LOCATION'];\n\n/**\n * A raw entity as produced by a token-classification pipeline\n * (transformers.js `aggregation_strategy: 'simple'`) or any compatible inferer.\n * Offsets are absolute char positions into the input; entities without offsets\n * are skipped (we never trust the reconstructed `word`, which can carry subword\n * artifacts — we always slice the original text by [start, end)).\n */\nexport interface RawEntity {\n  entity_group: string; // e.g. 'PER' | 'ORG' | 'LOC' | 'person' | 'organization'\n  score: number; // 0..1\n  start?: number;\n  end?: number;\n  word?: string;\n}\n\nexport type InferFn = (text: string) => Promise<RawEntity[]>;\n\nexport interface NerMatch {\n  type: NerLabel;\n  value: string;\n  start: number;\n  end: number;\n  score: number;\n}\n\n/** Minimal vault surface — structurally compatible with @raeven-co/sether's Vault. */\nexport interface VaultLike {\n  set(token: string, value: string): void;\n}\n\nexport interface NerOptions {\n  /** Model id for the default transformers.js inferer. Default: 'Xenova/bert-base-NER'. */\n  model?: string;\n  /** Minimum confidence to keep a match. Default: 0.6. */\n  threshold?: number;\n  /** Which entity types to redact. Default: NAME, ORG, LOCATION. */\n  labels?: readonly NerLabel[];\n  /** Inject a custom inferer (GLiNER, a remote service, or a test mock). */\n  infer?: InferFn;\n  /** Token id generator. Default: node:crypto randomUUID. */\n  uuid?: () => string;\n}\n\nexport interface RedactResult {\n  redacted: string;\n  matches: NerMatch[];\n}\n\nexport interface NerRedactor {\n  /** Detect names / organisations / locations in the text. */\n  detect(text: string): Promise<NerMatch[]>;\n  /**\n   * Redact entities into `<TYPE_uuid>` tokens (the same format @raeven-co/sether\n   * uses), storing originals in the vault so the core `restore()` swaps them back.\n   * Runs on the full OUTBOUND text — not the response byte-stream.\n   */\n  redact(text: string, opts: { vault: VaultLike }): Promise<RedactResult>;\n  /** Preload the model so the first real call isn't slow. */\n  warmup(): Promise<void>;\n}\n","import type { InferFn, NerOptions, RawEntity } from './types.js';\n\ntype Pipe = (text: string, opts: { aggregation_strategy: string }) => Promise<unknown>;\n\ninterface RawPipelineEntity {\n  entity_group?: string;\n  entity?: string;\n  score?: number;\n  start?: number;\n  end?: number;\n  word?: string;\n}\n\n// Hide the specifier from the bundler and the type-checker so\n// @huggingface/transformers stays a TRULY optional peer dependency — it's only\n// needed at runtime if the default inferer actually runs.\nconst dynamicImport = (specifier: string): Promise<unknown> =>\n  (Function('s', 'return import(s)') as (s: string) => Promise<unknown>)(specifier);\n\n/**\n * The default inferer: a lazy, memoized transformers.js token-classification\n * pipeline. The ~30 MB+ model is only fetched on first inference, so importing\n * this module stays cheap. Swap in GLiNER or a remote service by passing your\n * own `infer` to createNerRedactor().\n */\nexport function createTransformersInfer(options: NerOptions = {}): InferFn {\n  const model = options.model ?? 'Xenova/bert-base-NER';\n  let pipePromise: Promise<Pipe> | null = null;\n\n  async function getPipe(): Promise<Pipe> {\n    if (!pipePromise) {\n      pipePromise = (async () => {\n        let mod: { pipeline: (task: string, model: string) => Promise<Pipe> };\n        try {\n          mod = (await dynamicImport('@huggingface/transformers')) as typeof mod;\n        } catch {\n          throw new Error(\n            \"@raeven-co/sether-ner: install the optional peer '@huggingface/transformers' to use the default model, or pass your own { infer } to createNerRedactor().\",\n          );\n        }\n        return mod.pipeline('token-classification', model);\n      })();\n    }\n    return pipePromise;\n  }\n\n  return async (text: string): Promise<RawEntity[]> => {\n    const pipe = await getPipe();\n    const out = (await pipe(text, { aggregation_strategy: 'simple' })) as RawPipelineEntity[];\n    return out.map((e) => ({\n      entity_group: e.entity_group ?? e.entity ?? 'MISC',\n      score: typeof e.score === 'number' ? e.score : 0,\n      start: e.start,\n      end: e.end,\n      word: e.word,\n    }));\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,97 @@
+type NerLabel = 'NAME' | 'ORG' | 'LOCATION';
+declare const NER_LABELS: readonly NerLabel[];
+/**
+ * A raw entity as produced by a token-classification pipeline
+ * (transformers.js `aggregation_strategy: 'simple'`) or any compatible inferer.
+ * Offsets are absolute char positions into the input; entities without offsets
+ * are skipped (we never trust the reconstructed `word`, which can carry subword
+ * artifacts — we always slice the original text by [start, end)).
+ */
+interface RawEntity {
+    entity_group: string;
+    score: number;
+    start?: number;
+    end?: number;
+    word?: string;
+}
+type InferFn = (text: string) => Promise<RawEntity[]>;
+interface NerMatch {
+    type: NerLabel;
+    value: string;
+    start: number;
+    end: number;
+    score: number;
+}
+/** Minimal vault surface — structurally compatible with @raeven-co/sether's Vault. */
+interface VaultLike {
+    set(token: string, value: string): void;
+}
+interface NerOptions {
+    /** Model id for the default transformers.js inferer. Default: 'Xenova/bert-base-NER'. */
+    model?: string;
+    /** Minimum confidence to keep a match. Default: 0.6. */
+    threshold?: number;
+    /** Which entity types to redact. Default: NAME, ORG, LOCATION. */
+    labels?: readonly NerLabel[];
+    /** Inject a custom inferer (GLiNER, a remote service, or a test mock). */
+    infer?: InferFn;
+    /** Token id generator. Default: node:crypto randomUUID. */
+    uuid?: () => string;
+}
+interface RedactResult {
+    redacted: string;
+    matches: NerMatch[];
+}
+interface NerRedactor {
+    /** Detect names / organisations / locations in the text. */
+    detect(text: string): Promise<NerMatch[]>;
+    /**
+     * Redact entities into `<TYPE_uuid>` tokens (the same format @raeven-co/sether
+     * uses), storing originals in the vault so the core `restore()` swaps them back.
+     * Runs on the full OUTBOUND text — not the response byte-stream.
+     */
+    redact(text: string, opts: {
+        vault: VaultLike;
+    }): Promise<RedactResult>;
+    /** Preload the model so the first real call isn't slow. */
+    warmup(): Promise<void>;
+}
+
+/**
+ * Build a redactor from an injected inferer. This is the pure, model-free core —
+ * fully unit-testable with a mock `infer`. The default model wiring lives in
+ * index.ts so this module carries no heavy dependency.
+ */
+declare function buildRedactor(infer: InferFn, options?: NerOptions): NerRedactor;
+
+/**
+ * The default inferer: a lazy, memoized transformers.js token-classification
+ * pipeline. The ~30 MB+ model is only fetched on first inference, so importing
+ * this module stays cheap. Swap in GLiNER or a remote service by passing your
+ * own `infer` to createNerRedactor().
+ */
+declare function createTransformersInfer(options?: NerOptions): InferFn;
+
+/**
+ * Create a free-text NER redactor for names, organisations, and locations.
+ *
+ * ```ts
+ * import { Sether, redactSync, basicDetectors } from '@raeven-co/sether';
+ * import { createNerRedactor } from '@raeven-co/sether-ner';
+ *
+ * const sether = new Sether();
+ * const ner = createNerRedactor();            // uses Xenova/bert-base-NER, lazy-loaded
+ *
+ * // Outbound: NER first (names/orgs/locations), then structured PII — same vault.
+ * const { redacted } = await ner.redact(prompt, { vault: sether.vault });
+ * const safe = redactSync(redacted, { detectors: basicDetectors, vault: sether.vault });
+ * // ...send `safe` to the LLM. sether.restore() then swaps BOTH token sets back,
+ * //    because NER tokens use the same `<TYPE_uuid>` format.
+ * ```
+ *
+ * Pass `{ infer }` to use GLiNER or any other model. NER runs on the full
+ * outbound text — not the streaming response.
+ */
+declare function createNerRedactor(options?: NerOptions): NerRedactor;
+
+export { type InferFn, NER_LABELS, type NerLabel, type NerMatch, type NerOptions, type NerRedactor, type RawEntity, type RedactResult, type VaultLike, buildRedactor, createNerRedactor, createTransformersInfer };

package/dist/index.d.ts

@@ -0,0 +1,97 @@
+type NerLabel = 'NAME' | 'ORG' | 'LOCATION';
+declare const NER_LABELS: readonly NerLabel[];
+/**
+ * A raw entity as produced by a token-classification pipeline
+ * (transformers.js `aggregation_strategy: 'simple'`) or any compatible inferer.
+ * Offsets are absolute char positions into the input; entities without offsets
+ * are skipped (we never trust the reconstructed `word`, which can carry subword
+ * artifacts — we always slice the original text by [start, end)).
+ */
+interface RawEntity {
+    entity_group: string;
+    score: number;
+    start?: number;
+    end?: number;
+    word?: string;
+}
+type InferFn = (text: string) => Promise<RawEntity[]>;
+interface NerMatch {
+    type: NerLabel;
+    value: string;
+    start: number;
+    end: number;
+    score: number;
+}
+/** Minimal vault surface — structurally compatible with @raeven-co/sether's Vault. */
+interface VaultLike {
+    set(token: string, value: string): void;
+}
+interface NerOptions {
+    /** Model id for the default transformers.js inferer. Default: 'Xenova/bert-base-NER'. */
+    model?: string;
+    /** Minimum confidence to keep a match. Default: 0.6. */
+    threshold?: number;
+    /** Which entity types to redact. Default: NAME, ORG, LOCATION. */
+    labels?: readonly NerLabel[];
+    /** Inject a custom inferer (GLiNER, a remote service, or a test mock). */
+    infer?: InferFn;
+    /** Token id generator. Default: node:crypto randomUUID. */
+    uuid?: () => string;
+}
+interface RedactResult {
+    redacted: string;
+    matches: NerMatch[];
+}
+interface NerRedactor {
+    /** Detect names / organisations / locations in the text. */
+    detect(text: string): Promise<NerMatch[]>;
+    /**
+     * Redact entities into `<TYPE_uuid>` tokens (the same format @raeven-co/sether
+     * uses), storing originals in the vault so the core `restore()` swaps them back.
+     * Runs on the full OUTBOUND text — not the response byte-stream.
+     */
+    redact(text: string, opts: {
+        vault: VaultLike;
+    }): Promise<RedactResult>;
+    /** Preload the model so the first real call isn't slow. */
+    warmup(): Promise<void>;
+}
+
+/**
+ * Build a redactor from an injected inferer. This is the pure, model-free core —
+ * fully unit-testable with a mock `infer`. The default model wiring lives in
+ * index.ts so this module carries no heavy dependency.
+ */
+declare function buildRedactor(infer: InferFn, options?: NerOptions): NerRedactor;
+
+/**
+ * The default inferer: a lazy, memoized transformers.js token-classification
+ * pipeline. The ~30 MB+ model is only fetched on first inference, so importing
+ * this module stays cheap. Swap in GLiNER or a remote service by passing your
+ * own `infer` to createNerRedactor().
+ */
+declare function createTransformersInfer(options?: NerOptions): InferFn;
+
+/**
+ * Create a free-text NER redactor for names, organisations, and locations.
+ *
+ * ```ts
+ * import { Sether, redactSync, basicDetectors } from '@raeven-co/sether';
+ * import { createNerRedactor } from '@raeven-co/sether-ner';
+ *
+ * const sether = new Sether();
+ * const ner = createNerRedactor();            // uses Xenova/bert-base-NER, lazy-loaded
+ *
+ * // Outbound: NER first (names/orgs/locations), then structured PII — same vault.
+ * const { redacted } = await ner.redact(prompt, { vault: sether.vault });
+ * const safe = redactSync(redacted, { detectors: basicDetectors, vault: sether.vault });
+ * // ...send `safe` to the LLM. sether.restore() then swaps BOTH token sets back,
+ * //    because NER tokens use the same `<TYPE_uuid>` format.
+ * ```
+ *
+ * Pass `{ infer }` to use GLiNER or any other model. NER runs on the full
+ * outbound text — not the streaming response.
+ */
+declare function createNerRedactor(options?: NerOptions): NerRedactor;
+
+export { type InferFn, NER_LABELS, type NerLabel, type NerMatch, type NerOptions, type NerRedactor, type RawEntity, type RedactResult, type VaultLike, buildRedactor, createNerRedactor, createTransformersInfer };

package/dist/index.js

@@ -0,0 +1,118 @@
+// src/redactor.ts
+import { randomUUID } from "crypto";
+
+// src/types.ts
+var NER_LABELS = ["NAME", "ORG", "LOCATION"];
+
+// src/redactor.ts
+var LABEL_MAP = {
+  PER: "NAME",
+  PERSON: "NAME",
+  NAME: "NAME",
+  ORG: "ORG",
+  ORGANIZATION: "ORG",
+  ORGANISATION: "ORG",
+  LOC: "LOCATION",
+  LOCATION: "LOCATION",
+  GPE: "LOCATION"
+};
+function mapLabel(group) {
+  return LABEL_MAP[group.toUpperCase().replace(/^[BI]-/, "")] ?? null;
+}
+function buildRedactor(infer, options = {}) {
+  const threshold = options.threshold ?? 0.6;
+  const enabled = new Set(options.labels ?? NER_LABELS);
+  const uuid = options.uuid ?? randomUUID;
+  async function detect(text) {
+    if (!text.trim()) return [];
+    const raw = await infer(text);
+    return resolveOverlaps(toMatches(raw, text, threshold, enabled));
+  }
+  async function redact(text, opts) {
+    const matches = await detect(text);
+    if (matches.length === 0) return { redacted: text, matches };
+    let out = "";
+    let pos = 0;
+    for (const m of matches) {
+      out += text.slice(pos, m.start);
+      const token = `<${m.type}_${uuid()}>`;
+      opts.vault.set(token, m.value);
+      out += token;
+      pos = m.end;
+    }
+    out += text.slice(pos);
+    return { redacted: out, matches };
+  }
+  async function warmup() {
+    await infer("Warm up the model.");
+  }
+  return { detect, redact, warmup };
+}
+function toMatches(raw, text, threshold, enabled) {
+  const out = [];
+  for (const e of raw) {
+    if (e.score < threshold) continue;
+    if (e.start == null || e.end == null || e.end <= e.start) continue;
+    const type = mapLabel(e.entity_group);
+    if (!type || !enabled.has(type)) continue;
+    const value = text.slice(e.start, e.end);
+    if (!value.trim()) continue;
+    out.push({ type, value, start: e.start, end: e.end, score: e.score });
+  }
+  return out;
+}
+function resolveOverlaps(matches) {
+  matches.sort((a, b) => a.start - b.start || b.score - a.score || b.end - b.start - (a.end - a.start));
+  const out = [];
+  for (const m of matches) {
+    if (!out.some((o) => m.start < o.end && o.start < m.end)) out.push(m);
+  }
+  return out.sort((a, b) => a.start - b.start);
+}
+
+// src/infer.ts
+var dynamicImport = (specifier) => Function("s", "return import(s)")(specifier);
+function createTransformersInfer(options = {}) {
+  const model = options.model ?? "Xenova/bert-base-NER";
+  let pipePromise = null;
+  async function getPipe() {
+    if (!pipePromise) {
+      pipePromise = (async () => {
+        let mod;
+        try {
+          mod = await dynamicImport("@huggingface/transformers");
+        } catch {
+          throw new Error(
+            "@raeven-co/sether-ner: install the optional peer '@huggingface/transformers' to use the default model, or pass your own { infer } to createNerRedactor()."
+          );
+        }
+        return mod.pipeline("token-classification", model);
+      })();
+    }
+    return pipePromise;
+  }
+  return async (text) => {
+    const pipe = await getPipe();
+    const out = await pipe(text, { aggregation_strategy: "simple" });
+    return out.map((e) => ({
+      entity_group: e.entity_group ?? e.entity ?? "MISC",
+      score: typeof e.score === "number" ? e.score : 0,
+      start: e.start,
+      end: e.end,
+      word: e.word
+    }));
+  };
+}
+
+// src/index.ts
+function createNerRedactor(options = {}) {
+  const infer = options.infer ?? createTransformersInfer(options);
+  return buildRedactor(infer, options);
+}
+export {
+  NER_LABELS,
+  buildRedactor,
+  createNerRedactor,
+  createTransformersInfer
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/redactor.ts","../src/types.ts","../src/infer.ts","../src/index.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport {\n  NER_LABELS,\n  type InferFn,\n  type NerLabel,\n  type NerMatch,\n  type NerOptions,\n  type NerRedactor,\n  type RawEntity,\n  type RedactResult,\n  type VaultLike,\n} from './types.js';\n\n// Map model label groups (and B-/I- prefixes) to Sether's three NER types.\nconst LABEL_MAP: Record<string, NerLabel> = {\n  PER: 'NAME',\n  PERSON: 'NAME',\n  NAME: 'NAME',\n  ORG: 'ORG',\n  ORGANIZATION: 'ORG',\n  ORGANISATION: 'ORG',\n  LOC: 'LOCATION',\n  LOCATION: 'LOCATION',\n  GPE: 'LOCATION',\n};\n\nfunction mapLabel(group: string): NerLabel | null {\n  return LABEL_MAP[group.toUpperCase().replace(/^[BI]-/, '')] ?? null;\n}\n\n/**\n * Build a redactor from an injected inferer. This is the pure, model-free core —\n * fully unit-testable with a mock `infer`. The default model wiring lives in\n * index.ts so this module carries no heavy dependency.\n */\nexport function buildRedactor(infer: InferFn, options: NerOptions = {}): NerRedactor {\n  const threshold = options.threshold ?? 0.6;\n  const enabled = new Set<NerLabel>(options.labels ?? NER_LABELS);\n  const uuid = options.uuid ?? randomUUID;\n\n  async function detect(text: string): Promise<NerMatch[]> {\n    if (!text.trim()) return [];\n    const raw = await infer(text);\n    return resolveOverlaps(toMatches(raw, text, threshold, enabled));\n  }\n\n  async function redact(text: string, opts: { vault: VaultLike }): Promise<RedactResult> {\n    const matches = await detect(text);\n    if (matches.length === 0) return { redacted: text, matches };\n\n    let out = '';\n    let pos = 0;\n    for (const m of matches) {\n      out += text.slice(pos, m.start);\n      const token = `<${m.type}_${uuid()}>`;\n      opts.vault.set(token, m.value);\n      out += token;\n      pos = m.end;\n    }\n    out += text.slice(pos);\n    return { redacted: out, matches };\n  }\n\n  async function warmup(): Promise<void> {\n    await infer('Warm up the model.');\n  }\n\n  return { detect, redact, warmup };\n}\n\nfunction toMatches(raw: RawEntity[], text: string, threshold: number, enabled: Set<NerLabel>): NerMatch[] {\n  const out: NerMatch[] = [];\n  for (const e of raw) {\n    if (e.score < threshold) continue;\n    if (e.start == null || e.end == null || e.end <= e.start) continue;\n    const type = mapLabel(e.entity_group);\n    if (!type || !enabled.has(type)) continue;\n    const value = text.slice(e.start, e.end);\n    if (!value.trim()) continue;\n    out.push({ type, value, start: e.start, end: e.end, score: e.score });\n  }\n  return out;\n}\n\n// Keep the higher-score (then longer) match when spans overlap.\nfunction resolveOverlaps(matches: NerMatch[]): NerMatch[] {\n  matches.sort((a, b) => a.start - b.start || b.score - a.score || b.end - b.start - (a.end - a.start));\n  const out: NerMatch[] = [];\n  for (const m of matches) {\n    if (!out.some((o) => m.start < o.end && o.start < m.end)) out.push(m);\n  }\n  return out.sort((a, b) => a.start - b.start);\n}\n","export type NerLabel = 'NAME' | 'ORG' | 'LOCATION';\n\nexport const NER_LABELS: readonly NerLabel[] = ['NAME', 'ORG', 'LOCATION'];\n\n/**\n * A raw entity as produced by a token-classification pipeline\n * (transformers.js `aggregation_strategy: 'simple'`) or any compatible inferer.\n * Offsets are absolute char positions into the input; entities without offsets\n * are skipped (we never trust the reconstructed `word`, which can carry subword\n * artifacts — we always slice the original text by [start, end)).\n */\nexport interface RawEntity {\n  entity_group: string; // e.g. 'PER' | 'ORG' | 'LOC' | 'person' | 'organization'\n  score: number; // 0..1\n  start?: number;\n  end?: number;\n  word?: string;\n}\n\nexport type InferFn = (text: string) => Promise<RawEntity[]>;\n\nexport interface NerMatch {\n  type: NerLabel;\n  value: string;\n  start: number;\n  end: number;\n  score: number;\n}\n\n/** Minimal vault surface — structurally compatible with @raeven-co/sether's Vault. */\nexport interface VaultLike {\n  set(token: string, value: string): void;\n}\n\nexport interface NerOptions {\n  /** Model id for the default transformers.js inferer. Default: 'Xenova/bert-base-NER'. */\n  model?: string;\n  /** Minimum confidence to keep a match. Default: 0.6. */\n  threshold?: number;\n  /** Which entity types to redact. Default: NAME, ORG, LOCATION. */\n  labels?: readonly NerLabel[];\n  /** Inject a custom inferer (GLiNER, a remote service, or a test mock). */\n  infer?: InferFn;\n  /** Token id generator. Default: node:crypto randomUUID. */\n  uuid?: () => string;\n}\n\nexport interface RedactResult {\n  redacted: string;\n  matches: NerMatch[];\n}\n\nexport interface NerRedactor {\n  /** Detect names / organisations / locations in the text. */\n  detect(text: string): Promise<NerMatch[]>;\n  /**\n   * Redact entities into `<TYPE_uuid>` tokens (the same format @raeven-co/sether\n   * uses), storing originals in the vault so the core `restore()` swaps them back.\n   * Runs on the full OUTBOUND text — not the response byte-stream.\n   */\n  redact(text: string, opts: { vault: VaultLike }): Promise<RedactResult>;\n  /** Preload the model so the first real call isn't slow. */\n  warmup(): Promise<void>;\n}\n","import type { InferFn, NerOptions, RawEntity } from './types.js';\n\ntype Pipe = (text: string, opts: { aggregation_strategy: string }) => Promise<unknown>;\n\ninterface RawPipelineEntity {\n  entity_group?: string;\n  entity?: string;\n  score?: number;\n  start?: number;\n  end?: number;\n  word?: string;\n}\n\n// Hide the specifier from the bundler and the type-checker so\n// @huggingface/transformers stays a TRULY optional peer dependency — it's only\n// needed at runtime if the default inferer actually runs.\nconst dynamicImport = (specifier: string): Promise<unknown> =>\n  (Function('s', 'return import(s)') as (s: string) => Promise<unknown>)(specifier);\n\n/**\n * The default inferer: a lazy, memoized transformers.js token-classification\n * pipeline. The ~30 MB+ model is only fetched on first inference, so importing\n * this module stays cheap. Swap in GLiNER or a remote service by passing your\n * own `infer` to createNerRedactor().\n */\nexport function createTransformersInfer(options: NerOptions = {}): InferFn {\n  const model = options.model ?? 'Xenova/bert-base-NER';\n  let pipePromise: Promise<Pipe> | null = null;\n\n  async function getPipe(): Promise<Pipe> {\n    if (!pipePromise) {\n      pipePromise = (async () => {\n        let mod: { pipeline: (task: string, model: string) => Promise<Pipe> };\n        try {\n          mod = (await dynamicImport('@huggingface/transformers')) as typeof mod;\n        } catch {\n          throw new Error(\n            \"@raeven-co/sether-ner: install the optional peer '@huggingface/transformers' to use the default model, or pass your own { infer } to createNerRedactor().\",\n          );\n        }\n        return mod.pipeline('token-classification', model);\n      })();\n    }\n    return pipePromise;\n  }\n\n  return async (text: string): Promise<RawEntity[]> => {\n    const pipe = await getPipe();\n    const out = (await pipe(text, { aggregation_strategy: 'simple' })) as RawPipelineEntity[];\n    return out.map((e) => ({\n      entity_group: e.entity_group ?? e.entity ?? 'MISC',\n      score: typeof e.score === 'number' ? e.score : 0,\n      start: e.start,\n      end: e.end,\n      word: e.word,\n    }));\n  };\n}\n","import { buildRedactor } from './redactor.js';\nimport { createTransformersInfer } from './infer.js';\nimport type { NerOptions, NerRedactor } from './types.js';\n\n/**\n * Create a free-text NER redactor for names, organisations, and locations.\n *\n * ```ts\n * import { Sether, redactSync, basicDetectors } from '@raeven-co/sether';\n * import { createNerRedactor } from '@raeven-co/sether-ner';\n *\n * const sether = new Sether();\n * const ner = createNerRedactor();            // uses Xenova/bert-base-NER, lazy-loaded\n *\n * // Outbound: NER first (names/orgs/locations), then structured PII — same vault.\n * const { redacted } = await ner.redact(prompt, { vault: sether.vault });\n * const safe = redactSync(redacted, { detectors: basicDetectors, vault: sether.vault });\n * // ...send `safe` to the LLM. sether.restore() then swaps BOTH token sets back,\n * //    because NER tokens use the same `<TYPE_uuid>` format.\n * ```\n *\n * Pass `{ infer }` to use GLiNER or any other model. NER runs on the full\n * outbound text — not the streaming response.\n */\nexport function createNerRedactor(options: NerOptions = {}): NerRedactor {\n  const infer = options.infer ?? createTransformersInfer(options);\n  return buildRedactor(infer, options);\n}\n\nexport { buildRedactor } from './redactor.js';\nexport { createTransformersInfer } from './infer.js';\nexport { NER_LABELS } from './types.js';\nexport type {\n  NerLabel,\n  NerMatch,\n  NerOptions,\n  NerRedactor,\n  InferFn,\n  RawEntity,\n  VaultLike,\n  RedactResult,\n} from './types.js';\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@raeven-co/sether-ner",
+  "version": "0.1.0",
+  "description": "Free-text NER redaction (names, organisations, locations) for Sether. Lazy-loaded ONNX model via transformers.js. Tokens restore through @raeven-co/sether's vault.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "node test/redactor.test.mjs"
+  },
+  "keywords": ["pii", "ner", "redaction", "sether", "llm", "privacy", "onnx", "transformers", "gdpr"],
+  "author": "Godfrey Lebo <emorylebo@gmail.com> (Raeven, Inc.)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raeven-co/sether-ner.git"
+  },
+  "peerDependencies": {
+    "@huggingface/transformers": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@huggingface/transformers": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "esbuild": "^0.24.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}