gheim 0.1.4 → 0.1.5

package/dist/cjs/index.cjs

@@ -58,7 +58,8 @@ __export(exports_src, {
   LocalDetector: () => LocalDetector,
   LABEL_TO_TAG: () => LABEL_TO_TAG,
   DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
-  CompositeDetector: () => CompositeDetector
+  CompositeDetector: () => CompositeDetector,
+  CalibratedDetector: () => CalibratedDetector
 });
 module.exports = __toCommonJS(exports_src);
 
@@ -842,10 +843,281 @@ class CompositeDetector {
     return out;
   }
 }
+// src/detectors/calibrated.ts
+var DEFAULT_MODEL3 = "joelbarmettler/gheim-ch-560m";
+var DEFAULT_CHUNK_TOKENS2 = 510;
+var DEFAULT_OVERLAP_TOKENS2 = 32;
+function trimSpan2(text, start, end) {
+  while (start < end && /\s/.test(text[start] ?? ""))
+    start++;
+  while (end > start && /\s/.test(text[end - 1] ?? ""))
+    end--;
+  return [start, end];
+}
+
+class CalibratedDetector {
+  model;
+  oBias;
+  device;
+  dtype;
+  chunkTokens;
+  chunkOverlapTokens;
+  trimWhitespace;
+  actualDevice = null;
+  _model = null;
+  _tokenizer = null;
+  _id2label = {};
+  _oId = 0;
+  _loadPromise = null;
+  _onProgress;
+  constructor(opts = {}) {
+    this.model = opts.model ?? DEFAULT_MODEL3;
+    this.oBias = opts.oBias ?? 0.5;
+    this.device = opts.device ?? "auto";
+    this.dtype = opts.dtype ?? "fp32";
+    this.chunkTokens = opts.chunkTokens ?? DEFAULT_CHUNK_TOKENS2;
+    this.chunkOverlapTokens = opts.chunkOverlapTokens ?? DEFAULT_OVERLAP_TOKENS2;
+    this.trimWhitespace = opts.trimWhitespace ?? true;
+    this._onProgress = opts.onProgress;
+    if (this.chunkOverlapTokens >= this.chunkTokens) {
+      throw new Error(`chunkOverlapTokens (${this.chunkOverlapTokens}) must be smaller than ` + `chunkTokens (${this.chunkTokens})`);
+    }
+  }
+  async load() {
+    if (this._model)
+      return;
+    if (this._loadPromise)
+      return this._loadPromise;
+    this._loadPromise = (async () => {
+      const mod = await loadTransformersJs2();
+      let preferredDevice = this.device;
+      if (this.device === "auto") {
+        const nav = typeof navigator !== "undefined" ? navigator : null;
+        preferredDevice = "wasm";
+        if (nav?.gpu?.requestAdapter) {
+          try {
+            const adapter = await nav.gpu.requestAdapter();
+            if (adapter)
+              preferredDevice = "webgpu";
+          } catch {}
+        }
+      }
+      const tokenizer = await mod.AutoTokenizer.from_pretrained(this.model);
+      const model = await mod.AutoModelForTokenClassification.from_pretrained(this.model, {
+        device: preferredDevice,
+        dtype: this.dtype,
+        progress_callback: this._onProgress ? (raw) => this._emitProgress(raw, preferredDevice) : undefined
+      });
+      this._tokenizer = tokenizer;
+      this._model = model;
+      this._id2label = model.config.id2label;
+      const label2id = model.config.label2id;
+      this._oId = label2id?.["O"] ?? 0;
+      this.actualDevice = preferredDevice;
+    })();
+    return this._loadPromise;
+  }
+  async detect(text, opts) {
+    if (opts?.model && opts.model !== this.model) {
+      throw new Error(`CalibratedDetector was constructed with model='${this.model}'; ` + `per-call model override ('${opts.model}') not supported.`);
+    }
+    if (!text)
+      return [];
+    await this.load();
+    return this._detectChunked(text);
+  }
+  async _detectChunked(text) {
+    if (text.length <= 1500) {
+      return await this._detectWindow(text, 0);
+    }
+    const stride = 1500 - 200;
+    const seen = new Set;
+    const out = [];
+    for (let s = 0;s < text.length; s += stride) {
+      const e = Math.min(s + 1500, text.length);
+      const sub = text.slice(s, e);
+      const subSpans = await this._detectWindow(sub, s);
+      for (const sp of subSpans) {
+        const key = `${sp.start}|${sp.end}|${sp.label}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        out.push(sp);
+      }
+      if (e >= text.length)
+        break;
+    }
+    out.sort((a, b) => a.start - b.start || a.end - b.end);
+    return out;
+  }
+  async _detectWindow(text, charOffset) {
+    const tokenizer = this._tokenizer;
+    const model = this._model;
+    const enc = await tokenizer([text], {
+      padding: true,
+      truncation: true,
+      max_length: this.chunkTokens + 2
+    });
+    const inputs = {};
+    if (enc.input_ids)
+      inputs["input_ids"] = enc.input_ids;
+    if (enc.attention_mask)
+      inputs["attention_mask"] = enc.attention_mask;
+    const out = await model(inputs);
+    const logits = readLogits(out.logits);
+    if (this.oBias !== 0) {
+      for (let t = 0;t < logits.length; t++) {
+        const row = logits[t];
+        if (row === undefined)
+          continue;
+        const cur = row[this._oId];
+        if (cur !== undefined) {
+          row[this._oId] = cur - this.oBias;
+        }
+      }
+    }
+    const inputIds = readInputIds(enc.input_ids);
+    const tokenLabels = [];
+    for (let t = 0;t < logits.length; t++) {
+      const row = logits[t];
+      const id = inputIds[t];
+      if (!row || id === undefined)
+        continue;
+      let maxIdx = 0;
+      let maxVal = row[0];
+      for (let i = 1;i < row.length; i++) {
+        if (row[i] > maxVal) {
+          maxVal = row[i];
+          maxIdx = i;
+        }
+      }
+      tokenLabels.push({ id, label: this._id2label[maxIdx] ?? "O" });
+    }
+    const spans = [];
+    let cursor = 0;
+    let groupIds = [];
+    let groupCat = null;
+    const flush = () => {
+      if (groupCat === null || groupIds.length === 0)
+        return;
+      const surface = normalizeDecoded(tokenizer.decode(groupIds, { skip_special_tokens: true }));
+      groupIds = [];
+      const cat = groupCat;
+      groupCat = null;
+      if (!surface)
+        return;
+      const idx = text.indexOf(surface, cursor);
+      if (idx === -1)
+        return;
+      let s = idx;
+      let e = idx + surface.length;
+      cursor = e;
+      if (this.trimWhitespace)
+        [s, e] = trimSpan2(text, s, e);
+      if (s >= e)
+        return;
+      spans.push({
+        start: s + charOffset,
+        end: e + charOffset,
+        label: cat,
+        text: text.slice(s, e),
+        score: 1
+      });
+    };
+    for (const { id, label } of tokenLabels) {
+      const cat = label === "O" ? null : label.split("-", 2)[1] ?? null;
+      if (cat === groupCat && cat !== null) {
+        groupIds.push(id);
+      } else {
+        flush();
+        if (cat !== null) {
+          groupIds.push(id);
+          groupCat = cat;
+        }
+      }
+    }
+    flush();
+    return spans;
+  }
+  _emitProgress(raw, device) {
+    if (!this._onProgress)
+      return;
+    const event = {
+      phase: raw.status ?? "progress",
+      device
+    };
+    if (raw.file)
+      event.file = raw.file;
+    if (raw.status === "progress") {
+      if (raw.loaded != null)
+        event.loadedBytes = raw.loaded;
+      if (raw.total != null)
+        event.totalBytes = raw.total;
+      if (raw.progress != null) {
+        const norm = raw.progress > 1 ? raw.progress / 100 : raw.progress;
+        event.fraction = Math.max(0, Math.min(1, norm));
+      }
+    }
+    this._onProgress(event);
+  }
+}
+async function loadTransformersJs2() {
+  try {
+    return await import("@huggingface/transformers");
+  } catch {
+    throw new Error("CalibratedDetector requires `@huggingface/transformers`. Install with: bun add @huggingface/transformers");
+  }
+}
+function readInputIds(tensor) {
+  if (!tensor)
+    return [];
+  if (typeof tensor.tolist === "function") {
+    const list = tensor.tolist();
+    if (Array.isArray(list) && Array.isArray(list[0])) {
+      return list[0].map((x) => Number(x));
+    }
+    if (Array.isArray(list))
+      return list.map((x) => Number(x));
+  }
+  const dims = tensor.dims;
+  const seq = dims[dims.length - 1] ?? 0;
+  const data = tensor.data;
+  const out = [];
+  for (let i = 0;i < seq; i++)
+    out.push(Number(data[i]));
+  return out;
+}
+function normalizeDecoded(s) {
+  return s.replace(/##/g, "").trim();
+}
+function readLogits(tensor) {
+  if (typeof tensor.tolist === "function") {
+    const list = tensor.tolist();
+    if (Array.isArray(list) && Array.isArray(list[0]) && Array.isArray(list[0][0])) {
+      return list[0];
+    }
+    if (Array.isArray(list) && Array.isArray(list[0])) {
+      return list;
+    }
+  }
+  const dims = tensor.dims;
+  const seq = dims[dims.length - 2] ?? 0;
+  const cls = dims[dims.length - 1] ?? 0;
+  const data = tensor.data;
+  const out = [];
+  for (let t = 0;t < seq; t++) {
+    const row = [];
+    for (let c = 0;c < cls; c++) {
+      row.push(Number(data[t * cls + c]));
+    }
+    out.push(row);
+  }
+  return out;
+}
 // src/detectors/index.ts
 function defaultDetector() {
   const hasKey = typeof process !== "undefined" && Boolean(process.env?.GHEIM_API_KEY);
-  return hasKey ? new RemoteDetector : new LocalDetector;
+  return hasKey ? new RemoteDetector : new CalibratedDetector;
 }
 // src/plain.ts
 function resolve(session, detector) {
@@ -896,4 +1168,4 @@ async function* deanonymizeStream(chunks, session) {
 }
 
 // src/index.ts
-var VERSION = "0.1.4";
+var VERSION = "0.1.5";

package/dist/cjs/openai/index.cjs

@@ -751,10 +751,281 @@ class CompositeDetector {
     return out;
   }
 }
+// src/detectors/calibrated.ts
+var DEFAULT_MODEL3 = "joelbarmettler/gheim-ch-560m";
+var DEFAULT_CHUNK_TOKENS2 = 510;
+var DEFAULT_OVERLAP_TOKENS2 = 32;
+function trimSpan2(text, start, end) {
+  while (start < end && /\s/.test(text[start] ?? ""))
+    start++;
+  while (end > start && /\s/.test(text[end - 1] ?? ""))
+    end--;
+  return [start, end];
+}
+
+class CalibratedDetector {
+  model;
+  oBias;
+  device;
+  dtype;
+  chunkTokens;
+  chunkOverlapTokens;
+  trimWhitespace;
+  actualDevice = null;
+  _model = null;
+  _tokenizer = null;
+  _id2label = {};
+  _oId = 0;
+  _loadPromise = null;
+  _onProgress;
+  constructor(opts = {}) {
+    this.model = opts.model ?? DEFAULT_MODEL3;
+    this.oBias = opts.oBias ?? 0.5;
+    this.device = opts.device ?? "auto";
+    this.dtype = opts.dtype ?? "fp32";
+    this.chunkTokens = opts.chunkTokens ?? DEFAULT_CHUNK_TOKENS2;
+    this.chunkOverlapTokens = opts.chunkOverlapTokens ?? DEFAULT_OVERLAP_TOKENS2;
+    this.trimWhitespace = opts.trimWhitespace ?? true;
+    this._onProgress = opts.onProgress;
+    if (this.chunkOverlapTokens >= this.chunkTokens) {
+      throw new Error(`chunkOverlapTokens (${this.chunkOverlapTokens}) must be smaller than ` + `chunkTokens (${this.chunkTokens})`);
+    }
+  }
+  async load() {
+    if (this._model)
+      return;
+    if (this._loadPromise)
+      return this._loadPromise;
+    this._loadPromise = (async () => {
+      const mod = await loadTransformersJs2();
+      let preferredDevice = this.device;
+      if (this.device === "auto") {
+        const nav = typeof navigator !== "undefined" ? navigator : null;
+        preferredDevice = "wasm";
+        if (nav?.gpu?.requestAdapter) {
+          try {
+            const adapter = await nav.gpu.requestAdapter();
+            if (adapter)
+              preferredDevice = "webgpu";
+          } catch {}
+        }
+      }
+      const tokenizer = await mod.AutoTokenizer.from_pretrained(this.model);
+      const model = await mod.AutoModelForTokenClassification.from_pretrained(this.model, {
+        device: preferredDevice,
+        dtype: this.dtype,
+        progress_callback: this._onProgress ? (raw) => this._emitProgress(raw, preferredDevice) : undefined
+      });
+      this._tokenizer = tokenizer;
+      this._model = model;
+      this._id2label = model.config.id2label;
+      const label2id = model.config.label2id;
+      this._oId = label2id?.["O"] ?? 0;
+      this.actualDevice = preferredDevice;
+    })();
+    return this._loadPromise;
+  }
+  async detect(text, opts) {
+    if (opts?.model && opts.model !== this.model) {
+      throw new Error(`CalibratedDetector was constructed with model='${this.model}'; ` + `per-call model override ('${opts.model}') not supported.`);
+    }
+    if (!text)
+      return [];
+    await this.load();
+    return this._detectChunked(text);
+  }
+  async _detectChunked(text) {
+    if (text.length <= 1500) {
+      return await this._detectWindow(text, 0);
+    }
+    const stride = 1500 - 200;
+    const seen = new Set;
+    const out = [];
+    for (let s = 0;s < text.length; s += stride) {
+      const e = Math.min(s + 1500, text.length);
+      const sub = text.slice(s, e);
+      const subSpans = await this._detectWindow(sub, s);
+      for (const sp of subSpans) {
+        const key = `${sp.start}|${sp.end}|${sp.label}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        out.push(sp);
+      }
+      if (e >= text.length)
+        break;
+    }
+    out.sort((a, b) => a.start - b.start || a.end - b.end);
+    return out;
+  }
+  async _detectWindow(text, charOffset) {
+    const tokenizer = this._tokenizer;
+    const model = this._model;
+    const enc = await tokenizer([text], {
+      padding: true,
+      truncation: true,
+      max_length: this.chunkTokens + 2
+    });
+    const inputs = {};
+    if (enc.input_ids)
+      inputs["input_ids"] = enc.input_ids;
+    if (enc.attention_mask)
+      inputs["attention_mask"] = enc.attention_mask;
+    const out = await model(inputs);
+    const logits = readLogits(out.logits);
+    if (this.oBias !== 0) {
+      for (let t = 0;t < logits.length; t++) {
+        const row = logits[t];
+        if (row === undefined)
+          continue;
+        const cur = row[this._oId];
+        if (cur !== undefined) {
+          row[this._oId] = cur - this.oBias;
+        }
+      }
+    }
+    const inputIds = readInputIds(enc.input_ids);
+    const tokenLabels = [];
+    for (let t = 0;t < logits.length; t++) {
+      const row = logits[t];
+      const id = inputIds[t];
+      if (!row || id === undefined)
+        continue;
+      let maxIdx = 0;
+      let maxVal = row[0];
+      for (let i = 1;i < row.length; i++) {
+        if (row[i] > maxVal) {
+          maxVal = row[i];
+          maxIdx = i;
+        }
+      }
+      tokenLabels.push({ id, label: this._id2label[maxIdx] ?? "O" });
+    }
+    const spans = [];
+    let cursor = 0;
+    let groupIds = [];
+    let groupCat = null;
+    const flush = () => {
+      if (groupCat === null || groupIds.length === 0)
+        return;
+      const surface = normalizeDecoded(tokenizer.decode(groupIds, { skip_special_tokens: true }));
+      groupIds = [];
+      const cat = groupCat;
+      groupCat = null;
+      if (!surface)
+        return;
+      const idx = text.indexOf(surface, cursor);
+      if (idx === -1)
+        return;
+      let s = idx;
+      let e = idx + surface.length;
+      cursor = e;
+      if (this.trimWhitespace)
+        [s, e] = trimSpan2(text, s, e);
+      if (s >= e)
+        return;
+      spans.push({
+        start: s + charOffset,
+        end: e + charOffset,
+        label: cat,
+        text: text.slice(s, e),
+        score: 1
+      });
+    };
+    for (const { id, label } of tokenLabels) {
+      const cat = label === "O" ? null : label.split("-", 2)[1] ?? null;
+      if (cat === groupCat && cat !== null) {
+        groupIds.push(id);
+      } else {
+        flush();
+        if (cat !== null) {
+          groupIds.push(id);
+          groupCat = cat;
+        }
+      }
+    }
+    flush();
+    return spans;
+  }
+  _emitProgress(raw, device) {
+    if (!this._onProgress)
+      return;
+    const event = {
+      phase: raw.status ?? "progress",
+      device
+    };
+    if (raw.file)
+      event.file = raw.file;
+    if (raw.status === "progress") {
+      if (raw.loaded != null)
+        event.loadedBytes = raw.loaded;
+      if (raw.total != null)
+        event.totalBytes = raw.total;
+      if (raw.progress != null) {
+        const norm = raw.progress > 1 ? raw.progress / 100 : raw.progress;
+        event.fraction = Math.max(0, Math.min(1, norm));
+      }
+    }
+    this._onProgress(event);
+  }
+}
+async function loadTransformersJs2() {
+  try {
+    return await import("@huggingface/transformers");
+  } catch {
+    throw new Error("CalibratedDetector requires `@huggingface/transformers`. Install with: bun add @huggingface/transformers");
+  }
+}
+function readInputIds(tensor) {
+  if (!tensor)
+    return [];
+  if (typeof tensor.tolist === "function") {
+    const list = tensor.tolist();
+    if (Array.isArray(list) && Array.isArray(list[0])) {
+      return list[0].map((x) => Number(x));
+    }
+    if (Array.isArray(list))
+      return list.map((x) => Number(x));
+  }
+  const dims = tensor.dims;
+  const seq = dims[dims.length - 1] ?? 0;
+  const data = tensor.data;
+  const out = [];
+  for (let i = 0;i < seq; i++)
+    out.push(Number(data[i]));
+  return out;
+}
+function normalizeDecoded(s) {
+  return s.replace(/##/g, "").trim();
+}
+function readLogits(tensor) {
+  if (typeof tensor.tolist === "function") {
+    const list = tensor.tolist();
+    if (Array.isArray(list) && Array.isArray(list[0]) && Array.isArray(list[0][0])) {
+      return list[0];
+    }
+    if (Array.isArray(list) && Array.isArray(list[0])) {
+      return list;
+    }
+  }
+  const dims = tensor.dims;
+  const seq = dims[dims.length - 2] ?? 0;
+  const cls = dims[dims.length - 1] ?? 0;
+  const data = tensor.data;
+  const out = [];
+  for (let t = 0;t < seq; t++) {
+    const row = [];
+    for (let c = 0;c < cls; c++) {
+      row.push(Number(data[t * cls + c]));
+    }
+    out.push(row);
+  }
+  return out;
+}
 // src/detectors/index.ts
 function defaultDetector() {
   const hasKey = typeof process !== "undefined" && Boolean(process.env?.GHEIM_API_KEY);
-  return hasKey ? new RemoteDetector : new LocalDetector;
+  return hasKey ? new RemoteDetector : new CalibratedDetector;
 }
 
 // src/core/session.ts

package/dist/esm/index.js

@@ -786,10 +786,281 @@ class CompositeDetector {
     return out;
   }
 }
