@datafog/node 0.2.0

package/index.d.ts

@@ -0,0 +1,284 @@
+/** Canonical built-in values are uppercase, but custom detectors may add values. */
+export type EntityType = string;
+
+export type TransformationStrategy =
+  | "redact"
+  | "mask"
+  | "remove"
+  | "pseudonymize"
+  | "tokenize";
+
+export interface MaskRevealConfig {
+  readonly direction: "first" | "last";
+  readonly count: number;
+}
+
+export type TransformationStrategyConfig =
+  | { readonly strategy: "redact" }
+  | { readonly strategy: "remove" }
+  | {
+      readonly strategy: "pseudonymize";
+      readonly key_ref: string;
+      readonly key_version?: string;
+    }
+  | {
+      readonly strategy: "tokenize";
+      readonly token_ref: string;
+    }
+  | {
+      readonly strategy: "mask";
+      readonly character?: string;
+      readonly reveal?: MaskRevealConfig;
+    };
+
+export interface RegexAllowRule {
+  readonly pattern: string;
+  readonly case_sensitive?: boolean;
+}
+
+export interface AllowConfig {
+  readonly exact?: Readonly<Record<EntityType, readonly string[]>>;
+  readonly regex?: Readonly<Record<EntityType, readonly RegexAllowRule[]>>;
+}
+
+export interface TransformationConfig {
+  readonly default: TransformationStrategyConfig;
+  readonly entities?: readonly EntityType[];
+  readonly overrides?: Readonly<Record<EntityType, TransformationStrategyConfig>>;
+  readonly allow?: AllowConfig;
+}
+
+export interface ScanConfig {
+  readonly locale?: string;
+}
+
+export interface ScanAndTransformConfig {
+  readonly scan?: ScanConfig;
+  readonly transform: TransformationConfig;
+}
+
+export type DataFogErrorCode =
+  | "invalid_configuration"
+  | "invalid_finding"
+  | "key_provider_required"
+  | "key_not_found"
+  | "key_access_denied"
+  | "key_provider_unavailable"
+  | "invalid_key_material"
+  | "key_provider_error"
+  | "token_provider_required"
+  | "invalid_token"
+  | "unsupported_token_version"
+  | "token_not_found"
+  | "token_expired"
+  | "token_access_denied"
+  | "invalid_token_material"
+  | "token_provider_unavailable"
+  | "token_provider_error"
+  | "unsupported_strategy"
+  | "internal_error";
+
+export declare class DataFogError extends Error {
+  readonly code: DataFogErrorCode;
+  readonly reason?: string;
+  readonly path?: string;
+  readonly findingIndex?: number;
+}
+
+export interface KeyProviderRequest {
+  readonly keyRef: string;
+  readonly keyVersion?: string;
+}
+
+export interface KeyProviderResponse {
+  readonly key: Uint8Array;
+  readonly resolvedVersion: string;
+}
+
+export interface KeyProvider {
+  resolveKey(request: KeyProviderRequest): Promise<KeyProviderResponse>;
+}
+
+export interface PrivacyContext {
+  readonly scope: string;
+}
+
+export interface TokenizeProviderItem {
+  readonly id: string;
+  readonly exactValue: string;
+  readonly tokenRef: string;
+}
+
+export interface TokenizeProviderResult {
+  readonly id: string;
+  readonly payload: Uint8Array;
+  readonly resolvedVersion: string;
+}
+
+export interface RestoreProviderItem {
+  readonly id: string;
+  readonly tokenRef: string;
+  readonly resolvedVersion: string;
+  readonly payload: Uint8Array;
+}
+
+export interface RestoreProviderResult {
+  readonly id: string;
+  readonly value: string;
+}
+
+export interface TokenProvider {
+  tokenizeBatch(scope: string, items: TokenizeProviderItem[]): Promise<TokenizeProviderResult[]>;
+  restoreBatch(scope: string, items: RestoreProviderItem[]): Promise<RestoreProviderResult[]>;
+}
+
+export interface PrivacyManagerProviders {
+  readonly keyProvider?: KeyProvider;
+  readonly tokenProvider?: TokenProvider;
+}
+
+export declare class PrivacyManager {
+  constructor(provider: KeyProvider | PrivacyManagerProviders, tokenProvider?: TokenProvider);
+  transform(
+    text: string,
+    findings: FindingInput[],
+    config: TransformationConfig,
+    context?: PrivacyContext,
+  ): Promise<TransformResult>;
+  scanAndTransform(
+    text: string,
+    config: ScanAndTransformConfig,
+    context?: PrivacyContext,
+  ): Promise<TransformResult>;
+  restore(text: string, context: PrivacyContext): Promise<RestoreResult>;
+}
+export interface Finding {
+  readonly entityType: EntityType
+  readonly matchedText: string
+  readonly byteRange: TextRange
+  readonly codepointRange: TextRange
+  readonly utf16Range: TextRange
+  readonly confidence?: number
+  readonly detectorName: string
+  readonly detectorVersion?: string
+}
+
+export interface FindingInput {
+  entityType: EntityType
+  matchedText: string
+  byteRange: TextRange
+  codepointRange: TextRange
+  confidence?: number
+  detectorName: string
+  detectorVersion?: string
+}
+
+export interface KeySelector {
+  readonly index: number
+  readonly keyRef: string
+  readonly keyVersion?: string
+  readonly path: string
+}
+
+export interface PreparedScanAndTransform {
+  readonly findings: Array<Finding>
+  readonly selectors: Array<KeySelector>
+}
+
+export declare function prepareScanAndTransform(text: string, config: ScanAndTransformConfig): PreparedScanAndTransform
+
+export declare function requiredKeySelectors(text: string, findings: FindingInput[], config: TransformationConfig): Array<KeySelector>
+
+export declare function requiredRestoreItems(text: string, context: PrivacyContext): Array<RestoreItem>
+
+export declare function requiredTokenizationItems(text: string, findings: FindingInput[], config: TransformationConfig, context?: PrivacyContext | undefined): Array<TokenizeItem>
+
+export interface ResolvedKeyInput {
+  selectorIndex: number
+  key: Uint8Array
+  resolvedVersion: string
+}
+
+export interface Restoration {
+  readonly sourceByteRange: TextRange
+  readonly sourceCodepointRange: TextRange
+  readonly sourceUtf16Range: TextRange
+  readonly outputByteRange: TextRange
+  readonly outputCodepointRange: TextRange
+  readonly outputUtf16Range: TextRange
+  readonly tokenRef: string
+  readonly resolvedTokenVersion: string
+}
+
+export interface RestoredValueInput {
+  id: string
+  value: string
+}
+
+export interface RestoreItem {
+  readonly id: string
+  readonly tokenRef: string
+  readonly resolvedVersion: string
+  readonly payload: Uint8Array
+}
+
+export interface RestoreResult {
+  readonly text: string
+  readonly restorations: Array<Restoration>
+}
+
+export declare function restoreWithResults(text: string, context: PrivacyContext, results: Array<RestoredValueInput>): RestoreResult
+
+/** Scan text for supported PII findings. */
+export declare function scan(text: string, config?: ScanConfig | undefined): Array<Finding>
+
+/** Scan text and transform the detected findings. */
+export declare function scanAndTransform(text: string, config: ScanAndTransformConfig): TransformResult
+
+export interface TextRange {
+  readonly start: number
+  readonly end: number
+}
+
+export interface TokenizeItem {
+  readonly id: string
+  readonly exactValue: string
+  readonly tokenRef: string
+}
+
+export interface TokenizeResultInput {
+  id: string
+  payload: Uint8Array
+  resolvedVersion: string
+}
+
+/** Transform explicit findings without scanning implicitly. */
+export declare function transform(text: string, findings: FindingInput[], config: TransformationConfig): TransformResult
+
+export interface Transformation {
+  readonly entityType: string
+  readonly sourceByteRange: TextRange
+  readonly sourceCodepointRange: TextRange
+  readonly sourceUtf16Range: TextRange
+  readonly confidence?: number
+  readonly detectorName: string
+  readonly detectorVersion?: string
+  readonly strategy: TransformationStrategy
+  readonly replacement: string
+  readonly outputByteRange: TextRange
+  readonly outputCodepointRange: TextRange
+  readonly outputUtf16Range: TextRange
+  readonly keyRef?: string
+  readonly resolvedKeyVersion?: string
+  readonly tokenRef?: string
+  readonly resolvedTokenVersion?: string
+}
+
+export interface TransformResult {
+  readonly text: string
+  readonly transformations: Array<Transformation>
+}
+
+export declare function transformWithProviderResults(text: string, findings: FindingInput[], config: TransformationConfig, context: PrivacyContext | undefined, resolvedKeys: Array<ResolvedKeyInput>, tokenResults: Array<TokenizeResultInput>): TransformResult
+
+export declare function transformWithResolvedKeys(text: string, findings: FindingInput[], config: TransformationConfig, resolvedKeys: Array<ResolvedKeyInput>): TransformResult

