@mlx-node/privacy 0.0.0

package/dist/classifier.d.ts

@@ -0,0 +1,32 @@
+import type { ClassifyOptions, ClassifyResult, RedactOptions, RedactResult } from './types.js';
+/**
+ * High-level wrapper around the native `PrivacyFilterModel` NAPI class.
+ *
+ * The native binding's `load`/`classify` methods are synchronous, but the
+ * public API here is intentionally `async` so we can later move work to a
+ * worker thread without a breaking change to consumers.
+ */
+export declare class PrivacyFilter {
+    private readonly native;
+    private constructor();
+    /**
+     * Load a privacy-filter checkpoint from a directory.
+     *
+     * The directory must contain `config.json`, `model.safetensors`,
+     * `tokenizer.json`, and optionally `viterbi_calibration.json` and
+     * `tokenizer_config.json`.
+     */
+    static load(modelPath: string): Promise<PrivacyFilter>;
+    /**
+     * Classify `text` and return detected PII entities (and optionally
+     * per-token tags when `opts.returnTokens` is `true`).
+     */
+    classify(text: string, opts?: ClassifyOptions): Promise<ClassifyResult>;
+    /**
+     * Classify `text`, then replace each detected entity according to
+     * `opts.replacement` (defaults to `[<label>]`). If `opts.labels` is set,
+     * only entities whose label is in that list are redacted.
+     */
+    redact(text: string, opts?: RedactOptions): Promise<RedactResult>;
+}
+//# sourceMappingURL=classifier.d.ts.map

package/dist/classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","sourceRoot":"","sources":["../src/classifier.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAU,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEvG;;;;;;GAMG;AACH,qBAAa,aAAa;IACJ,OAAO,CAAC,QAAQ,CAAC,MAAM;IAA3C,OAAO,eAAkE;IAEzE;;;;;;OAMG;IACH,OAAa,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAK3D;IAED;;;OAGG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAS5E;IAED;;;;OAIG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAGtE;CACF"}

package/dist/classifier.js