+// src/detectors/calibrated.ts
+var DEFAULT_MODEL3 = "joelbarmettler/gheim-ch-560m";
+var DEFAULT_CHUNK_TOKENS2 = 510;
+var DEFAULT_OVERLAP_TOKENS2 = 32;
+function trimSpan2(text, start, end) {
+  while (start < end && /\s/.test(text[start] ?? ""))
+    start++;
+  while (end > start && /\s/.test(text[end - 1] ?? ""))
+    end--;
+  return [start, end];
+}
+
+class CalibratedDetector {
+  model;
+  oBias;
+  device;
+  dtype;
+  chunkTokens;
+  chunkOverlapTokens;
+  trimWhitespace;
+  actualDevice = null;
+  _model = null;
+  _tokenizer = null;
+  _id2label = {};
+  _oId = 0;
+  _loadPromise = null;
+  _onProgress;
+  constructor(opts = {}) {
+    this.model = opts.model ?? DEFAULT_MODEL3;
+    this.oBias = opts.oBias ?? 0.5;
+    this.device = opts.device ?? "auto";
+    this.dtype = opts.dtype ?? "fp32";
+    this.chunkTokens = opts.chunkTokens ?? DEFAULT_CHUNK_TOKENS2;
+    this.chunkOverlapTokens = opts.chunkOverlapTokens ?? DEFAULT_OVERLAP_TOKENS2;
+    this.trimWhitespace = opts.trimWhitespace ?? true;
+    this._onProgress = opts.onProgress;
+    if (this.chunkOverlapTokens >= this.chunkTokens) {
+      throw new Error(`chunkOverlapTokens (${this.chunkOverlapTokens}) must be smaller than ` + `chunkTokens (${this.chunkTokens})`);
+    }
+  }
+  async load() {
+    if (this._model)
+      return;
+    if (this._loadPromise)
+      return this._loadPromise;
+    this._loadPromise = (async () => {
+      const mod = await loadTransformersJs2();
+      let preferredDevice = this.device;
+      if (this.device === "auto") {
+        const nav = typeof navigator !== "undefined" ? navigator : null;
+        preferredDevice = "wasm";
+        if (nav?.gpu?.requestAdapter) {
+          try {
+            const adapter = await nav.gpu.requestAdapter();
+            if (adapter)
+              preferredDevice = "webgpu";
+          } catch {}
+        }
+      }
+      const tokenizer = await mod.AutoTokenizer.from_pretrained(this.model);
+      const model = await mod.AutoModelForTokenClassification.from_pretrained(this.model, {
+        device: preferredDevice,
+        dtype: this.dtype,
+        progress_callback: this._onProgress ? (raw) => this._emitProgress(raw, preferredDevice) : undefined
+      });
+      this._tokenizer = tokenizer;
+      this._model = model;
+      this._id2label = model.config.id2label;
+      const label2id = model.config.label2id;
+      this._oId = label2id?.["O"] ?? 0;
+      this.actualDevice = preferredDevice;
+    })();
+    return this._loadPromise;
+  }
+  async detect(text, opts) {
+    if (opts?.model && opts.model !== this.model) {
+      throw new Error(`CalibratedDetector was constructed with model='${this.model}'; ` + `per-call model override ('${opts.model}') not supported.`);
+    }
+    if (!text)
+      return [];
+    await this.load();
+    return this._detectChunked(text);
+  }
+  async _detectChunked(text) {
+    if (text.length <= 1500) {
+      return await this._detectWindow(text, 0);
+    }
+    const stride = 1500 - 200;
+    const seen = new Set;
+    const out = [];
+    for (let s = 0;s < text.length; s += stride) {
+      const e = Math.min(s + 1500, text.length);
+      const sub = text.slice(s, e);
+      const subSpans = await this._detectWindow(sub, s);
+      for (const sp of subSpans) {
+        const key = `${sp.start}|${sp.end}|${sp.label}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        out.push(sp);
+      }
+      if (e >= text.length)
+        break;
+    }
+    out.sort((a, b) => a.start - b.start || a.end - b.end);
+    return out;
+  }
+  async _detectWindow(text, charOffset) {
+    const tokenizer = this._tokenizer;
+    const model = this._model;
+    const enc = await tokenizer([text], {
+      padding: true,
+      truncation: true,
+      max_length: this.chunkTokens + 2
+    });
+    const inputs = {};
+    if (enc.input_ids)
+      inputs["input_ids"] = enc.input_ids;
+    if (enc.attention_mask)
+      inputs["attention_mask"] = enc.attention_mask;
+    const out = await model(inputs);
+    const logits = readLogits(out.logits);
+    if (this.oBias !== 0) {
+      for (let t = 0;t < logits.length; t++) {
+        const row = logits[t];
+        if (row === undefined)
+          continue;
+        const cur = row[this._oId];
+        if (cur !== undefined) {
+          row[this._oId] = cur - this.oBias;
+        }
+      }
+    }
+    const inputIds = readInputIds(enc.input_ids);
+    const tokenLabels = [];
+    for (let t = 0;t < logits.length; t++) {
+      const row = logits[t];
+      const id = inputIds[t];
+      if (!row || id === undefined)
+        continue;
+      let maxIdx = 0;
+      let maxVal = row[0];
+      for (let i = 1;i < row.length; i++) {
+        if (row[i] > maxVal) {
+          maxVal = row[i];
+          maxIdx = i;
+        }
+      }
+      tokenLabels.push({ id, label: this._id2label[maxIdx] ?? "O" });
+    }
+    const spans = [];
+    let cursor = 0;
+    let groupIds = [];
+    let groupCat = null;
+    const flush = () => {
+      if (groupCat === null || groupIds.length === 0)
+        return;
+      const surface = normalizeDecoded(tokenizer.decode(groupIds, { skip_special_tokens: true }));
+      groupIds = [];
+      const cat = groupCat;
+      groupCat = null;
+      if (!surface)
+        return;
+      const idx = text.indexOf(surface, cursor);
+      if (idx === -1)
+        return;
+      let s = idx;
+      let e = idx + surface.length;
+      cursor = e;
+      if (this.trimWhitespace)
+        [s, e] = trimSpan2(text, s, e);
+      if (s >= e)
+        return;
+      spans.push({
+        start: s + charOffset,
+        end: e + charOffset,
+        label: cat,
+        text: text.slice(s, e),
+        score: 1
+      });
+    };
+    for (const { id, label } of tokenLabels) {
+      const cat = label === "O" ? null : label.split("-", 2)[1] ?? null;
+      if (cat === groupCat && cat !== null) {
+        groupIds.push(id);
+      } else {
+        flush();
+        if (cat !== null) {
+          groupIds.push(id);
+          groupCat = cat;
+        }
+      }
+    }
+    flush();
+    return spans;
+  }
+  _emitProgress(raw, device) {
+    if (!this._onProgress)
+      return;
+    const event = {
+      phase: raw.status ?? "progress",
+      device
+    };
+    if (raw.file)
+      event.file = raw.file;
+    if (raw.status === "progress") {
+      if (raw.loaded != null)
+        event.loadedBytes = raw.loaded;
+      if (raw.total != null)
+        event.totalBytes = raw.total;
+      if (raw.progress != null) {
+        const norm = raw.progress > 1 ? raw.progress / 100 : raw.progress;
+        event.fraction = Math.max(0, Math.min(1, norm));
+      }
+    }
+    this._onProgress(event);
+  }
+}
+async function loadTransformersJs2() {
+  try {
+    return await import("@huggingface/transformers");
+  } catch {
+    throw new Error("CalibratedDetector requires `@huggingface/transformers`. Install with: bun add @huggingface/transformers");
+  }
+}
+function readInputIds(tensor) {
+  if (!tensor)
+    return [];
+  if (typeof tensor.tolist === "function") {
+    const list = tensor.tolist();
+    if (Array.isArray(list) && Array.isArray(list[0])) {
+      return list[0].map((x) => Number(x));
+    }
+    if (Array.isArray(list))
+      return list.map((x) => Number(x));
+  }
+  const dims = tensor.dims;
+  const seq = dims[dims.length - 1] ?? 0;
+  const data = tensor.data;
+  const out = [];
+  for (let i = 0;i < seq; i++)
+    out.push(Number(data[i]));
+  return out;
+}
+function normalizeDecoded(s) {
+  return s.replace(/##/g, "").trim();
+}
+function readLogits(tensor) {
+  if (typeof tensor.tolist === "function") {
+    const list = tensor.tolist();
+    if (Array.isArray(list) && Array.isArray(list[0]) && Array.isArray(list[0][0])) {
+      return list[0];
+    }
+    if (Array.isArray(list) && Array.isArray(list[0])) {
+      return list;
+    }
+  }
+  const dims = tensor.dims;
+  const seq = dims[dims.length - 2] ?? 0;
+  const cls = dims[dims.length - 1] ?? 0;
+  const data = tensor.data;
+  const out = [];
+  for (let t = 0;t < seq; t++) {
+    const row = [];
+    for (let c = 0;c < cls; c++) {
+      row.push(Number(data[t * cls + c]));
+    }
+    out.push(row);
+  }
+  return out;
+}
 // src/detectors/index.ts
 function defaultDetector() {
   const hasKey = typeof process !== "undefined" && Boolean(process.env?.GHEIM_API_KEY);
-  return hasKey ? new RemoteDetector : new LocalDetector;
+  return hasKey ? new RemoteDetector : new CalibratedDetector;
 }
 // src/plain.ts
 function resolve(session, detector) {
@@ -840,7 +1111,7 @@ async function* deanonymizeStream(chunks, session) {
 }
 
 // src/index.ts
-var VERSION = "0.1.4";
+var VERSION = "0.1.5";
 export {
   renderSentinel,
   parseSentinel,
@@ -861,5 +1132,6 @@ export {
   LocalDetector,
   LABEL_TO_TAG,
   DEFAULT_BASE_URL,
-  CompositeDetector
+  CompositeDetector,
+  CalibratedDetector
 };

package/dist/esm/openai/index.js

@@ -708,10 +708,281 @@ class CompositeDetector {
     return out;
   }
 }
+// src/detectors/calibrated.ts
+var DEFAULT_MODEL3 = "joelbarmettler/gheim-ch-560m";
+var DEFAULT_CHUNK_TOKENS2 = 510;
+var DEFAULT_OVERLAP_TOKENS2 = 32;
+function trimSpan2(text, start, end) {
+  while (start < end && /\s/.test(text[start] ?? ""))
+    start++;
+  while (end > start && /\s/.test(text[end - 1] ?? ""))
+    end--;
+  return [start, end];
+}
+
+class CalibratedDetector {
+  model;
+  oBias;
+  device;
+  dtype;
+  chunkTokens;
+  chunkOverlapTokens;
+  trimWhitespace;
+  actualDevice = null;
+  _model = null;
+  _tokenizer = null;
+  _id2label = {};
+  _oId = 0;
+  _loadPromise = null;
+  _onProgress;
+  constructor(opts = {}) {
+    this.model = opts.model ?? DEFAULT_MODEL3;
+    this.oBias = opts.oBias ?? 0.5;
+    this.device = opts.device ?? "auto";
+    this.dtype = opts.dtype ?? "fp32";
+    this.chunkTokens = opts.chunkTokens ?? DEFAULT_CHUNK_TOKENS2;
+    this.chunkOverlapTokens = opts.chunkOverlapTokens ?? DEFAULT_OVERLAP_TOKENS2;
+    this.trimWhitespace = opts.trimWhitespace ?? true;
+    this._onProgress = opts.onProgress;
+    if (this.chunkOverlapTokens >= this.chunkTokens) {
+      throw new Error(`chunkOverlapTokens (${this.chunkOverlapTokens}) must be smaller than ` + `chunkTokens (${this.chunkTokens})`);
+    }
+  }
+  async load() {
+    if (this._model)
+      return;
+    if (this._loadPromise)
+      return this._loadPromise;
+    this._loadPromise = (async () => {
+      const mod = await loadTransformersJs2();
+      let preferredDevice = this.device;
+      if (this.device === "auto") {
+        const nav = typeof navigator !== "undefined" ? navigator : null;
+        preferredDevice = "wasm";
+        if (nav?.gpu?.requestAdapter) {
+          try {
+            const adapter = await nav.gpu.requestAdapter();
+            if (adapter)
+              preferredDevice = "webgpu";
+          } catch {}
+        }
+      }
+      const tokenizer = await mod.AutoTokenizer.from_pretrained(this.model);
+      const model = await mod.AutoModelForTokenClassification.from_pretrained(this.model, {
+        device: preferredDevice,
+        dtype: this.dtype,
+        progress_callback: this._onProgress ? (raw) => this._emitProgress(raw, preferredDevice) : undefined
+      });
+      this._tokenizer = tokenizer;
+      this._model = model;
+      this._id2label = model.config.id2label;
+      const label2id = model.config.label2id;
+      this._oId = label2id?.["O"] ?? 0;
+      this.actualDevice = preferredDevice;
+    })();
+    return this._loadPromise;
+  }
+  async detect(text, opts) {
+    if (opts?.model && opts.model !== this.model) {
+      throw new Error(`CalibratedDetector was constructed with model='${this.model}'; ` + `per-call model override ('${opts.model}') not supported.`);
+    }
+    if (!text)
+      return [];
+    await this.load();
+    return this._detectChunked(text);
+  }
+  async _detectChunked(text) {
+    if (text.length <= 1500) {
+      return await this._detectWindow(text, 0);
+    }
+    const stride = 1500 - 200;
+    const seen = new Set;
+    const out = [];
+    for (let s = 0;s < text.length; s += stride) {
+      const e = Math.min(s + 1500, text.length);
+      const sub = text.slice(s, e);
+      const subSpans = await this._detectWindow(sub, s);
+      for (const sp of subSpans) {
+        const key = `${sp.start}|${sp.end}|${sp.label}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        out.push(sp);
+      }
+      if (e >= text.length)
+        break;
+    }
+    out.sort((a, b) => a.start - b.start || a.end - b.end);
+    return out;
+  }
+  async _detectWindow(text, charOffset) {
+    const tokenizer = this._tokenizer;
+    const model = this._model;
+    const enc = await tokenizer([text], {
+      padding: true,
+      truncation: true,
+      max_length: this.chunkTokens + 2
+    });
+    const inputs = {};
+    if (enc.input_ids)
+      inputs["input_ids"] = enc.input_ids;
+    if (enc.attention_mask)
+      inputs["attention_mask"] = enc.attention_mask;
+    const out = await model(inputs);
+    const logits = readLogits(out.logits);
+    if (this.oBias !== 0) {
+      for (let t = 0;t < logits.length; t++) {
+        const row = logits[t];
+        if (row === undefined)
+          continue;
+        const cur = row[this._oId];
+        if (cur !== undefined) {
+          row[this._oId] = cur - this.oBias;
+        }
+      }
+    }
+    const inputIds = readInputIds(enc.input_ids);
+    const tokenLabels = [];
+    for (let t = 0;t < logits.length; t++) {
+      const row = logits[t];
+      const id = inputIds[t];
+      if (!row || id === undefined)
+        continue;
+      let maxIdx = 0;
+      let maxVal = row[0];
+      for (let i = 1;i < row.length; i++) {
+        if (row[i] > maxVal) {
+          maxVal = row[i];
+          maxIdx = i;
+        }
+      }
+      tokenLabels.push({ id, label: this._id2label[maxIdx] ?? "O" });
+    }
+    const spans = [];
+    let cursor = 0;
+    let groupIds = [];
+    let groupCat = null;
+    const flush = () => {
+      if (groupCat === null || groupIds.length === 0)
+        return;
+      const surface = normalizeDecoded(tokenizer.decode(groupIds, { skip_special_tokens: true }));
+      groupIds = [];
+      const cat = groupCat;
+      groupCat = null;
+      if (!surface)
+        return;
+      const idx = text.indexOf(surface, cursor);
+      if (idx === -1)
+        return;
+      let s = idx;
+      let e = idx + surface.length;
+      cursor = e;
+      if (this.trimWhitespace)
+        [s, e] = trimSpan2(text, s, e);
+      if (s >= e)
+        return;
+      spans.push({
+        start: s + charOffset,
+        end: e + charOffset,
+        label: cat,
+        text: text.slice(s, e),
+        score: 1
+      });
+    };
+    for (const { id, label } of tokenLabels) {
+      const cat = label === "O" ? null : label.split("-", 2)[1] ?? null;
+      if (cat === groupCat && cat !== null) {
+        groupIds.push(id);
+      } else {
+        flush();
+        if (cat !== null) {
+          groupIds.push(id);
+          groupCat = cat;
+        }
+      }
+    }
+    flush();
+    return spans;
+  }
+  _emitProgress(raw, device) {
+    if (!this._onProgress)
+      return;
+    const event = {
+      phase: raw.status ?? "progress",
+      device
+    };
+    if (raw.file)
+      event.file = raw.file;
+    if (raw.status === "progress") {
+      if (raw.loaded != null)
+        event.loadedBytes = raw.loaded;
+      if (raw.total != null)
+        event.totalBytes = raw.total;
+      if (raw.progress != null) {
+        const norm = raw.progress > 1 ? raw.progress / 100 : raw.progress;
+        event.fraction = Math.max(0, Math.min(1, norm));
+      }
+    }
+    this._onProgress(event);
+  }
+}
+async function loadTransformersJs2() {
+  try {
+    return await import("@huggingface/transformers");
+  } catch {
+    throw new Error("CalibratedDetector requires `@huggingface/transformers`. Install with: bun add @huggingface/transformers");
+  }
+}
+function readInputIds(tensor) {
+  if (!tensor)
+    return [];
+  if (typeof tensor.tolist === "function") {
+    const list = tensor.tolist();
+    if (Array.isArray(list) && Array.isArray(list[0])) {
+      return list[0].map((x) => Number(x));
+    }
+    if (Array.isArray(list))
+      return list.map((x) => Number(x));
+  }
+  const dims = tensor.dims;
+  const seq = dims[dims.length - 1] ?? 0;
+  const data = tensor.data;
+  const out = [];
+  for (let i = 0;i < seq; i++)
+    out.push(Number(data[i]));
+  return out;
+}
+function normalizeDecoded(s) {
+  return s.replace(/##/g, "").trim();
+}
+function readLogits(tensor) {
+  if (typeof tensor.tolist === "function") {
+    const list = tensor.tolist();
+    if (Array.isArray(list) && Array.isArray(list[0]) && Array.isArray(list[0][0])) {
+      return list[0];
+    }
+    if (Array.isArray(list) && Array.isArray(list[0])) {
+      return list;
+    }
+  }
+  const dims = tensor.dims;
+  const seq = dims[dims.length - 2] ?? 0;
+  const cls = dims[dims.length - 1] ?? 0;
+  const data = tensor.data;
+  const out = [];
+  for (let t = 0;t < seq; t++) {
+    const row = [];
+    for (let c = 0;c < cls; c++) {
+      row.push(Number(data[t * cls + c]));
+    }
+    out.push(row);
+  }
+  return out;
+}
 // src/detectors/index.ts
 function defaultDetector() {
   const hasKey = typeof process !== "undefined" && Boolean(process.env?.GHEIM_API_KEY);
-  return hasKey ? new RemoteDetector : new LocalDetector;
+  return hasKey ? new RemoteDetector : new CalibratedDetector;
 }
 
 // src/core/session.ts

package/dist/types/detectors/calibrated.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Calibrated detector — fixes the v1 model's "single-category mode"
+ * bug at inference time by subtracting a constant `oBias` from the O
+ * class logit before argmax.
+ *
+ * Empirical justification (see eval/calibration_sweep.json): on a
+ * 237-case multi-entity pathology suite the v1 model emits literally
+ * zero non-O tokens for "Müller" / "März" when an IBAN follows them —
+ * but the per-token softmax shows person at 47% vs O at 51%. A small
+ * additive bias on O flips those marginal cases without inducing false
+ * positives on PII-free text.
+ *
+ * Sweet spot: oBias=0.5:
+ *   - pathology full-coverage 81% → 94.5% (+13.5pp)
+ *   - test_v1 strict-F1 0.872 → 0.868 (−0.4pp)
+ *   - ~0.05 extra FP per chunk on real text
+ *
+ * `defaultDetector()` returns this with oBias=0.5, so users get the
+ * better behavior automatically.
+ */
+import type { Detector, Span } from "./base.ts";
+import type { LocalDetectorLoadEvent } from "./local.ts";
+/** Constructor options for {@link CalibratedDetector}. */
+export interface CalibratedDetectorOptions {
+    /** HuggingFace model id (must be a token-classification head). */
+    model?: string;
+    /**
+     * Constant subtracted from the O-class logit before argmax. Default
+     * `0.5` is the Pareto-clean point per the full-scale bias sweep
+     * (eval/calibration_sweep.json):
+     *
+     *   - oBias=0.0  uncalibrated (matches the raw model)
+     *   - oBias=0.5  recovers ~95% of multi-entity pathology cases for
+     *               ~0.4pp test_v1 strict-F1 cost
+     *   - oBias=1.0  more aggressive: 96.6% pathology, 1.1pp test_v1 cost
+     *   - oBias=1.5+ trades too much precision; not recommended
+     */
+    oBias?: number;
+    /** Backend selector. See {@link LocalDetectorOptions.device}. */
+    device?: string;
+    /** Quantization dtype: "fp32" | "fp16" | "q8" | "q4" | "auto". */
+    dtype?: string;
+    /** Sliding-window size in model tokens (default 510). */
+    chunkTokens?: number;
+    /** Overlap between consecutive windows (default 32). */
+    chunkOverlapTokens?: number;
+    /** Strip leading/trailing whitespace from each emitted span. Default true. */
+    trimWhitespace?: boolean;
+    /** Optional progress callback during model load (mirrors LocalDetector). */
+    onProgress?: (event: LocalDetectorLoadEvent) => void;
+}
+/** CalibratedDetector — local model + O-logit bias. */
+export declare class CalibratedDetector implements Detector {
+    readonly model: string;
+    readonly oBias: number;
+    readonly device: string;
+    readonly dtype: string;
+    readonly chunkTokens: number;
+    readonly chunkOverlapTokens: number;
+    readonly trimWhitespace: boolean;
+    /** Backend actually used after `load()` resolves; `null` before. */
+    actualDevice: string | null;
+    private _model;
+    private _tokenizer;
+    private _id2label;
+    private _oId;
+    private _loadPromise;
+    private readonly _onProgress?;
+    constructor(opts?: CalibratedDetectorOptions);
+    load(): Promise<void>;
+    detect(text: string, opts?: {
+        model?: string;
+    }): Promise<Span[]>;
+    private _detectChunked;
+    private _detectWindow;
+    private _emitProgress;
+}
+//# sourceMappingURL=calibrated.d.ts.map

package/dist/types/detectors/calibrated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calibrated.d.ts","sourceRoot":"","sources":["../../../src/detectors/calibrated.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAMzD,0DAA0D;AAC1D,MAAM,WAAW,yBAAyB;IACxC,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;;;;OAUG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wDAAwD;IACxD,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC;CACtD;AA4CD,uDAAuD;AACvD,qBAAa,kBAAmB,YAAW,QAAQ;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,oEAAoE;IACpE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAQ;IACnC,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,UAAU,CAAkC;IACpD,OAAO,CAAC,SAAS,CAA8B;IAC/C,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAA0C;gBAE3D,IAAI,GAAE,yBAA8B;IAiB1C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAuCrB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;YAYxD,cAAc;YA0Bd,aAAa;IA6F3B,OAAO,CAAC,aAAa;CAiBtB"}

package/dist/types/detectors/index.d.ts

@@ -5,7 +5,14 @@ export { LocalDetector } from "./local.ts";
 export type { LocalDetectorOptions, LocalDetectorLoadEvent } from "./local.ts";
 export { CompositeDetector } from "./composite.ts";
 export type { CompositeDetectorOptions } from "./composite.ts";
+export { CalibratedDetector } from "./calibrated.ts";
+export type { CalibratedDetectorOptions } from "./calibrated.ts";
 import type { Detector } from "./base.ts";
-/** Pick a reasonable default: remote if `GHEIM_API_KEY` is set in env, else local. */
+/** Pick a reasonable default: remote when `GHEIM_API_KEY` is set in env,
+ *  else a calibrated local model.
+ *
+ *  The calibrated default (`oBias=0.5`) recovers ~95% of the
+ *  multi-entity-letter cases that the raw v1 model fails on, with
+ *  ~0.4pp test_v1 strict-F1 cost. See eval/calibration_sweep.json. */
 export declare function defaultDetector(): Detector;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/detectors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/detectors/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EACL,gBAAgB,EAChB,aAAa,IAAI,oBAAoB,EACrC,cAAc,GACf,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,YAAY,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAI1C,sFAAsF;AACtF,wBAAgB,eAAe,IAAI,QAAQ,CAI1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/detectors/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EACL,gBAAgB,EAChB,aAAa,IAAI,oBAAoB,EACrC,cAAc,GACf,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,YAAY,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,YAAY,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAEjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAI1C;;;;;sEAKsE;AACtE,wBAAgB,eAAe,IAAI,QAAQ,CAI1C"}

package/dist/types/index.d.ts

@@ -13,11 +13,11 @@ export { LABEL_TO_TAG, SENTINEL_RE, isPossibleSentinelPrefix, labelTag, parseSen
 export type { Sentinel } from "./core/sentinels.ts";
 export { StreamDeanonymizer } from "./core/stream.ts";
 export type { Detector, Span } from "./detectors/base.ts";
-export { DEFAULT_BASE_URL, REMOTE_DEFAULT_MODEL, RemoteDetector, LocalDetector, CompositeDetector, defaultDetector, } from "./detectors/index.ts";
-export type { RemoteDetectorOptions, LocalDetectorOptions, LocalDetectorLoadEvent, CompositeDetectorOptions, } from "./detectors/index.ts";
+export { DEFAULT_BASE_URL, REMOTE_DEFAULT_MODEL, RemoteDetector, LocalDetector, CompositeDetector, CalibratedDetector, defaultDetector, } from "./detectors/index.ts";
+export type { RemoteDetectorOptions, LocalDetectorOptions, LocalDetectorLoadEvent, CompositeDetectorOptions, CalibratedDetectorOptions, } from "./detectors/index.ts";
 export { anonymizeMessages, anonymizeText, deanonymizeStream, deanonymizeText, } from "./plain.ts";
 export type { ChatMessage } from "./plain.ts";
-export declare const VERSION = "0.1.4";
+export declare const VERSION = "0.1.5";
 export { mergeAdjacent } from "./core/session.ts";
 export type { MergedSpan } from "./core/session.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EACL,YAAY,EACZ,WAAW,EACX,wBAAwB,EACxB,QAAQ,EACR,aAAa,EACb,cAAc,GACf,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAK9C,eAAO,MAAM,OAAO,UAAU,CAAC;AAE/B,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EACL,YAAY,EACZ,WAAW,EACX,wBAAwB,EACxB,QAAQ,EACR,aAAa,EACb,cAAc,GACf,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAK9C,eAAO,MAAM,OAAO,UAAU,CAAC;AAE/B,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gheim",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "PII round-trip for LLM APIs: anonymize before the request, de-anonymize the stream on the way back.",
   "license": "Apache-2.0",
   "author": "Joel Barmettler <joel.barmettler@gmail.com>",