bounds-gemma 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,18 @@
+bounds-gemma
+Copyright 2026 Anya Chueayen
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may
+not use this code except in compliance with the License. You may obtain
+a copy of the License at:
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+This product uses Google's Gemma 4 model family via the Gemini API, the
+@mlc-ai/web-llm runtime, and Ollama. Each of those is governed by its
+own licence. Gemma is provided by Google under the Gemma Prohibited
+Use Policy (https://ai.google.dev/gemma/prohibited_use_policy). Users
+of this toolkit are responsible for complying with Google's terms.
+
+The contextual PHI taxonomy used in the system prompts of this toolkit
+is derived from the HIPAA Safe Harbor identifier categories at 45 CFR
+164.514(b)(2), which are in the public domain.

package/README.md

@@ -0,0 +1,149 @@
+# bounds-gemma
+
+**On-device Gemma 4 contextual PHI redaction.** A small, focused TypeScript toolkit that uses Google's Gemma 4 to catch the protected-health-information shapes that regex and named-entity recognition systematically miss: inline diagnoses in clinical prose, medication mentions, treatment narratives, indirect health context, sensitive social data, and genetic references. Runs in a browser via WebLLM, locally via Ollama, or in any environment that can speak HTTP to a Gemma 4 endpoint. Never on a server.
+
+Live demo: <https://bounds.pro>
+
+This is the open-source pipeline that powers the contextual-PHI layer of Bounds Pro, a closed-source PDF redaction workspace. The toolkit on its own is enough to reproduce that layer end to end on your own documents.
+
+---
+
+## Why this exists
+
+The HIPAA Safe Harbor de-identification standard at 45 CFR 164.514(b)(2) lists eighteen identifier categories. The first sixteen are structured — phone numbers, social-security numbers, medical-record numbers, dates of birth — and the long-standing rule-based redactors handle them. Identifier #17 is *"any other unique identifying number, characteristic, or code"*, and the surrounding clinical narrative is where it lives: a sentence that names a diagnosis without a label, a paragraph that mentions a medication in passing, an aside about a "therapist" or "insulin pump" that re-identifies the patient when triangulated with the rest of the document.
+
+Existing PDF redaction tools force a choice no healthcare reviewer should have to make: send the document to a cloud API and trust their privacy posture, or use a regex-only desktop tool that demonstrably misses everything contextual. This toolkit's argument is that a small, capable on-device model — Gemma 4 E2B at int4 quantisation, ~1.5 GB on disk, running on the user's own browser via WebGPU — closes the gap without ever shipping document bytes off-device.
+
+## What it does
+
+`bounds-gemma` exports a small surface area centred on a single async call:
+
+```ts
+import { startGemmaJob, getGemmaBackend } from 'bounds-gemma/pipeline/GemmaWorker'
+
+// Probe which backend is reachable (Ollama localhost first, WebLLM fallback,
+// unavailable if neither works). Cached after first probe.
+const backend = await getGemmaBackend()
+
+// Run a page's extracted text through Gemma. Returns the contextual-PHI
+// detections the regex and NER layers would have missed.
+const detections = await startGemmaJob({
+  text: pageText,
+  pageIndex: 0,
+})
+```
+
+Each detection is a `{ text, type, confidence, ruleId, reason }` object. Confidence has a healthcare-only floor of 0.75; below that, the detection is silently dropped. The text field is verified to be a byte-identical substring of the input page (with NFC Unicode normalisation), so model hallucinations and paraphrases never reach the consumer.
+
+## Architecture
+
+```
+Input page text
+      │
+      ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ GemmaWorker (main-thread facade)                                │
+│  ├─ probes Ollama at localhost:11434/api/tags                   │
+│  ├─ falls back to WebLLM via @mlc-ai/web-llm in a Worker        │
+│  └─ chunks long pages, dispatches one model call per chunk      │
+└─────────────────────────────────────────────────────────────────┘
+      │
+      ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ Gemma 4 inference                                               │
+│  ├─ Ollama:   model=gemma4:e2b                                  │
+│  ├─ WebLLM:   model=gemma-4-E2B-it-q4f16_1-MLC                  │
+│  ├─ system prompt: six HIPAA Safe Harbor #17 categories         │
+│  └─ output contract: JSON array, no prose                       │
+└─────────────────────────────────────────────────────────────────┘
+      │
+      ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ gemmaParse (validator)                                          │
+│  ├─ strips fences and prose preamble                            │
+│  ├─ enforces JSON schema and confidence floor (0.75)            │
+│  ├─ verifies every detection text is in-corpus (NFC compared)   │
+│  └─ rejects hallucinations silently                             │
+└─────────────────────────────────────────────────────────────────┘
+      │
+      ▼
+Detection[] for downstream PDF redaction
+```
+
+Three guardrails make this safe for healthcare paraphrase tasks:
+
+1. **In-corpus verification.** Every Gemma-emitted span must be a byte-identical substring of the input page text after Unicode NFC normalisation. Model hallucinations and paraphrases are dropped silently before they ever reach the review surface.
+2. **Confidence floor of 0.75.** Tuned specifically for healthcare; below it, candidates are omitted. This is a single constant in `gemmaParse.ts` and easy to lower for non-clinical use cases.
+3. **Default-off in the consumer UI.** Every Gemma detection arrives with `enabled: false`. The downstream reviewer must opt in per item. Surface-level acceptance is never automatic.
+
+## Two execution paths
+
+### Ollama (preferred for production)
+
+```bash
+ollama pull gemma4:e2b
+ollama serve
+```
+
+Then point any consumer at `http://localhost:11434/api/chat`. The toolkit probes this URL at start-up; if reachable, it routes all subsequent calls there. Sub-second latency per chunk on consumer hardware, zero model-CDN traffic, fully offline after the model pull.
+
+### WebLLM (no-install, in-browser)
+
+Serve your application under cross-origin isolation:
+
+```
+Cross-Origin-Opener-Policy: same-origin
+Cross-Origin-Embedder-Policy: require-corp
+```
+
+The toolkit dynamic-imports `@mlc-ai/web-llm` on first use and loads `gemma-4-E2B-it-q4f16_1-MLC` from the MLC CDN. Weights are cached in browser storage; subsequent sessions are fully offline. First load is slow (~1.5 GB download); subsequent loads are instant.
+
+## Install
+
+```bash
+npm install bounds-gemma
+# Optional, only if you want the WebLLM browser path:
+npm install @mlc-ai/web-llm
+```
+
+The package has no required runtime dependencies. `@mlc-ai/web-llm` is a peer dependency you only pull in if you use the browser fallback. Ollama is a separate install (`brew install ollama` or equivalent).
+
+## Run the example
+
+```bash
+git clone https://github.com/Aqta-ai/bounds-gemma.git
+cd bounds-gemma
+npm install
+ollama pull gemma4:e2b
+ollama serve &  # in another terminal
+npm run example:ollama
+```
+
+The example runs a sample clinical-note paragraph through Gemma 4 and prints the contextual-PHI detections.
+
+## Run the tests
+
+```bash
+npm install
+npm test
+```
+
+16 unit tests in `src/__tests__/gemmaParse.test.ts` cover the parser, validator, in-corpus check, NFC normalisation, fence-stripping, malformed-JSON handling, and confidence-floor enforcement. They run in <1 second with no model required.
+
+## What this toolkit deliberately does NOT do
+
+- It does not handle structured PHI (phone numbers, SSNs, dates, MRNs, addresses). Those are the regex and NER layers' job; combine this toolkit with [a regex PII detector](https://github.com/microsoft/presidio) for full Safe Harbor coverage.
+- It does not draw bounding boxes on PDFs. That is the consumer's job; the toolkit returns text spans and lets the consumer resolve them to PDF coordinates.
+- It does not run an auditor. The cross-check pattern in the closed-source Bounds Pro pairs Gemma 4 26B with Gemma 4 31B as paraphraser plus auditor; the on-device toolkit ships only the paraphraser side and relies on verbatim-wins-ties as the safety floor.
+- It does not phone home. No analytics, no telemetry, no model-CDN ping. Verify with the Network tab.
+
+## Source attribution
+
+Built and maintained by Anya Chueayen ([@anyaparanya](https://github.com/anyaparanya)). Released under Apache-2.0 (see `LICENSE`). The Gemma family and the Gemma Prohibited Use Policy are governed by their own terms; using this toolkit means you accept Google's terms for Gemma 4 as well. The HIPAA Safe Harbor identifier list is in the public domain.
+
+## Acknowledgements
+
+- [Google DeepMind](https://deepmind.google/) for Gemma 4 and the open weights.
+- [MLC LLM](https://llm.mlc.ai/) and [WebLLM](https://github.com/mlc-ai/web-llm) for the browser runtime.
+- [Ollama](https://ollama.com/) for the local-first inference daemon.
+- The [Centers for Medicare and Medicaid Services](https://www.hhs.gov/hipaa/for-professionals/privacy/special-topics/de-identification/index.html) for the public-domain HIPAA Safe Harbor specification.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { parseAndValidate, HEALTHCARE_CONFIDENCE_FLOOR, CHUNK_MAX_CHARS, type RawGemmaDetection, } from './workers/gemmaParse.js';
+export { startGemmaJob, cancelGemmaJob, getGemmaBackend, subscribeGemmaBackend, subscribeGemmaModelProgress, type GemmaBackend, } from './pipeline/GemmaWorker.js';
+export type { PiiType, DetectionSource, BBox, Detection, } from './types/index.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+// Public API surface for the bounds-gemma npm package.
+//
+// Three entry points that map to three integration shapes:
+//
+//   1. `bounds-gemma/parser` — pure parser + validator. No model, no
+//      worker, no DOM. Useful for unit tests, server-side parsing of
+//      a model response captured elsewhere, or building your own
+//      pipeline on top of the validated detection schema.
+//
+//   2. `bounds-gemma/pipeline` — main-thread facade that probes
+//      Ollama and falls back to WebLLM, dispatches jobs to the
+//      Worker, and returns parsed Detection[]. The standard
+//      consumer entry point.
+//
+//   3. `bounds-gemma/worker` — the Web Worker implementation. Bundle
+//      this directly into your application's worker chain if you
+//      want full control over message-passing and lifecycle.
+//
+// The root export is the union: parser symbols + pipeline facade +
+// type names. Use the sub-path imports for tighter bundles.
+export { parseAndValidate, HEALTHCARE_CONFIDENCE_FLOOR, CHUNK_MAX_CHARS, } from './workers/gemmaParse.js';
+export { startGemmaJob, cancelGemmaJob, getGemmaBackend, subscribeGemmaBackend, subscribeGemmaModelProgress, } from './pipeline/GemmaWorker.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,EAAE;AACF,2DAA2D;AAC3D,EAAE;AACF,qEAAqE;AACrE,qEAAqE;AACrE,iEAAiE;AACjE,0DAA0D;AAC1D,EAAE;AACF,gEAAgE;AAChE,+DAA+D;AAC/D,4DAA4D;AAC5D,6BAA6B;AAC7B,EAAE;AACF,qEAAqE;AACrE,iEAAiE;AACjE,6DAA6D;AAC7D,EAAE;AACF,mEAAmE;AACnE,4DAA4D;AAE5D,OAAO,EACL,gBAAgB,EAChB,2BAA2B,EAC3B,eAAe,GAEhB,MAAM,yBAAyB,CAAA;AAEhC,OAAO,EACL,aAAa,EACb,cAAc,EACd,eAAe,EACf,qBAAqB,EACrB,2BAA2B,GAE5B,MAAM,2BAA2B,CAAA","sourcesContent":["// Public API surface for the bounds-gemma npm package.\n//\n// Three entry points that map to three integration shapes:\n//\n//   1. `bounds-gemma/parser` — pure parser + validator. No model, no\n//      worker, no DOM. Useful for unit tests, server-side parsing of\n//      a model response captured elsewhere, or building your own\n//      pipeline on top of the validated detection schema.\n//\n//   2. `bounds-gemma/pipeline` — main-thread facade that probes\n//      Ollama and falls back to WebLLM, dispatches jobs to the\n//      Worker, and returns parsed Detection[]. The standard\n//      consumer entry point.\n//\n//   3. `bounds-gemma/worker` — the Web Worker implementation. Bundle\n//      this directly into your application's worker chain if you\n//      want full control over message-passing and lifecycle.\n//\n// The root export is the union: parser symbols + pipeline facade +\n// type names. Use the sub-path imports for tighter bundles.\n\nexport {\n  parseAndValidate,\n  HEALTHCARE_CONFIDENCE_FLOOR,\n  CHUNK_MAX_CHARS,\n  type RawGemmaDetection,\n} from './workers/gemmaParse.js'\n\nexport {\n  startGemmaJob,\n  cancelGemmaJob,\n  getGemmaBackend,\n  subscribeGemmaBackend,\n  subscribeGemmaModelProgress,\n  type GemmaBackend,\n} from './pipeline/GemmaWorker.js'\n\nexport type {\n  PiiType,\n  DetectionSource,\n  BBox,\n  Detection,\n} from './types/index.js'\n"]}

package/dist/pipeline/GemmaWorker.d.ts

@@ -0,0 +1,63 @@
+import type { Detection, PiiType } from '../types/index.js';
+export interface RawGemmaDetection {
+    text: string;
+    type: PiiType;
+    confidence: number;
+    ruleId: string;
+    reason: string;
+}
+export type GemmaBackend = 'ollama' | 'webllm' | 'unavailable';
+/**
+ * Subscribe to model-load progress (0..1). Returns an unsubscribe function.
+ * Multiple concurrent runs can subscribe; legacy `setGemmaModelProgressCallback`
+ * is kept for backwards compat and behaves as a single-slot subscription.
+ */
+export declare function subscribeGemmaModelProgress(cb: (pct: number) => void): () => void;
+export declare function subscribeGemmaBackend(cb: (backend: GemmaBackend) => void): () => void;
+/** Returns the cached backend if the worker has already probed, else null. */
+export declare function getGemmaBackend(): GemmaBackend | null;
+export declare function setGemmaModelProgressCallback(cb: ((pct: number) => void) | null): void;
+export declare function setGemmaBackendCallback(cb: ((backend: GemmaBackend) => void) | null): void;
+/**
+ * Run Gemma 4 health-PHI detection over a page's extracted text.
+ *
+ * Caller responsibility:
+ *  - Pass clean per-page text (already extracted, regex-stripped of high-
+ *    confidence matches to avoid sending duplicate work to the model).
+ *  - Chunk pages longer than 1800 characters before calling; the worker
+ *    re-chunks at 800-char paragraph boundaries internally but a very
+ *    large page increases hallucination surface area.
+ *
+ * Returns RawGemmaDetection candidates with confidence already filtered
+ * to >= 0.75 (the healthcare floor; raise via setGemmaConfidenceFloor if
+ * a more conservative deployment is needed).
+ *
+ * Returns the job id alongside the promise so callers that need a timeout
+ * can call cancelGemmaJob(id) to drop the pending job and prevent the
+ * worker reply from being mis-routed to a new caller that reuses the
+ * same job map slot.
+ */
+export interface GemmaJobHandle {
+    jobId: number;
+    result: Promise<RawGemmaDetection[]>;
+}
+export declare function detectHealthPhi(text: string, pageIndex: number): Promise<RawGemmaDetection[]>;
+export declare function startGemmaJob(text: string, pageIndex: number): GemmaJobHandle;
+/**
+ * Drop a pending job so a late worker reply is discarded silently rather
+ * than being routed to a stale resolver. Safe to call on a job that has
+ * already settled (no-op).
+ */
+export declare function cancelGemmaJob(jobId: number): void;
+/** Tear down the worker. Used by tests and on unmount. */
+export declare function disposeGemmaWorker(): void;
+/**
+ * Convert raw Gemma detections to typed Detection records ready for
+ * RedactionPipeline merging. The caller still needs to resolve bounding
+ * boxes via findSpanBBox, generate the redaction token, and de-duplicate
+ * against existing regex/NER detections at >= 0.90 confidence.
+ *
+ * Detections are emitted with source='GEMMA' and enabled=false so they
+ * appear unchecked in the review panel (the user opts in per item).
+ */
+export declare function rawToDetection(raw: RawGemmaDetection, pageIndex: number, id: string, token: string): Detection;

package/dist/pipeline/GemmaWorker.js

@@ -0,0 +1,158 @@
+let _worker = null;
+let _jobCounter = 0;
+const _pendingJobs = new Map();
+const _modelProgressSubs = new Set();
+const _backendSubs = new Set();
+// Once the worker has reported a backend, hold it. The worker probes once
+// per worker lifetime; a later run can synchronously call getGemmaBackend()
+// to learn the cached state instead of waiting for a re-probe message.
+let _resolvedBackend = null;
+/**
+ * Subscribe to model-load progress (0..1). Returns an unsubscribe function.
+ * Multiple concurrent runs can subscribe; legacy `setGemmaModelProgressCallback`
+ * is kept for backwards compat and behaves as a single-slot subscription.
+ */
+export function subscribeGemmaModelProgress(cb) {
+    _modelProgressSubs.add(cb);
+    return () => _modelProgressSubs.delete(cb);
+}
+export function subscribeGemmaBackend(cb) {
+    _backendSubs.add(cb);
+    // Replay the cached backend immediately so a late subscriber learns the
+    // already-resolved state without waiting for a re-probe.
+    if (_resolvedBackend !== null) {
+        queueMicrotask(() => {
+            if (_backendSubs.has(cb))
+                cb(_resolvedBackend);
+        });
+    }
+    return () => _backendSubs.delete(cb);
+}
+/** Returns the cached backend if the worker has already probed, else null. */
+export function getGemmaBackend() {
+    return _resolvedBackend;
+}
+// ---------------------------------------------------------------------------
+// Legacy single-slot APIs. Kept so existing callers (and tests) keep working.
+// New code should prefer subscribeGemmaBackend / subscribeGemmaModelProgress.
+// ---------------------------------------------------------------------------
+let _modelProgressLegacy = null;
+let _backendLegacy = null;
+export function setGemmaModelProgressCallback(cb) {
+    if (_modelProgressLegacy)
+        _modelProgressSubs.delete(_modelProgressLegacy);
+    _modelProgressLegacy = cb;
+    if (cb)
+        _modelProgressSubs.add(cb);
+}
+export function setGemmaBackendCallback(cb) {
+    if (_backendLegacy)
+        _backendSubs.delete(_backendLegacy);
+    _backendLegacy = cb;
+    if (cb) {
+        _backendSubs.add(cb);
+        if (_resolvedBackend !== null)
+            queueMicrotask(() => cb(_resolvedBackend));
+    }
+}
+function getWorker() {
+    if (!_worker) {
+        _worker = new Worker(new URL('../workers/gemma.worker.ts', import.meta.url), { type: 'module' });
+        _worker.onmessage = (e) => {
+            if (e.data.type === 'progress') {
+                const pct = e.data.progress ?? 0;
+                for (const sub of _modelProgressSubs)
+                    sub(pct);
+                return;
+            }
+            if (e.data.type === 'backend') {
+                const backend = e.data.backend ?? 'unavailable';
+                // Cache the first backend resolution; ignore subsequent duplicates
+                // so a late race message cannot overwrite the settled value.
+                if (_resolvedBackend === null)
+                    _resolvedBackend = backend;
+                for (const sub of _backendSubs)
+                    sub(_resolvedBackend);
+                return;
+            }
+            if (e.data.ready)
+                return;
+            const id = e.data.id;
+            if (typeof id !== 'number')
+                return;
+            const job = _pendingJobs.get(id);
+            if (!job)
+                return;
+            _pendingJobs.delete(id);
+            if (e.data.error) {
+                job.reject(new Error(e.data.error));
+                return;
+            }
+            job.resolve(e.data.detections ?? []);
+        };
+        _worker.onerror = (e) => {
+            // Reject all pending jobs on worker crash.
+            const err = new Error(`GemmaWorker crashed: ${e.message}`);
+            for (const job of _pendingJobs.values()) {
+                job.reject(err);
+            }
+            _pendingJobs.clear();
+            _worker = null;
+        };
+    }
+    return _worker;
+}
+export function detectHealthPhi(text, pageIndex) {
+    return startGemmaJob(text, pageIndex).result;
+}
+export function startGemmaJob(text, pageIndex) {
+    const id = ++_jobCounter;
+    const result = new Promise((resolve, reject) => {
+        const job = { id, text, pageIndex, resolve, reject };
+        _pendingJobs.set(id, job);
+        getWorker().postMessage({ id, text, pageIndex });
+    });
+    return { jobId: id, result };
+}
+/**
+ * Drop a pending job so a late worker reply is discarded silently rather
+ * than being routed to a stale resolver. Safe to call on a job that has
+ * already settled (no-op).
+ */
+export function cancelGemmaJob(jobId) {
+    _pendingJobs.delete(jobId);
+}
+/** Tear down the worker. Used by tests and on unmount. */
+export function disposeGemmaWorker() {
+    if (_worker) {
+        _worker.terminate();
+        _worker = null;
+    }
+    _pendingJobs.clear();
+    _resolvedBackend = null;
+}
+/**
+ * Convert raw Gemma detections to typed Detection records ready for
+ * RedactionPipeline merging. The caller still needs to resolve bounding
+ * boxes via findSpanBBox, generate the redaction token, and de-duplicate
+ * against existing regex/NER detections at >= 0.90 confidence.
+ *
+ * Detections are emitted with source='GEMMA' and enabled=false so they
+ * appear unchecked in the review panel (the user opts in per item).
+ */
+export function rawToDetection(raw, pageIndex, id, token) {
+    return {
+        id,
+        type: raw.type,
+        text: raw.text,
+        token,
+        pageIndex,
+        boundingBox: { x: 0, y: 0, width: 0, height: 0 }, // resolved later
+        confidence: raw.confidence,
+        source: 'GEMMA',
+        enabled: false,
+        ruleId: raw.ruleId,
+        reason: raw.reason,
+    };
+}
+//# sourceMappingURL=GemmaWorker.js.map

package/dist/pipeline/GemmaWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GemmaWorker.js","sourceRoot":"","sources":["../../src/pipeline/GemmaWorker.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Detection, PiiType } from '../types/index.js'\n\n// ---------------------------------------------------------------------------\n// GemmaWorker, main-thread facade for the gemma.worker.ts Web Worker.\n//\n// Catches context-sensitive PHI that the regex / NER / OCR layers miss:\n// inline diagnoses without a label, medication mentions in prose,\n// indirect health context (\"my insulin pump\"), genetic data references,\n// and other HIPAA Safe Harbor catch-all (item 17) candidates that have no\n// stable surface pattern.\n//\n// Two execution paths:\n//\n//   1. Ollama at localhost:11434 (preferred for the demo audience and\n//      production users who install it). Faster, better quality, smaller\n//      browser footprint. Probed at startup; if reachable the worker uses\n//      Ollama for all subsequent calls.\n//\n//   2. WebLLM with Gemma 4 E2B Instruct (fallback when Ollama is absent).\n//      Loads model weights from the MLC CDN on first use, caches them in\n//      browser storage. No additional install for the user but the first\n//      call is slow.\n//\n// Privacy posture: page text never leaves the browser process or\n// localhost:11434. Model weights are read-only fetches from a model CDN\n// (one-off on first WebLLM use, never accompanied by document data).\n// ---------------------------------------------------------------------------\n\ninterface GemmaJob {\n  id: number\n  text: string\n  pageIndex: number\n  resolve: (detections: RawGemmaDetection[]) => void\n  reject: (err: Error) => void\n}\n\nexport interface RawGemmaDetection {\n  text: string\n  type: PiiType\n  confidence: number\n  ruleId: string\n  reason: string\n}\n\nexport type GemmaBackend = 'ollama' | 'webllm' | 'unavailable'\n\nlet _worker: Worker | null = null\nlet _jobCounter = 0\nconst _pendingJobs = new Map<number, GemmaJob>()\nconst _modelProgressSubs = new Set<(pct: number) => void>()\nconst _backendSubs = new Set<(backend: GemmaBackend) => void>()\n// Once the worker has reported a backend, hold it. The worker probes once\n// per worker lifetime; a later run can synchronously call getGemmaBackend()\n// to learn the cached state instead of waiting for a re-probe message.\nlet _resolvedBackend: GemmaBackend | null = null\n\n/**\n * Subscribe to model-load progress (0..1). Returns an unsubscribe function.\n * Multiple concurrent runs can subscribe; legacy `setGemmaModelProgressCallback`\n * is kept for backwards compat and behaves as a single-slot subscription.\n */\nexport function subscribeGemmaModelProgress(cb: (pct: number) => void): () => void {\n  _modelProgressSubs.add(cb)\n  return () => _modelProgressSubs.delete(cb)\n}\n\nexport function subscribeGemmaBackend(cb: (backend: GemmaBackend) => void): () => void {\n  _backendSubs.add(cb)\n  // Replay the cached backend immediately so a late subscriber learns the\n  // already-resolved state without waiting for a re-probe.\n  if (_resolvedBackend !== null) {\n    queueMicrotask(() => {\n      if (_backendSubs.has(cb)) cb(_resolvedBackend!)\n    })\n  }\n  return () => _backendSubs.delete(cb)\n}\n\n/** Returns the cached backend if the worker has already probed, else null. */\nexport function getGemmaBackend(): GemmaBackend | null {\n  return _resolvedBackend\n}\n\n// ---------------------------------------------------------------------------\n// Legacy single-slot APIs. Kept so existing callers (and tests) keep working.\n// New code should prefer subscribeGemmaBackend / subscribeGemmaModelProgress.\n// ---------------------------------------------------------------------------\nlet _modelProgressLegacy: ((pct: number) => void) | null = null\nlet _backendLegacy: ((backend: GemmaBackend) => void) | null = null\n\nexport function setGemmaModelProgressCallback(cb: ((pct: number) => void) | null): void {\n  if (_modelProgressLegacy) _modelProgressSubs.delete(_modelProgressLegacy)\n  _modelProgressLegacy = cb\n  if (cb) _modelProgressSubs.add(cb)\n}\n\nexport function setGemmaBackendCallback(cb: ((backend: GemmaBackend) => void) | null): void {\n  if (_backendLegacy) _backendSubs.delete(_backendLegacy)\n  _backendLegacy = cb\n  if (cb) {\n    _backendSubs.add(cb)\n    if (_resolvedBackend !== null) queueMicrotask(() => cb(_resolvedBackend!))\n  }\n}\n\nfunction getWorker(): Worker {\n  if (!_worker) {\n    _worker = new Worker(new URL('../workers/gemma.worker.ts', import.meta.url), { type: 'module' })\n    _worker.onmessage = (e: MessageEvent<{\n      id?: number\n      detections?: RawGemmaDetection[]\n      error?: string\n      ready?: boolean\n      type?: string\n      progress?: number\n      backend?: GemmaBackend\n    }>) => {\n      if (e.data.type === 'progress') {\n        const pct = e.data.progress ?? 0\n        for (const sub of _modelProgressSubs) sub(pct)\n        return\n      }\n      if (e.data.type === 'backend') {\n        const backend = e.data.backend ?? 'unavailable'\n        // Cache the first backend resolution; ignore subsequent duplicates\n        // so a late race message cannot overwrite the settled value.\n        if (_resolvedBackend === null) _resolvedBackend = backend\n        for (const sub of _backendSubs) sub(_resolvedBackend)\n        return\n      }\n      if (e.data.ready) return\n\n      const id = e.data.id\n      if (typeof id !== 'number') return\n      const job = _pendingJobs.get(id)\n      if (!job) return\n      _pendingJobs.delete(id)\n\n      if (e.data.error) {\n        job.reject(new Error(e.data.error))\n        return\n      }\n      job.resolve(e.data.detections ?? [])\n    }\n    _worker.onerror = (e: ErrorEvent) => {\n      // Reject all pending jobs on worker crash.\n      const err = new Error(`GemmaWorker crashed: ${e.message}`)\n      for (const job of _pendingJobs.values()) {\n        job.reject(err)\n      }\n      _pendingJobs.clear()\n      _worker = null\n    }\n  }\n  return _worker\n}\n\n/**\n * Run Gemma 4 health-PHI detection over a page's extracted text.\n *\n * Caller responsibility:\n *  - Pass clean per-page text (already extracted, regex-stripped of high-\n *    confidence matches to avoid sending duplicate work to the model).\n *  - Chunk pages longer than 1800 characters before calling; the worker\n *    re-chunks at 800-char paragraph boundaries internally but a very\n *    large page increases hallucination surface area.\n *\n * Returns RawGemmaDetection candidates with confidence already filtered\n * to >= 0.75 (the healthcare floor; raise via setGemmaConfidenceFloor if\n * a more conservative deployment is needed).\n *\n * Returns the job id alongside the promise so callers that need a timeout\n * can call cancelGemmaJob(id) to drop the pending job and prevent the\n * worker reply from being mis-routed to a new caller that reuses the\n * same job map slot.\n */\nexport interface GemmaJobHandle {\n  jobId: number\n  result: Promise<RawGemmaDetection[]>\n}\n\nexport function detectHealthPhi(text: string, pageIndex: number): Promise<RawGemmaDetection[]> {\n  return startGemmaJob(text, pageIndex).result\n}\n\nexport function startGemmaJob(text: string, pageIndex: number): GemmaJobHandle {\n  const id = ++_jobCounter\n  const result = new Promise<RawGemmaDetection[]>((resolve, reject) => {\n    const job: GemmaJob = { id, text, pageIndex, resolve, reject }\n    _pendingJobs.set(id, job)\n    getWorker().postMessage({ id, text, pageIndex })\n  })\n  return { jobId: id, result }\n}\n\n/**\n * Drop a pending job so a late worker reply is discarded silently rather\n * than being routed to a stale resolver. Safe to call on a job that has\n * already settled (no-op).\n */\nexport function cancelGemmaJob(jobId: number): void {\n  _pendingJobs.delete(jobId)\n}\n\n/** Tear down the worker. Used by tests and on unmount. */\nexport function disposeGemmaWorker(): void {\n  if (_worker) {\n    _worker.terminate()\n    _worker = null\n  }\n  _pendingJobs.clear()\n  _resolvedBackend = null\n}\n\n/**\n * Convert raw Gemma detections to typed Detection records ready for\n * RedactionPipeline merging. The caller still needs to resolve bounding\n * boxes via findSpanBBox, generate the redaction token, and de-duplicate\n * against existing regex/NER detections at >= 0.90 confidence.\n *\n * Detections are emitted with source='GEMMA' and enabled=false so they\n * appear unchecked in the review panel (the user opts in per item).\n */\nexport function rawToDetection(raw: RawGemmaDetection, pageIndex: number, id: string, token: string): Detection {\n  return {\n    id,\n    type: raw.type,\n    text: raw.text,\n    token,\n    pageIndex,\n    boundingBox: { x: 0, y: 0, width: 0, height: 0 }, // resolved later\n    confidence: raw.confidence,\n    source: 'GEMMA',\n    enabled: false,\n    ruleId: raw.ruleId,\n    reason: raw.reason,\n  }\n}\n"]}

package/dist/types/index.d.ts

@@ -0,0 +1,32 @@
+export type PiiType = 'PERSON' | 'ADDRESS' | 'EMAIL' | 'PHONE' | 'IBAN' | 'SSN' | 'PASSPORT' | 'ID_NUMBER' | 'DATE_OF_BIRTH' | 'IP_ADDRESS' | 'CREDIT_CARD' | 'URL' | 'ORG' | 'MISC' | 'HEALTH_DATA' | 'CONFIDENTIAL' | 'PROPRIETARY' | 'LEGAL_CLAUSE';
+export type DetectionSource = 'NER' | 'REGEX' | 'OCR' | 'MANUAL' | 'FACE' | 'GEMMA';
+export interface BBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * The shape consumers of this toolkit emit and aggregate. Mirrors the
+ * production redaction schema. Gemma-produced detections set
+ * `source: 'GEMMA'`, `enabled: false` (reviewer must opt in per item),
+ * and `ruleId` to one of the six healthcare PHI category ids the
+ * worker is constrained to.
+ */
+export interface Detection {
+    id: string;
+    type: PiiType;
+    text: string;
+    /** Replacement token used during PDF redaction, e.g. "[HEALTH_DATA_001]". */
+    token: string;
+    pageIndex: number;
+    boundingBox: BBox;
+    /** 0 to 1; healthcare detections enforce a confidence floor of 0.75. */
+    confidence: number;
+    source: DetectionSource;
+    /** UI default: false for Gemma; reviewer opts in per item. */
+    enabled: boolean;
+    ruleId?: string;
+    /** One-sentence human-readable justification surfaced in the review UI. */
+    reason?: string;
+}

package/dist/types/index.js

@@ -0,0 +1,5 @@
+// Minimal types for the Gemma 4 PHI redaction toolkit. Mirrors the
+// upstream Bounds Pro production schema so that consumers can drop
+// either implementation in without changing call sites.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,mEAAmE;AACnE,wDAAwD","sourcesContent":["// Minimal types for the Gemma 4 PHI redaction toolkit. Mirrors the\n// upstream Bounds Pro production schema so that consumers can drop\n// either implementation in without changing call sites.\n\nexport type PiiType =\n  | 'PERSON'\n  | 'ADDRESS'\n  | 'EMAIL'\n  | 'PHONE'\n  | 'IBAN'\n  | 'SSN'\n  | 'PASSPORT'\n  | 'ID_NUMBER'\n  | 'DATE_OF_BIRTH'\n  | 'IP_ADDRESS'\n  | 'CREDIT_CARD'\n  | 'URL'\n  | 'ORG'\n  | 'MISC'\n  | 'HEALTH_DATA'\n  | 'CONFIDENTIAL'\n  | 'PROPRIETARY'\n  | 'LEGAL_CLAUSE'\n\nexport type DetectionSource =\n  | 'NER'\n  | 'REGEX'\n  | 'OCR'\n  | 'MANUAL'\n  | 'FACE'\n  | 'GEMMA'\n\nexport interface BBox {\n  x: number\n  y: number\n  width: number\n  height: number\n}\n\n/**\n * The shape consumers of this toolkit emit and aggregate. Mirrors the\n * production redaction schema. Gemma-produced detections set\n * `source: 'GEMMA'`, `enabled: false` (reviewer must opt in per item),\n * and `ruleId` to one of the six healthcare PHI category ids the\n * worker is constrained to.\n */\nexport interface Detection {\n  id: string\n  type: PiiType\n  text: string\n  /** Replacement token used during PDF redaction, e.g. \"[HEALTH_DATA_001]\". */\n  token: string\n  pageIndex: number\n  boundingBox: BBox\n  /** 0 to 1; healthcare detections enforce a confidence floor of 0.75. */\n  confidence: number\n  source: DetectionSource\n  /** UI default: false for Gemma; reviewer opts in per item. */\n  enabled: boolean\n  ruleId?: string\n  /** One-sentence human-readable justification surfaced in the review UI. */\n  reason?: string\n}\n"]}

package/dist/workers/gemma.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workers/gemma.worker.js

@@ -0,0 +1,202 @@
+// Gemma Web Worker. Runs Gemma 4 nano either via Ollama at
+// localhost:11434 (preferred) or via WebLLM in-browser (fallback).
+//
+// Catches the six context-sensitive health-PHI categories that the
+// regex / NER / OCR layers miss:
+//   1. Inline diagnosis without a structured label
+//      ("presents with generalised anxiety disorder")
+//   2. Medication mention in running prose
+//      ("she is on lithium and has been taking Adderall for three years")
+//   3. Treatment / procedure in narrative
+//      ("underwent CABG last April, followed by chemo")
+//   4. Indirect health context
+//      ("my therapist", "my insulin pump", "my dialysis centre")
+//   5. Sensitive social context
+//      ("gay male patient", "identifies as non-binary")
+//   6. Genetic data references
+//      ("BRCA1-positive", "family history of Huntington's")
+//
+// Output contract: a JSON array of {text, type, confidence, reason}
+// objects, rejected if the model emits malformed JSON or candidates
+// with confidence below the healthcare floor.
+import { HEALTHCARE_CONFIDENCE_FLOOR, chunkText, parseAndValidate, } from './gemmaParse.js';
+let _backend = 'unavailable';
+let _backendDetected = false;
+const SYSTEM_PROMPT = `You are a healthcare privacy auditor. The following is text extracted from a PDF page that may contain protected health information (PHI). Your job is to flag spans that contain PHI a regex or named-entity recogniser would MISS, focusing on these six categories ONLY:
+
+  1. inline_diagnosis        Inline diagnosis without a structured label (e.g. "presents with generalised anxiety disorder").
+  2. medication_mention      Medication name in running prose, not after a "Medications:" label (e.g. "she is on lithium").
+  3. treatment_procedure     Treatment, procedure, or surgery mentioned in narrative (e.g. "underwent CABG last April").
+  4. indirect_health_context Indirect references that imply health condition (e.g. "my therapist", "my insulin pump").
+  5. sensitive_social        Sensitive social-category data (sexuality, gender identity, religion).
+  6. genetic_reference       Genetic test results or family history (e.g. "BRCA1-positive", "father had Huntington's").
+
+For each span you flag, return ONE entry in a JSON array:
+
+  {
+    "text":       "<the exact span as it appears in the input, byte-identical>",
+    "type":       "HEALTH_DATA",
+    "confidence": <0.0 to 1.0>,
+    "ruleId":     "gemma:<one of the six category ids above>",
+    "reason":     "<one short sentence explaining why this span is PHI a reviewer should consider>"
+  }
+
+Rules:
+- Return ONLY a JSON array. No prose, no markdown, no preamble.
+- If no PHI is present, return [].
+- Confidence MUST be at least ${HEALTHCARE_CONFIDENCE_FLOOR}. Below that, omit the span.
+- The text field MUST appear verbatim in the input. Do NOT paraphrase, expand, or correct.
+- DO NOT flag patient names, dates, addresses, MRNs, phone numbers, emails, or other structured PHI; the regex and NER layers handle those. Your job is contextual content only.
+- If you are unsure, leave the span out. False positives in healthcare are worse than false negatives at this stage.`;
+async function probeOllama() {
+    try {
+        const res = await fetch('http://localhost:11434/api/tags', {
+            method: 'GET',
+            signal: AbortSignal.timeout(1500),
+        });
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        if (!Array.isArray(data.models))
+            return false;
+        return data.models.some((m) => m.name.startsWith('gemma4:e2b') || m.name.startsWith('gemma4'));
+    }
+    catch {
+        return false;
+    }
+}
+async function detectBackend() {
+    if (_backendDetected)
+        return _backend;
+    if (await probeOllama()) {
+        _backend = 'ollama';
+    }
+    else if (typeof self !== 'undefined' && self.crossOriginIsolated) {
+        // WebLLM uses WebGPU + SharedArrayBuffer + multi-threaded WASM. All
+        // three require the page (and therefore this worker) to be served
+        // under cross-origin isolation (COOP: same-origin + COEP: require-corp).
+        // If the deployment skipped those headers, surface that up front rather
+        // than attempting a load that will fail mid-stream.
+        _backend = 'webllm';
+    }
+    else {
+        _backend = 'unavailable';
+    }
+    _backendDetected = true;
+    postMessage({ type: 'backend', backend: _backend });
+    return _backend;
+}
+async function callOllama(chunk) {
+    const res = await fetch('http://localhost:11434/api/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model: 'gemma4:e2b',
+            messages: [
+                { role: 'system', content: SYSTEM_PROMPT },
+                { role: 'user', content: chunk },
+            ],
+            stream: false,
+            // Gemma 4 has chain-of-thought reasoning enabled by default in
+            // Ollama; those thinking tokens count against num_predict and
+            // truncated our test output mid-JSON-entry at the old 600 cap.
+            // Disable thinking (think:false) AND bump num_predict to 2048 so
+            // the visible JSON has room to complete on a full clinical page.
+            think: false,
+            options: {
+                temperature: 0.1,
+                num_predict: 2048,
+            },
+            format: 'json',
+        }),
+        signal: AbortSignal.timeout(90_000),
+    });
+    if (!res.ok) {
+        throw new Error(`Ollama returned ${res.status}: ${await res.text()}`);
+    }
+    const data = (await res.json());
+    const raw = data.message?.content ?? data.response ?? '';
+    return parseAndValidate(raw, chunk);
+}
+// WebLLM lazy-load state. We dynamic-import the runtime on first use so the
+// model weights are not pulled into the worker startup bundle, and so a
+// deployment that never lands on a Gemma-required document never pays the
+// download cost.
+//
+// Default model id resolves to Gemma 4 E2B Instruct, q4f16_1 quantisation
+// (stock community release, validated 2026-04-13). Override via the build-
+// time env var VITE_BOUNDS_GEMMA_MODEL_ID to swap in a custom fine-tune;
+// pointing at huggingface.co/Aqta-ai/bounds-gemma-e2b-phi-ft/resolve/...
+// loads our domain-tuned model in place of stock. Requires WebGPU +
+// shader-f16 feature in the browser.
+const WEBLLM_MODEL_ID = (typeof import.meta !== 'undefined' &&
+    import.meta.env?.VITE_BOUNDS_GEMMA_MODEL_ID) ||
+    'gemma-4-E2B-it-q4f16_1-MLC';
+let _webllmEngine = null;
+let _webllmLoading = null;
+async function loadWebLLM() {
+    if (_webllmEngine)
+        return _webllmEngine;
+    if (_webllmLoading)
+        return _webllmLoading;
+    _webllmLoading = (async () => {
+        // Dynamic import keeps WebLLM out of the worker startup bundle. The
+        // import path is the package's runtime entry; @mlc-ai/web-llm exposes
+        // CreateMLCEngine for a one-call "load model + return engine" flow.
+        const webllm = (await import('@mlc-ai/web-llm'));
+        const engine = await webllm.CreateMLCEngine(WEBLLM_MODEL_ID, {
+            initProgressCallback: (info) => {
+                const pct = typeof info.progress === 'number' ? info.progress : 0;
+                postMessage({ type: 'progress', progress: pct });
+            },
+        });
+        _webllmEngine = engine;
+        return engine;
+    })();
+    try {
+        return await _webllmLoading;
+    }
+    finally {
+        _webllmLoading = null;
+    }
+}
+async function callWebLLM(chunk) {
+    const engine = await loadWebLLM();
+    const completion = await engine.chat.completions.create({
+        messages: [
+            { role: 'system', content: SYSTEM_PROMPT },
+            { role: 'user', content: chunk },
+        ],
+        temperature: 0.1,
+        max_tokens: 600,
+    });
+    const raw = completion.choices?.[0]?.message?.content ?? '';
+    return parseAndValidate(raw, chunk);
+}
+self.onmessage = async (e) => {
+    const { id, text } = e.data;
+    try {
+        const backend = await detectBackend();
+        if (backend === 'unavailable') {
+            postMessage({
+                id,
+                error: 'No Gemma 4 backend available. Install Ollama with `ollama pull gemma4:e2b` and start the daemon, or serve the app under cross-origin isolation (COOP same-origin + COEP require-corp) so the in-browser WebLLM fallback can load.',
+            });
+            return;
+        }
+        const chunks = chunkText(text);
+        const all = [];
+        for (let i = 0; i < chunks.length; i++) {
+            postMessage({ type: 'progress', progress: i / chunks.length });
+            const chunk = chunks[i];
+            const detections = backend === 'ollama' ? await callOllama(chunk) : await callWebLLM(chunk);
+            all.push(...detections);
+        }
+        postMessage({ id, detections: all });
+    }
+    catch (err) {
+        postMessage({ id, error: err instanceof Error ? err.message : String(err) });
+    }
+};
+postMessage({ ready: true });
+//# sourceMappingURL=gemma.worker.js.map

package/dist/workers/gemma.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemma.worker.js","sourceRoot":"","sources":["../../src/workers/gemma.worker.ts"],"names":[],"mappings":"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","sourcesContent":["// Gemma Web Worker. Runs Gemma 4 nano either via Ollama at\n// localhost:11434 (preferred) or via WebLLM in-browser (fallback).\n//\n// Catches the six context-sensitive health-PHI categories that the\n// regex / NER / OCR layers miss:\n//   1. Inline diagnosis without a structured label\n//      (\"presents with generalised anxiety disorder\")\n//   2. Medication mention in running prose\n//      (\"she is on lithium and has been taking Adderall for three years\")\n//   3. Treatment / procedure in narrative\n//      (\"underwent CABG last April, followed by chemo\")\n//   4. Indirect health context\n//      (\"my therapist\", \"my insulin pump\", \"my dialysis centre\")\n//   5. Sensitive social context\n//      (\"gay male patient\", \"identifies as non-binary\")\n//   6. Genetic data references\n//      (\"BRCA1-positive\", \"family history of Huntington's\")\n//\n// Output contract: a JSON array of {text, type, confidence, reason}\n// objects, rejected if the model emits malformed JSON or candidates\n// with confidence below the healthcare floor.\n\nimport {\n  HEALTHCARE_CONFIDENCE_FLOOR,\n  chunkText,\n  parseAndValidate,\n  type RawGemmaDetection,\n} from './gemmaParse.js'\n\ntype GemmaBackend = 'ollama' | 'webllm' | 'unavailable'\n\nlet _backend: GemmaBackend = 'unavailable'\nlet _backendDetected = false\n\nconst SYSTEM_PROMPT = `You are a healthcare privacy auditor. The following is text extracted from a PDF page that may contain protected health information (PHI). Your job is to flag spans that contain PHI a regex or named-entity recogniser would MISS, focusing on these six categories ONLY:\n\n  1. inline_diagnosis        Inline diagnosis without a structured label (e.g. \"presents with generalised anxiety disorder\").\n  2. medication_mention      Medication name in running prose, not after a \"Medications:\" label (e.g. \"she is on lithium\").\n  3. treatment_procedure     Treatment, procedure, or surgery mentioned in narrative (e.g. \"underwent CABG last April\").\n  4. indirect_health_context Indirect references that imply health condition (e.g. \"my therapist\", \"my insulin pump\").\n  5. sensitive_social        Sensitive social-category data (sexuality, gender identity, religion).\n  6. genetic_reference       Genetic test results or family history (e.g. \"BRCA1-positive\", \"father had Huntington's\").\n\nFor each span you flag, return ONE entry in a JSON array:\n\n  {\n    \"text\":       \"<the exact span as it appears in the input, byte-identical>\",\n    \"type\":       \"HEALTH_DATA\",\n    \"confidence\": <0.0 to 1.0>,\n    \"ruleId\":     \"gemma:<one of the six category ids above>\",\n    \"reason\":     \"<one short sentence explaining why this span is PHI a reviewer should consider>\"\n  }\n\nRules:\n- Return ONLY a JSON array. No prose, no markdown, no preamble.\n- If no PHI is present, return [].\n- Confidence MUST be at least ${HEALTHCARE_CONFIDENCE_FLOOR}. Below that, omit the span.\n- The text field MUST appear verbatim in the input. Do NOT paraphrase, expand, or correct.\n- DO NOT flag patient names, dates, addresses, MRNs, phone numbers, emails, or other structured PHI; the regex and NER layers handle those. Your job is contextual content only.\n- If you are unsure, leave the span out. False positives in healthcare are worse than false negatives at this stage.`\n\nasync function probeOllama(): Promise<boolean> {\n  try {\n    const res = await fetch('http://localhost:11434/api/tags', {\n      method: 'GET',\n      signal: AbortSignal.timeout(1500),\n    })\n    if (!res.ok) return false\n    const data: { models?: Array<{ name: string }> } = await res.json()\n    if (!Array.isArray(data.models)) return false\n    return data.models.some((m) => m.name.startsWith('gemma4:e2b') || m.name.startsWith('gemma4'))\n  } catch {\n    return false\n  }\n}\n\nasync function detectBackend(): Promise<GemmaBackend> {\n  if (_backendDetected) return _backend\n  if (await probeOllama()) {\n    _backend = 'ollama'\n  } else if (typeof self !== 'undefined' && (self as unknown as { crossOriginIsolated?: boolean }).crossOriginIsolated) {\n    // WebLLM uses WebGPU + SharedArrayBuffer + multi-threaded WASM. All\n    // three require the page (and therefore this worker) to be served\n    // under cross-origin isolation (COOP: same-origin + COEP: require-corp).\n    // If the deployment skipped those headers, surface that up front rather\n    // than attempting a load that will fail mid-stream.\n    _backend = 'webllm'\n  } else {\n    _backend = 'unavailable'\n  }\n  _backendDetected = true\n  postMessage({ type: 'backend', backend: _backend })\n  return _backend\n}\n\ninterface OllamaResponse {\n  message?: { content?: string }\n  response?: string\n}\n\nasync function callOllama(chunk: string): Promise<RawGemmaDetection[]> {\n  const res = await fetch('http://localhost:11434/api/chat', {\n    method: 'POST',\n    headers: { 'Content-Type': 'application/json' },\n    body: JSON.stringify({\n      model: 'gemma4:e2b',\n      messages: [\n        { role: 'system', content: SYSTEM_PROMPT },\n        { role: 'user', content: chunk },\n      ],\n      stream: false,\n      // Gemma 4 has chain-of-thought reasoning enabled by default in\n      // Ollama; those thinking tokens count against num_predict and\n      // truncated our test output mid-JSON-entry at the old 600 cap.\n      // Disable thinking (think:false) AND bump num_predict to 2048 so\n      // the visible JSON has room to complete on a full clinical page.\n      think: false,\n      options: {\n        temperature: 0.1,\n        num_predict: 2048,\n      },\n      format: 'json',\n    }),\n    signal: AbortSignal.timeout(90_000),\n  })\n  if (!res.ok) {\n    throw new Error(`Ollama returned ${res.status}: ${await res.text()}`)\n  }\n  const data = (await res.json()) as OllamaResponse\n  const raw = data.message?.content ?? data.response ?? ''\n  return parseAndValidate(raw, chunk)\n}\n\n// WebLLM lazy-load state. We dynamic-import the runtime on first use so the\n// model weights are not pulled into the worker startup bundle, and so a\n// deployment that never lands on a Gemma-required document never pays the\n// download cost.\n//\n// Default model id resolves to Gemma 4 E2B Instruct, q4f16_1 quantisation\n// (stock community release, validated 2026-04-13). Override via the build-\n// time env var VITE_BOUNDS_GEMMA_MODEL_ID to swap in a custom fine-tune;\n// pointing at huggingface.co/Aqta-ai/bounds-gemma-e2b-phi-ft/resolve/...\n// loads our domain-tuned model in place of stock. Requires WebGPU +\n// shader-f16 feature in the browser.\nconst WEBLLM_MODEL_ID =\n  (typeof import.meta !== 'undefined' &&\n    (import.meta as { env?: Record<string, string> }).env?.VITE_BOUNDS_GEMMA_MODEL_ID) ||\n  'gemma-4-E2B-it-q4f16_1-MLC'\n\ninterface WebLLMEngine {\n  chat: {\n    completions: {\n      create(req: {\n        messages: Array<{ role: string; content: string }>\n        temperature?: number\n        max_tokens?: number\n      }): Promise<{\n        choices: Array<{ message: { content?: string | null } }>\n      }>\n    }\n  }\n}\n\nlet _webllmEngine: WebLLMEngine | null = null\nlet _webllmLoading: Promise<WebLLMEngine> | null = null\n\nasync function loadWebLLM(): Promise<WebLLMEngine> {\n  if (_webllmEngine) return _webllmEngine\n  if (_webllmLoading) return _webllmLoading\n\n  _webllmLoading = (async () => {\n    // Dynamic import keeps WebLLM out of the worker startup bundle. The\n    // import path is the package's runtime entry; @mlc-ai/web-llm exposes\n    // CreateMLCEngine for a one-call \"load model + return engine\" flow.\n    const webllm = (await import('@mlc-ai/web-llm')) as unknown as {\n      CreateMLCEngine: (\n        modelId: string,\n        opts?: {\n          initProgressCallback?: (info: { progress?: number; text?: string }) => void\n        },\n      ) => Promise<WebLLMEngine>\n    }\n\n    const engine = await webllm.CreateMLCEngine(WEBLLM_MODEL_ID, {\n      initProgressCallback: (info) => {\n        const pct = typeof info.progress === 'number' ? info.progress : 0\n        postMessage({ type: 'progress', progress: pct })\n      },\n    })\n\n    _webllmEngine = engine\n    return engine\n  })()\n\n  try {\n    return await _webllmLoading\n  } finally {\n    _webllmLoading = null\n  }\n}\n\nasync function callWebLLM(chunk: string): Promise<RawGemmaDetection[]> {\n  const engine = await loadWebLLM()\n  const completion = await engine.chat.completions.create({\n    messages: [\n      { role: 'system', content: SYSTEM_PROMPT },\n      { role: 'user', content: chunk },\n    ],\n    temperature: 0.1,\n    max_tokens: 600,\n  })\n  const raw = completion.choices?.[0]?.message?.content ?? ''\n  return parseAndValidate(raw, chunk)\n}\n\nself.onmessage = async (e: MessageEvent<{ id: number; text: string; pageIndex: number }>) => {\n  const { id, text } = e.data\n  try {\n    const backend = await detectBackend()\n    if (backend === 'unavailable') {\n      postMessage({\n        id,\n        error: 'No Gemma 4 backend available. Install Ollama with `ollama pull gemma4:e2b` and start the daemon, or serve the app under cross-origin isolation (COOP same-origin + COEP require-corp) so the in-browser WebLLM fallback can load.',\n      })\n      return\n    }\n\n    const chunks = chunkText(text)\n    const all: RawGemmaDetection[] = []\n\n    for (let i = 0; i < chunks.length; i++) {\n      postMessage({ type: 'progress', progress: i / chunks.length })\n      const chunk = chunks[i]\n      const detections = backend === 'ollama' ? await callOllama(chunk) : await callWebLLM(chunk)\n      all.push(...detections)\n    }\n\n    postMessage({ id, detections: all })\n  } catch (err) {\n    postMessage({ id, error: err instanceof Error ? err.message : String(err) })\n  }\n}\n\npostMessage({ ready: true })\n\nexport {} // ensure this is treated as a module\n"]}

package/dist/workers/gemmaParse.d.ts

@@ -0,0 +1,32 @@
+import type { PiiType } from '../types/index.js';
+export declare const HEALTHCARE_CONFIDENCE_FLOOR = 0.75;
+export declare const CHUNK_MAX_CHARS = 800;
+export interface RawGemmaDetection {
+    text: string;
+    type: PiiType;
+    confidence: number;
+    ruleId: string;
+    reason: string;
+}
+/**
+ * Validate a model response and return the surviving detections.
+ *
+ * Rejects:
+ *  - Malformed JSON.
+ *  - Non-array top-level values.
+ *  - Items with confidence below HEALTHCARE_CONFIDENCE_FLOOR (0.75).
+ *  - Items whose text is not (after NFC normalisation) a substring of
+ *    sourceChunk. This rejects model hallucinations and paraphrases while
+ *    tolerating the NFC vs NFD differences that arise when text crosses
+ *    PDF font ↔ LLM ↔ JS string boundaries (e.g. "café" vs "café").
+ *  - Items with a type other than HEALTH_DATA.
+ *  - Items with a ruleId outside the gemma:* namespace.
+ *  - Items missing a reason field (the review panel surfaces it).
+ */
+export declare function parseAndValidate(raw: string, sourceChunk: string): RawGemmaDetection[];
+/**
+ * Split text into chunks of at most CHUNK_MAX_CHARS, preferring paragraph
+ * boundaries, falling back to sentence boundaries for paragraphs that
+ * exceed the limit.
+ */
+export declare function chunkText(text: string): string[];

package/dist/workers/gemmaParse.js

@@ -0,0 +1,103 @@
+// Pure helpers for the Gemma worker. Extracted into a separate module so
+// they can be unit-tested without instantiating the Web Worker (which is
+// not available in the Node test environment).
+export const HEALTHCARE_CONFIDENCE_FLOOR = 0.75;
+export const CHUNK_MAX_CHARS = 800;
+/**
+ * Validate a model response and return the surviving detections.
+ *
+ * Rejects:
+ *  - Malformed JSON.
+ *  - Non-array top-level values.
+ *  - Items with confidence below HEALTHCARE_CONFIDENCE_FLOOR (0.75).
+ *  - Items whose text is not (after NFC normalisation) a substring of
+ *    sourceChunk. This rejects model hallucinations and paraphrases while
+ *    tolerating the NFC vs NFD differences that arise when text crosses
+ *    PDF font ↔ LLM ↔ JS string boundaries (e.g. "café" vs "café").
+ *  - Items with a type other than HEALTH_DATA.
+ *  - Items with a ruleId outside the gemma:* namespace.
+ *  - Items missing a reason field (the review panel surfaces it).
+ */
+export function parseAndValidate(raw, sourceChunk) {
+    let parsed;
+    try {
+        const cleaned = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```\s*$/i, '').trim();
+        parsed = JSON.parse(cleaned);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const sourceNfc = sourceChunk.normalize('NFC');
+    const out = [];
+    for (const item of parsed) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const obj = item;
+        const text = typeof obj.text === 'string' ? obj.text.trim() : '';
+        const type = obj.type === 'HEALTH_DATA' ? 'HEALTH_DATA' : null;
+        const confidence = typeof obj.confidence === 'number' ? obj.confidence : 0;
+        const ruleId = typeof obj.ruleId === 'string' ? obj.ruleId : '';
+        const reason = typeof obj.reason === 'string' ? obj.reason : '';
+        if (!text)
+            continue;
+        if (!type)
+            continue;
+        if (confidence < HEALTHCARE_CONFIDENCE_FLOOR)
+            continue;
+        if (!ruleId.startsWith('gemma:'))
+            continue;
+        if (!reason)
+            continue;
+        if (!sourceNfc.includes(text.normalize('NFC')))
+            continue;
+        out.push({ text, type: type, confidence, ruleId, reason });
+    }
+    return out;
+}
+/**
+ * Split text into chunks of at most CHUNK_MAX_CHARS, preferring paragraph
+ * boundaries, falling back to sentence boundaries for paragraphs that
+ * exceed the limit.
+ */
+export function chunkText(text) {
+    if (text.length <= CHUNK_MAX_CHARS)
+        return [text];
+    const chunks = [];
+    const paragraphs = text.split(/\n\s*\n/);
+    let current = '';
+    for (const p of paragraphs) {
+        if ((current + p).length <= CHUNK_MAX_CHARS) {
+            current += (current ? '\n\n' : '') + p;
+        }
+        else {
+            if (current)
+                chunks.push(current);
+            if (p.length <= CHUNK_MAX_CHARS) {
+                current = p;
+            }
+            else {
+                const sentences = p.split(/(?<=[.!?])\s+/);
+                let sentChunk = '';
+                for (const s of sentences) {
+                    if ((sentChunk + s).length <= CHUNK_MAX_CHARS) {
+                        sentChunk += (sentChunk ? ' ' : '') + s;
+                    }
+                    else {
+                        if (sentChunk)
+                            chunks.push(sentChunk);
+                        sentChunk = s;
+                    }
+                }
+                if (sentChunk)
+                    chunks.push(sentChunk);
+                current = '';
+            }
+        }
+    }
+    if (current)
+        chunks.push(current);
+    return chunks;
+}
+//# sourceMappingURL=gemmaParse.js.map

package/dist/workers/gemmaParse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemmaParse.js","sourceRoot":"","sources":["../../src/workers/gemmaParse.ts"],"names":[],"mappings":"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","sourcesContent":["// Pure helpers for the Gemma worker. Extracted into a separate module so\n// they can be unit-tested without instantiating the Web Worker (which is\n// not available in the Node test environment).\n\nimport type { PiiType } from '../types/index.js'\n\nexport const HEALTHCARE_CONFIDENCE_FLOOR = 0.75\nexport const CHUNK_MAX_CHARS = 800\n\nexport interface RawGemmaDetection {\n  text: string\n  type: PiiType\n  confidence: number\n  ruleId: string\n  reason: string\n}\n\n/**\n * Validate a model response and return the surviving detections.\n *\n * Rejects:\n *  - Malformed JSON.\n *  - Non-array top-level values.\n *  - Items with confidence below HEALTHCARE_CONFIDENCE_FLOOR (0.75).\n *  - Items whose text is not (after NFC normalisation) a substring of\n *    sourceChunk. This rejects model hallucinations and paraphrases while\n *    tolerating the NFC vs NFD differences that arise when text crosses\n *    PDF font ↔ LLM ↔ JS string boundaries (e.g. \"café\" vs \"café\").\n *  - Items with a type other than HEALTH_DATA.\n *  - Items with a ruleId outside the gemma:* namespace.\n *  - Items missing a reason field (the review panel surfaces it).\n */\nexport function parseAndValidate(raw: string, sourceChunk: string): RawGemmaDetection[] {\n  let parsed: unknown\n  try {\n    const cleaned = raw.replace(/^```(?:json)?\\s*/i, '').replace(/\\s*```\\s*$/i, '').trim()\n    parsed = JSON.parse(cleaned)\n  } catch {\n    return []\n  }\n  if (!Array.isArray(parsed)) return []\n\n  const sourceNfc = sourceChunk.normalize('NFC')\n\n  const out: RawGemmaDetection[] = []\n  for (const item of parsed) {\n    if (typeof item !== 'object' || item === null) continue\n    const obj = item as Record<string, unknown>\n    const text = typeof obj.text === 'string' ? obj.text.trim() : ''\n    const type = obj.type === 'HEALTH_DATA' ? 'HEALTH_DATA' : null\n    const confidence = typeof obj.confidence === 'number' ? obj.confidence : 0\n    const ruleId = typeof obj.ruleId === 'string' ? obj.ruleId : ''\n    const reason = typeof obj.reason === 'string' ? obj.reason : ''\n\n    if (!text) continue\n    if (!type) continue\n    if (confidence < HEALTHCARE_CONFIDENCE_FLOOR) continue\n    if (!ruleId.startsWith('gemma:')) continue\n    if (!reason) continue\n    if (!sourceNfc.includes(text.normalize('NFC'))) continue\n\n    out.push({ text, type: type as PiiType, confidence, ruleId, reason })\n  }\n  return out\n}\n\n/**\n * Split text into chunks of at most CHUNK_MAX_CHARS, preferring paragraph\n * boundaries, falling back to sentence boundaries for paragraphs that\n * exceed the limit.\n */\nexport function chunkText(text: string): string[] {\n  if (text.length <= CHUNK_MAX_CHARS) return [text]\n  const chunks: string[] = []\n  const paragraphs = text.split(/\\n\\s*\\n/)\n  let current = ''\n  for (const p of paragraphs) {\n    if ((current + p).length <= CHUNK_MAX_CHARS) {\n      current += (current ? '\\n\\n' : '') + p\n    } else {\n      if (current) chunks.push(current)\n      if (p.length <= CHUNK_MAX_CHARS) {\n        current = p\n      } else {\n        const sentences = p.split(/(?<=[.!?])\\s+/)\n        let sentChunk = ''\n        for (const s of sentences) {\n          if ((sentChunk + s).length <= CHUNK_MAX_CHARS) {\n            sentChunk += (sentChunk ? ' ' : '') + s\n          } else {\n            if (sentChunk) chunks.push(sentChunk)\n            sentChunk = s\n          }\n        }\n        if (sentChunk) chunks.push(sentChunk)\n        current = ''\n      }\n    }\n  }\n  if (current) chunks.push(current)\n  return chunks\n}\n"]}

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "bounds-gemma",
+  "version": "0.1.0",
+  "description": "On-device Gemma 4 contextual PHI redaction toolkit for HIPAA Safe Harbor de-identification. Runs in a browser via WebLLM or locally via Ollama, never on a server.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "private": false,
+  "author": "Anya Chueayen <hello@aqta.ai>",
+  "homepage": "https://github.com/Aqta-ai/bounds-gemma#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Aqta-ai/bounds-gemma.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Aqta-ai/bounds-gemma/issues"
+  },
+  "keywords": [
+    "gemma",
+    "gemma-4",
+    "phi",
+    "pii",
+    "hipaa",
+    "redaction",
+    "privacy",
+    "on-device",
+    "webllm",
+    "ollama",
+    "healthcare",
+    "ai",
+    "llm"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./parser": {
+      "types": "./dist/workers/gemmaParse.d.ts",
+      "import": "./dist/workers/gemmaParse.js"
+    },
+    "./worker": {
+      "types": "./dist/workers/gemma.worker.d.ts",
+      "import": "./dist/workers/gemma.worker.js"
+    },
+    "./pipeline": {
+      "types": "./dist/pipeline/GemmaWorker.d.ts",
+      "import": "./dist/pipeline/GemmaWorker.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "prepublishOnly": "npm run build && npm test",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "example:ollama": "tsx examples/runOllama.ts",
+    "example:webllm": "echo 'Open examples/webllm.html in a browser (Chrome + WebGPU + cross-origin-isolated headers)'"
+  },
+  "devDependencies": {
+    "@mlc-ai/web-llm": "^0.2.83",
+    "@types/node": "^20.12.7",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.5",
+    "vitest": "^1.6.0"
+  },
+  "peerDependencies": {
+    "@mlc-ai/web-llm": "^0.2.79"
+  },
+  "peerDependenciesMeta": {
+    "@mlc-ai/web-llm": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}