@@ -0,0 +1,51 @@
+import { PrivacyFilterModel as NativePrivacyFilterModel } from '@mlx-node/core';
+import { redactImpl } from './redactor.js';
+/**
+ * High-level wrapper around the native `PrivacyFilterModel` NAPI class.
+ *
+ * The native binding's `load`/`classify` methods are synchronous, but the
+ * public API here is intentionally `async` so we can later move work to a
+ * worker thread without a breaking change to consumers.
+ */
+export class PrivacyFilter {
+    native;
+    constructor(native) {
+        this.native = native;
+    }
+    /**
+     * Load a privacy-filter checkpoint from a directory.
+     *
+     * The directory must contain `config.json`, `model.safetensors`,
+     * `tokenizer.json`, and optionally `viterbi_calibration.json` and
+     * `tokenizer_config.json`.
+     */
+    static async load(modelPath) {
+        // Native `load` is synchronous; we keep the public surface async so
+        // future implementations (e.g. off-main-thread load) don't break ABI.
+        const native = NativePrivacyFilterModel.load(modelPath);
+        return new PrivacyFilter(native);
+    }
+    /**
+     * Classify `text` and return detected PII entities (and optionally
+     * per-token tags when `opts.returnTokens` is `true`).
+     */
+    async classify(text, opts) {
+        const result = this.native.classify(text, opts ?? null);
+        // The native binding returns `label: string`; at runtime any
+        // non-background span is one of the 8 `PrivacyLabel` values, so the
+        // cast through `Entity[]` narrows the public surface for callers.
+        return {
+            entities: result.entities,
+            tokens: result.tokens ?? undefined,
+        };
+    }
+    /**
+     * Classify `text`, then replace each detected entity according to
+     * `opts.replacement` (defaults to `[<label>]`). If `opts.labels` is set,
+     * only entities whose label is in that list are redacted.
+     */
+    async redact(text, opts) {
+        const { entities } = await this.classify(text, opts);
+        return redactImpl(text, entities, opts);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type * from './types.js';
+export { PrivacyFilter } from './classifier.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAC;AAEhC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { PrivacyFilter } from './classifier.js';

package/dist/redactor.d.ts

@@ -0,0 +1,28 @@
+import type { Entity, RedactOptions } from './types.js';
+/**
+ * Apply entity redaction to `text` using the entities returned by the
+ * classifier.
+ *
+ * - If `opts.labels` is set, only entities whose label is in that list are
+ *   redacted (others are left in place verbatim).
+ * - Each surviving entity span is replaced via {@link renderReplacement}.
+ * - The returned `entities` array is sorted by start offset and only
+ *   contains the entities that were actually redacted (post-filter).
+ *
+ * Entities are assumed to be non-overlapping (the privacy-filter Viterbi
+ * decoder produces non-overlapping spans), and we walk them left-to-right
+ * with a running cursor so the output is built in a single pass.
+ *
+ * IMPORTANT: `Entity.start`/`Entity.end` are **UTF-8 byte offsets** (the
+ * Hugging Face `tokenizers` convention used by the underlying Rust
+ * classifier). JavaScript's `String.prototype.slice` indexes UTF-16 code
+ * units, so slicing the original string directly corrupts spans whenever
+ * any non-ASCII character (emoji, CJK, accented Latin) appears before an
+ * entity. We therefore encode `text` as a UTF-8 Buffer once and slice
+ * bytes, decoding each segment back to a string.
+ */
+export declare function redactImpl(text: string, entities: Entity[], opts?: RedactOptions): {
+    redacted: string;
+    entities: Entity[];
+};
+//# sourceMappingURL=redactor.d.ts.map

package/dist/redactor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redactor.d.ts","sourceRoot":"","sources":["../src/redactor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAe,MAAM,YAAY,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,IAAI,CAAC,EAAE,aAAa,GACnB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAsB1C"}

package/dist/redactor.js

@@ -0,0 +1,54 @@
+import { Buffer } from 'node:buffer';
+/**
+ * Apply entity redaction to `text` using the entities returned by the
+ * classifier.
+ *
+ * - If `opts.labels` is set, only entities whose label is in that list are
+ *   redacted (others are left in place verbatim).
+ * - Each surviving entity span is replaced via {@link renderReplacement}.
+ * - The returned `entities` array is sorted by start offset and only
+ *   contains the entities that were actually redacted (post-filter).
+ *
+ * Entities are assumed to be non-overlapping (the privacy-filter Viterbi
+ * decoder produces non-overlapping spans), and we walk them left-to-right
+ * with a running cursor so the output is built in a single pass.
+ *
+ * IMPORTANT: `Entity.start`/`Entity.end` are **UTF-8 byte offsets** (the
+ * Hugging Face `tokenizers` convention used by the underlying Rust
+ * classifier). JavaScript's `String.prototype.slice` indexes UTF-16 code
+ * units, so slicing the original string directly corrupts spans whenever
+ * any non-ASCII character (emoji, CJK, accented Latin) appears before an
+ * entity. We therefore encode `text` as a UTF-8 Buffer once and slice
+ * bytes, decoding each segment back to a string.
+ */
+export function redactImpl(text, entities, opts) {
+    const labelFilter = opts?.labels ? new Set(opts.labels) : null;
+    const filtered = labelFilter ? entities.filter((e) => labelFilter.has(e.label)) : entities;
+    const sorted = [...filtered].sort((a, b) => a.start - b.start);
+    // Fast path: no redactions → return the original text unchanged without
+    // a Buffer round-trip.
+    if (sorted.length === 0) {
+        return { redacted: text, entities: sorted };
+    }
+    const buf = Buffer.from(text, 'utf8');
+    let out = '';
+    let cursor = 0;
+    for (const e of sorted) {
+        out += buf.toString('utf8', cursor, e.start);
+        out += renderReplacement(e, opts?.replacement);
+        cursor = e.end;
+    }
+    out += buf.toString('utf8', cursor, buf.length);
+    return { redacted: out, entities: sorted };
+}
+/**
+ * Render the replacement string for a single entity. Defaults to
+ * `[<label>]` when no replacement is provided.
+ */
+function renderReplacement(entity, replacement) {
+    if (typeof replacement === 'function')
+        return replacement(entity);
+    if (replacement === 'label' || replacement == null)
+        return `[${entity.label}]`;
+    return replacement;
+}

package/dist/train.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Configuration for {@link PrivacyLoraTrainer.create}.
+ *
+ * All tunables are optional; omitting a field falls back to the
+ * documented defaults from the native trainer:
+ *
+ * - `rank` = 16, `alpha` = 32, `dropout` = 0.05
+ * - `loraLr` = 1e-4, `classifierLr` = 5e-5
+ * - `batchSize` = 2, `maxSeqLen` = 256, `numEpochs` = 3
+ * - `gradAccumSteps` = 4, `gradClip` = 1.0
+ * - `saveEvery` = 500 (set 0 to disable intermediate checkpoints)
+ * - `padTokenId` = 0
+ *
+ * `modelPath`, `dataPath`, and `outputDir` are required.
+ *
+ * The field names match the native NAPI casing
+ * ({@link import('@mlx-node/core').PrivacyLoraTrainConfigJs}) so the
+ * wrapper can pass values straight through without re-keying.
+ */
+export interface PrivacyLoraTrainConfig {
+    /** Filesystem path to the base privacy-filter checkpoint directory. */
+    modelPath: string;
+    /** Path to the training JSONL dataset (pre-tokenized). */
+    dataPath: string;
+    /**
+     * Optional evaluation JSONL dataset path. Currently ignored by the
+     * trainer — reserved for future eval-loop integration.
+     */
+    evalPath?: string;
+    /**
+     * Directory where `adapter.safetensors`, `adapter_config.json`,
+     * `optimizer_state.safetensors`, and `trainer_state.json` are written.
+     */
+    outputDir: string;
+    rank?: number;
+    alpha?: number;
+    dropout?: number;
+    loraLr?: number;
+    classifierLr?: number;
+    batchSize?: number;
+    maxSeqLen?: number;
+    numEpochs?: number;
+    gradAccumSteps?: number;
+    gradClip?: number;
+    saveEvery?: number;
+    resumeFrom?: string;
+    padTokenId?: number;
+}
+/**
+ * High-level wrapper around the native `PrivacyLoraTrainerJs` NAPI class.
+ *
+ * The native binding's `create` factory is synchronous (it loads the base
+ * checkpoint, attaches zero-B LoRA adapters, and parses the JSONL dataset
+ * inline), but the public API here is intentionally `async` so we can later
+ * move work to a worker thread without a breaking change to consumers.
+ *
+ * `train()` and `saveAdapter()` are already async on the native side — they
+ * funnel through `spawn_blocking` so the Node.js event loop stays responsive
+ * for the duration of the training run.
+ */
+export declare class PrivacyLoraTrainer {
+    private readonly inner;
+    private constructor();
+    /**
+     * Construct a new trainer.
+     *
+     * Loads the base privacy-filter model from `config.modelPath`, attaches
+     * zero-B LoRA adapters on every attention projection, and parses the
+     * pre-tokenized JSONL dataset at `config.dataPath`.
+     */
+    static create(config: PrivacyLoraTrainConfig): Promise<PrivacyLoraTrainer>;
+    /**
+     * Run the full training loop. Resolves with the final optimizer step
+     * count once `numEpochs` epochs have completed.
+     */
+    train(): Promise<number>;
+    /**
+     * Persist adapter weights, optimizer state, and trainer progress to the
+     * configured `outputDir`. Overwrites any previous checkpoint at that
+     * path.
+     */
+    saveAdapter(): Promise<void>;
+}
+//# sourceMappingURL=train.d.ts.map

package/dist/train.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"train.d.ts","sourceRoot":"","sources":["../src/train.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,sBAAsB;IACrC,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAkB;IACT,OAAO,CAAC,QAAQ,CAAC,KAAK;IAA1C,OAAO;IAEP;;;;;;OAMG;WACU,MAAM,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAQhF;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAI9B;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;CAGnC"}

package/dist/train.js

@@ -0,0 +1,48 @@
+import { PrivacyLoraTrainerJs as NativePrivacyLoraTrainerJs, } from '@mlx-node/core';
+/**
+ * High-level wrapper around the native `PrivacyLoraTrainerJs` NAPI class.
+ *
+ * The native binding's `create` factory is synchronous (it loads the base
+ * checkpoint, attaches zero-B LoRA adapters, and parses the JSONL dataset
+ * inline), but the public API here is intentionally `async` so we can later
+ * move work to a worker thread without a breaking change to consumers.
+ *
+ * `train()` and `saveAdapter()` are already async on the native side — they
+ * funnel through `spawn_blocking` so the Node.js event loop stays responsive
+ * for the duration of the training run.
+ */
+export class PrivacyLoraTrainer {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    /**
+     * Construct a new trainer.
+     *
+     * Loads the base privacy-filter model from `config.modelPath`, attaches
+     * zero-B LoRA adapters on every attention projection, and parses the
+     * pre-tokenized JSONL dataset at `config.dataPath`.
+     */
+    static async create(config) {
+        // NAPI requires the camelCase keys to exactly match the interface — pass
+        // the object through directly so any future field additions are picked
+        // up without an extra mapping table.
+        const native = NativePrivacyLoraTrainerJs.create(config);
+        return new PrivacyLoraTrainer(native);
+    }
+    /**
+     * Run the full training loop. Resolves with the final optimizer step
+     * count once `numEpochs` epochs have completed.
+     */
+    async train() {
+        return this.inner.train();
+    }
+    /**
+     * Persist adapter weights, optimizer state, and trainer progress to the
+     * configured `outputDir`. Overwrites any previous checkpoint at that
+     * path.
+     */
+    async saveAdapter() {
+        return this.inner.saveAdapter();
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Public types for the `@mlx-node/privacy` package.
+ *
+ * Mirrors the native NAPI surface ({@link import('@mlx-node/core').PrivacyEntity}
+ * etc.) but narrows the `label` field to the literal union of the 8 PII
+ * classes produced by the privacy-filter checkpoint, so consumers get
+ * autocomplete on `e.label === 'private_email'`.
+ */
+/**
+ * The 8 PII categories the privacy-filter checkpoint can emit (without the
+ * BIOES prefix). At runtime the native binding returns a plain `string`, but
+ * any non-background span produced by the model is guaranteed to be one of
+ * these values, so the wrapper narrows it for callers.
+ */
+export type PrivacyLabel = 'account_number' | 'private_address' | 'private_date' | 'private_email' | 'private_person' | 'private_phone' | 'private_url' | 'secret';
+/**
+ * A detected PII span. `start`/`end` are byte offsets into the original
+ * input string (Hugging Face `tokenizers` convention). `score` is the mean —
+ * across the span's tokens — of the softmax probability of the Viterbi-emitted
+ * tag at each token.
+ */
+export interface Entity {
+    start: number;
+    end: number;
+    label: PrivacyLabel;
+    score: number;
+    text: string;
+}
+/**
+ * Per-call Viterbi calibration overrides.
+ *
+ * Field names match the native NAPI binding's camelCase casing
+ * ({@link import('@mlx-node/core').PrivacyCalibration}) so the wrapper can
+ * pass user options straight through without re-keying.
+ *
+ * Any omitted field falls back to the model's default calibration
+ * (loaded from `viterbi_calibration.json` at load time).
+ */
+export interface ViterbiCalibration {
+    transitionBiasBackgroundStay: number;
+    transitionBiasBackgroundToStart: number;
+    transitionBiasEndToBackground: number;
+    transitionBiasEndToStart: number;
+    transitionBiasInsideToContinue: number;
+    transitionBiasInsideToEnd: number;
+}
+/**
+ * Options for {@link PrivacyFilter.classify}.
+ *
+ * - `threshold` (default `0.5`): minimum mean per-token probability for an
+ *   extracted span to be returned.
+ * - `calibration`: per-call overrides on top of the checkpoint default.
+ * - `returnTokens` (default `false`): when `true`, the result includes a
+ *   `tokens` array with one entry per input token.
+ */
+export interface ClassifyOptions {
+    threshold?: number;
+    calibration?: Partial<ViterbiCalibration>;
+    returnTokens?: boolean;
+}
+/**
+ * A single token with its Viterbi-decoded tag. Emitted by
+ * {@link PrivacyFilter.classify} when `returnTokens: true`.
+ *
+ * `tag` is the full BIOES tag (`'O'` or `'B-...'`/`'I-...'`/`'E-...'`/
+ * `'S-...'`) chosen by the Viterbi decoder. `score` is the softmax
+ * probability of that emitted tag at this token, so `tag` and `score`
+ * always share decoders (at boundary tokens the Viterbi pick can differ
+ * from the local argmax).
+ */
+export interface Token {
+    text: string;
+    tag: string;
+    score: number;
+    start: number;
+    end: number;
+}
+/** Result of {@link PrivacyFilter.classify}. */
+export interface ClassifyResult {
+    entities: Entity[];
+    tokens?: Token[];
+}
+/**
+ * How to replace a detected entity in {@link PrivacyFilter.redact}.
+ *
+ * - The sentinel string `'label'` produces `[<label>]` (this is the
+ *   default when no `replacement` is provided).
+ * - Any other string is inserted verbatim.
+ * - A function receives the entity and returns the replacement string.
+ */
+export type Replacement = string | ((entity: Entity) => string);
+/**
+ * Options for {@link PrivacyFilter.redact}. Extends {@link ClassifyOptions}
+ * so threshold / calibration / returnTokens can be passed through to the
+ * underlying classify call.
+ */
+export interface RedactOptions extends ClassifyOptions {
+    /** How to replace each entity. Defaults to `'label'`. */
+    replacement?: Replacement;
+    /** If set, only entities whose label is in this list are redacted. */
+    labels?: PrivacyLabel[];
+}
+/** Result of {@link PrivacyFilter.redact}. */
+export interface RedactResult {
+    /** The input text with each entity span replaced. */
+    redacted: string;
+    /** The entities that were actually redacted (after `labels` filter). */
+    entities: Entity[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GACpB,gBAAgB,GAChB,iBAAiB,GACjB,cAAc,GACd,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,aAAa,GACb,QAAQ,CAAC;AAEb;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,YAAY,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,4BAA4B,EAAE,MAAM,CAAC;IACrC,+BAA+B,EAAE,MAAM,CAAC;IACxC,6BAA6B,EAAE,MAAM,CAAC;IACtC,wBAAwB,EAAE,MAAM,CAAC;IACjC,8BAA8B,EAAE,MAAM,CAAC;IACvC,yBAAyB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC1C,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,gDAAgD;AAChD,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,yDAAyD;IACzD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,sEAAsE;IACtE,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;CACzB;AAED,8CAA8C;AAC9C,MAAM,WAAW,YAAY;IAC3B,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB"}

package/dist/types.js

@@ -0,0 +1,9 @@
+/**
+ * Public types for the `@mlx-node/privacy` package.
+ *
+ * Mirrors the native NAPI surface ({@link import('@mlx-node/core').PrivacyEntity}
+ * etc.) but narrows the `label` field to the literal union of the 8 PII
+ * classes produced by the privacy-filter checkpoint, so consumers get
+ * autocomplete on `e.label === 'private_email'`.
+ */
+export {};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@mlx-node/privacy",
+  "version": "0.0.0",
+  "homepage": "https://github.com/mlx-node/mlx-node",
+  "bugs": {
+    "url": "https://github.com/mlx-node/mlx-node/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mlx-node/mlx-node.git",
+    "directory": "packages/privacy"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "test": "vite test run"
+  },
+  "dependencies": {
+    "@mlx-node/core": "0.0.7"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0"
+  }
+}