package/index.js

@@ -0,0 +1,289 @@
+import { Buffer } from "node:buffer";
+import {
+  prepareScanAndTransform as nativePrepareScanAndTransform,
+  requiredKeySelectors as nativeRequiredKeySelectors,
+  requiredRestoreItems as nativeRequiredRestoreItems,
+  requiredTokenizationItems as nativeRequiredTokenizationItems,
+  restoreWithResults as nativeRestoreWithResults,
+  scan as nativeScan,
+  scanAndTransform as nativeScanAndTransform,
+  transform as nativeTransform,
+  transformWithProviderResults as nativeTransformWithProviderResults,
+} from "./native.js";
+
+export class DataFogError extends Error {
+  constructor({ code, reason, message, path, findingIndex }) {
+    super(message);
+    this.name = "DataFogError";
+    this.code = code;
+    this.reason = reason;
+    this.path = path;
+    this.findingIndex = findingIndex;
+  }
+}
+
+function normalizeError(error, fallbackCode) {
+  if (error instanceof DataFogError) return error;
+  try {
+    const details = JSON.parse(error?.message ?? "");
+    if (typeof details.code === "string" && typeof details.message === "string") {
+      return new DataFogError(details);
+    }
+  } catch {
+    // Native conversion errors use the operation-specific fallback below.
+  }
+  return new DataFogError({
+    code: fallbackCode,
+    reason: fallbackCode === "invalid_configuration" ? "invalid_type" : undefined,
+    message:
+      fallbackCode === "invalid_configuration"
+        ? "request configuration could not be decoded"
+        : "the native operation failed unexpectedly",
+    path: fallbackCode === "invalid_configuration" ? "" : undefined,
+  });
+}
+
+const providerErrorMessages = {
+  key_not_found: "key provider could not find the requested key",
+  key_access_denied: "key provider denied access to the requested key",
+  key_provider_unavailable: "key provider is temporarily unavailable",
+  key_provider_error: "key provider could not resolve the requested key",
+  token_not_found: "token was not found",
+  token_expired: "token has expired",
+  token_access_denied: "token access was denied",
+  token_provider_unavailable: "token provider is temporarily unavailable",
+  token_provider_error: "token provider could not complete the request",
+};
+
+function normalizeProviderError(error, path, fallback = "key_provider_error") {
+  const candidateCode = error?.code;
+  const expectedPrefix = fallback.startsWith("token_") ? "token_" : "key_";
+  const code =
+    typeof candidateCode === "string" &&
+      candidateCode.startsWith(expectedPrefix) &&
+      candidateCode in providerErrorMessages
+      ? candidateCode
+      : fallback;
+  return new DataFogError({
+    code,
+    message: providerErrorMessages[code],
+    path,
+  });
+}
+
+function withPathPrefix(error, prefix) {
+  const normalized = normalizeError(error, "internal_error");
+  return new DataFogError({
+    code: normalized.code,
+    reason: normalized.reason,
+    message: normalized.message,
+    path: normalized.path ? `${prefix}${normalized.path}` : normalized.path,
+    findingIndex: normalized.findingIndex,
+  });
+}
+
+function resolvedKeyInput(selector, response) {
+  if (
+    !response ||
+    !(response.key instanceof Uint8Array) ||
+    typeof response.resolvedVersion !== "string"
+  ) {
+    return {
+      selectorIndex: selector.index,
+      key: Buffer.alloc(0),
+      resolvedVersion: "",
+    };
+  }
+  return {
+    selectorIndex: selector.index,
+    key: Buffer.from(response.key),
+    resolvedVersion: response.resolvedVersion,
+  };
+}
+
+export class PrivacyManager {
+  #keyProvider;
+  #tokenProvider;
+
+  constructor(provider, tokenProvider) {
+    const options = provider && ("keyProvider" in provider || "tokenProvider" in provider)
+      ? provider
+      : { keyProvider: provider, tokenProvider };
+    if (options.keyProvider && typeof options.keyProvider.resolveKey !== "function") {
+      throw new TypeError("key provider must define resolveKey(request)");
+    }
+    if (options.tokenProvider &&
+        (typeof options.tokenProvider.tokenizeBatch !== "function" ||
+         typeof options.tokenProvider.restoreBatch !== "function")) {
+      throw new TypeError("token provider must define tokenizeBatch(scope, items) and restoreBatch(scope, items)");
+    }
+    this.#keyProvider = options.keyProvider;
+    this.#tokenProvider = options.tokenProvider;
+  }
+
+  async #resolve(selectors, pathPrefix = "") {
+    const resolved = [];
+    if (selectors.length > 0 && !this.#keyProvider) {
+      throw new DataFogError({
+        code: "key_provider_required",
+        message: "pseudonymization requires a runtime key provider",
+        path: `${pathPrefix}${selectors[0].path}`,
+      });
+    }
+    for (const selector of selectors) {
+      let response;
+      try {
+        response = await this.#keyProvider.resolveKey({
+          keyRef: selector.keyRef,
+          keyVersion: selector.keyVersion,
+        });
+      } catch (error) {
+        throw normalizeProviderError(error, `${pathPrefix}${selector.path}`);
+      }
+      resolved.push(resolvedKeyInput(selector, response));
+    }
+    return resolved;
+  }
+
+  async #tokenize(items, context) {
+    if (items.length === 0) return [];
+    if (!this.#tokenProvider) {
+      throw new DataFogError({
+        code: "token_provider_required",
+        message: "tokenization requires a runtime token provider and request scope",
+      });
+    }
+    let results;
+    try {
+      results = await this.#tokenProvider.tokenizeBatch(context.scope, items);
+    } catch (error) {
+      throw normalizeProviderError(error, undefined, "token_provider_error");
+    }
+    if (!Array.isArray(results)) return [];
+    return results.map((result) => ({
+      id: result?.id ?? "",
+      payload: result?.payload instanceof Uint8Array ? Buffer.from(result.payload) : Buffer.alloc(0),
+      resolvedVersion: typeof result?.resolvedVersion === "string" ? result.resolvedVersion : "",
+    }));
+  }
+
+  async transform(text, findings, config, context) {
+    if (typeof text !== "string") {
+      throw new TypeError("transform text must be a string");
+    }
+    if (!Array.isArray(findings)) {
+      throw new TypeError("transform findings must be an array");
+    }
+    let resolved = [];
+    try {
+      const selectors = nativeRequiredKeySelectors(text, findings, config);
+      resolved = await this.#resolve(selectors);
+      const items = nativeRequiredTokenizationItems(text, findings, config, context);
+      const tokens = await this.#tokenize(items, context);
+      return nativeTransformWithProviderResults(text, findings, config, context, resolved, tokens);
+    } catch (error) {
+      if (error instanceof DataFogError) throw error;
+      throw normalizeError(error, "invalid_configuration");
+    } finally {
+      resolved.forEach(({ key }) => key.fill(0));
+    }
+  }
+
+  async scanAndTransform(text, config, context) {
+    if (typeof text !== "string") {
+      throw new TypeError("scanAndTransform text must be a string");
+    }
+    let prepared;
+    try {
+      prepared = nativePrepareScanAndTransform(text, config);
+    } catch (error) {
+      throw normalizeError(error, "invalid_configuration");
+    }
+    const resolved = await this.#resolve(prepared.selectors, "/transform");
+    try {
+      const items = nativeRequiredTokenizationItems(text, prepared.findings, config.transform, context);
+      const tokens = await this.#tokenize(items, context);
+      return nativeTransformWithProviderResults(
+        text,
+        prepared.findings,
+        config.transform,
+        context,
+        resolved,
+        tokens,
+      );
+    } catch (error) {
+      throw withPathPrefix(error, "/transform");
+    } finally {
+      resolved.forEach(({ key }) => key.fill(0));
+    }
+  }
+
+
+  async restore(text, context) {
+    if (typeof text !== "string") {
+      throw new TypeError("restore text must be a string");
+    }
+    let items;
+    try {
+      items = nativeRequiredRestoreItems(text, context);
+    } catch (error) {
+      throw normalizeError(error, "invalid_configuration");
+    }
+    if (items.length === 0) return nativeRestoreWithResults(text, context, []);
+    if (!this.#tokenProvider) {
+      throw new DataFogError({
+        code: "token_provider_required",
+        message: "restoration requires a runtime token provider",
+      });
+    }
+    let results;
+    try {
+      results = await this.#tokenProvider.restoreBatch(context.scope, items);
+    } catch (error) {
+      throw normalizeProviderError(error, undefined, "token_provider_error");
+    }
+    return nativeRestoreWithResults(text, context, Array.isArray(results) ? results : []);
+  }
+}
+
+export function scan(text, config) {
+  if (typeof text !== "string") {
+    throw new TypeError("scan text must be a string");
+  }
+
+  try {
+    return nativeScan(text, config);
+  } catch (error) {
+    throw normalizeError(
+      error,
+      config === undefined ? "internal_error" : "invalid_configuration",
+    );
+  }
+}
+
+export function transform(text, findings, config) {
+  if (typeof text !== "string") {
+    throw new TypeError("transform text must be a string");
+  }
+  if (!Array.isArray(findings)) {
+    throw new TypeError("transform findings must be an array");
+  }
+
+  try {
+    return nativeTransform(text, findings, config);
+  } catch (error) {
+    throw normalizeError(error, "invalid_configuration");
+  }
+}
+
+export function scanAndTransform(text, config) {
+  if (typeof text !== "string") {
+    throw new TypeError("scanAndTransform text must be a string");
+  }
+
+  try {
+    return nativeScanAndTransform(text, config);
+  } catch (error) {
+    throw normalizeError(error, "invalid_configuration");
+  }
+}

package/native.js

@@ -0,0 +1,716 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+const __dirname = new URL('.', import.meta.url).pathname
+
+const { readFileSync } = require('fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (process.report && typeof process.report.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./datafog.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-android-arm64')
+        const bindingPackageVersion = require('@datafog/node-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./datafog.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-android-arm-eabi')
+        const bindingPackageVersion = require('@datafog/node-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if ((process.config && process.config.variables && process.config.variables.shlib_suffix === 'dll.a') || (process.config && process.config.variables && process.config.variables.node_target_type === 'shared_library')) {
+        try {
+        return require('./datafog.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-win32-x64-gnu')
+        const bindingPackageVersion = require('@datafog/node-win32-x64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      } else {
+        try {
+        return require('./datafog.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-win32-x64-msvc')
+        const bindingPackageVersion = require('@datafog/node-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./datafog.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-win32-ia32-msvc')
+        const bindingPackageVersion = require('@datafog/node-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./datafog.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-win32-arm64-msvc')
+        const bindingPackageVersion = require('@datafog/node-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./datafog.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@datafog/node-darwin-universal')
+      const bindingPackageVersion = require('@datafog/node-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./datafog.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-darwin-x64')
+        const bindingPackageVersion = require('@datafog/node-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./datafog.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-darwin-arm64')
+        const bindingPackageVersion = require('@datafog/node-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./datafog.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-freebsd-x64')
+        const bindingPackageVersion = require('@datafog/node-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./datafog.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-freebsd-arm64')
+        const bindingPackageVersion = require('@datafog/node-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./datafog.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-x64-musl')
+          const bindingPackageVersion = require('@datafog/node-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./datafog.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-x64-gnu')
+          const bindingPackageVersion = require('@datafog/node-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./datafog.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-arm64-musl')
+          const bindingPackageVersion = require('@datafog/node-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./datafog.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-arm64-gnu')
+          const bindingPackageVersion = require('@datafog/node-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./datafog.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@datafog/node-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./datafog.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@datafog/node-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./datafog.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-loong64-musl')
+          const bindingPackageVersion = require('@datafog/node-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./datafog.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-loong64-gnu')
+          const bindingPackageVersion = require('@datafog/node-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./datafog.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-riscv64-musl')
+          const bindingPackageVersion = require('@datafog/node-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./datafog.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@datafog/node-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@datafog/node-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./datafog.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@datafog/node-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./datafog.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-linux-s390x-gnu')
+        const bindingPackageVersion = require('@datafog/node-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./datafog.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-openharmony-arm64')
+        const bindingPackageVersion = require('@datafog/node-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./datafog.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-openharmony-x64')
+        const bindingPackageVersion = require('@datafog/node-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./datafog.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@datafog/node-openharmony-arm')
+        const bindingPackageVersion = require('@datafog/node-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.2.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+function createLoadErrorChain(errors) {
+  return errors.reduce((previous, current) => {
+    let message
+    try {
+      message =
+        current && typeof current.message === 'string'
+          ? current.message
+          : String(current)
+    } catch {
+      message = 'Unknown error'
+    }
+    const error = new Error(message)
+    error.cause = previous
+    return error
+  }, null)
+}
+
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → prefer WASI, but retain native as a lazy fallback
+//   'error'                  → require WASI without initializing a native fallback
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+//
+// NAPI_RS_WASI_FLAVOR selects one exact generated flavor and implies strict
+// WASI loading. It never crosses into another flavor or falls back to native.
+const __napiWasiFlavors = ["wasm32-wasi"]
+const __napiWasiFlavor = process.env.NAPI_RS_WASI_FLAVOR
+const __napiWasiFlavorRequested =
+  typeof __napiWasiFlavor === 'string' && __napiWasiFlavor.length > 0
+if (
+  __napiWasiFlavorRequested &&
+  __napiWasiFlavors.indexOf(__napiWasiFlavor) === -1
+) {
+  throw new Error(
+    'Unsupported WASI flavor "' +
+      __napiWasiFlavor +
+      '". Available flavors: ' +
+      __napiWasiFlavors.join(', '),
+  )
+}
+const forceWasiError = process.env.NAPI_RS_FORCE_WASI === 'error'
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' ||
+  forceWasiError ||
+  __napiWasiFlavorRequested
+
+if (!forceWasi) {
+  nativeBinding = requireNative()
+}
+
+if (!nativeBinding || forceWasi) {
+  let wasiBinding = null
+  let wasiBindingLoaded = false
+  const wasiBindingErrors = []
+  const __napiWasiResolveCandidate = (specifier, isPackage, localArtifacts) => {
+    try {
+      require.resolve(specifier)
+    } catch (resolveError) {
+      if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+        throw resolveError
+      }
+      if (isPackage) {
+        try {
+          require.resolve(specifier + '/package.json')
+        } catch (packageError) {
+          if (packageError && packageError.code === 'MODULE_NOT_FOUND') {
+            return resolveError
+          }
+          // An exports restriction proves the package exists even when its
+          // package.json is not public. Preserve the root resolution failure.
+          throw resolveError
+        }
+        // The package exists but its main/export target is broken.
+        throw resolveError
+      }
+      return resolveError
+    }
+    if (localArtifacts) {
+      let artifactError = null
+      for (let i = 0; i < localArtifacts.length; i++) {
+        try {
+          require.resolve(localArtifacts[i])
+          return null
+        } catch (resolveError) {
+          if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+            throw resolveError
+          }
+          artifactError = resolveError
+        }
+      }
+      return artifactError
+    }
+    return null
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === "wasm32-wasi")) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('./datafog.wasi.cjs', false, ["./datafog.wasm32-wasi.debug.wasm","./datafog.wasm32-wasi.wasm"])
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        wasiBinding = require('./datafog.wasi.cjs')
+        nativeBinding = wasiBinding
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === "wasm32-wasi")) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('@datafog/node-wasm32-wasi', true, undefined)
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        if (process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          const bindingPackageVersion = require('@datafog/node-wasm32-wasi/package.json').version
+          if (bindingPackageVersion !== '0.2.0') {
+            throw new Error(`WASI binding package version mismatch, expected 0.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+        }
+        wasiBinding = require('@datafog/node-wasm32-wasi')
+        nativeBinding = wasiBinding
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (
+    !wasiBindingLoaded &&
+    forceWasi &&
+    !forceWasiError &&
+    !__napiWasiFlavorRequested
+  ) {
+    nativeBinding = requireNative()
+  }
+  if ((forceWasiError || __napiWasiFlavorRequested) && !wasiBindingLoaded) {
+    const error = new Error(
+      __napiWasiFlavorRequested
+        ? 'WASI binding for flavor "' + __napiWasiFlavor + '" not found'
+        : 'WASI binding not found and NAPI_RS_FORCE_WASI is set to error',
+    )
+    error.cause = createLoadErrorChain(wasiBindingErrors)
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    const error = new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+    )
+    // assign instead of the `new Error(message, { cause })` options form,
+    // which Node < 16.9 silently ignores
+    error.cause = createLoadErrorChain(loadErrors)
+    throw error
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { prepareScanAndTransform, requiredKeySelectors, requiredRestoreItems, requiredTokenizationItems, restoreWithResults, scan, scanAndTransform, transform, transformWithProviderResults, transformWithResolvedKeys } = nativeBinding
+export { prepareScanAndTransform }
+export { requiredKeySelectors }
+export { requiredRestoreItems }
+export { requiredTokenizationItems }
+export { restoreWithResults }
+export { scan }
+export { scanAndTransform }
+export { transform }
+export { transformWithProviderResults }
+export { transformWithResolvedKeys }

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@datafog/node",
+  "version": "0.2.0",
+  "description": "Fast structured PII detection for Node.js, powered by Rust",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DataFog/datafog-core.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "index.js",
+    "native.js",
+    "index.d.ts",
+    "*.node"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "types": "./index.d.ts",
+  "engines": {
+    "node": "24.x"
+  },
+  "napi": {
+    "binaryName": "datafog",
+    "targets": [
+      "aarch64-apple-darwin",
+      "x86_64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc"
+    ],
+    "dtsHeaderFile": "dts-header.d.ts"
+  },
+  "scripts": {
+    "build": "napi build --manifest-path Cargo.toml --release --platform --esm --js native.js --dts index.d.ts",
+    "test:package": "node ../../scripts/test-node-package.mjs",
+    "prepublishOnly": "napi prepublish -t npm --no-gh-release"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "3.8.6",
+    "typescript": "7.0.2"
+  },
+  "optionalDependencies": {
+    "@datafog/node-darwin-arm64": "0.2.0",
+    "@datafog/node-darwin-x64": "0.2.0",
+    "@datafog/node-linux-x64-gnu": "0.2.0",
+    "@datafog/node-linux-arm64-gnu": "0.2.0",
+    "@datafog/node-win32-x64-msvc": "0.2.0"
+  }
+}