@stll/anonymize-wasm 2.0.0 → 2.0.2

package/dist/wasm.mjs

@@ -1,5 +1,166 @@
-import { DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, OPERATOR_TYPES } from "./constants.mjs";
+import { DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, ENTITY_CAPABILITIES, ENTITY_LABELS, ENTITY_SELECTIONS, OPERATOR_TYPES } from "./constants.mjs";
+import { CAPABILITY_MANIFEST, CAPABILITY_MANIFEST_SCHEMA_VERSION, CAPABILITY_RUNTIMES } from "./capabilities.mjs";
 //#region src/native.ts
+const CALLER_DETECTION_CONTRACT_VERSION = 2;
+const callerDetectionRequestJson = (detections) => JSON.stringify({
+	version: 2,
+	detections: detections.map((detection) => ({
+		start: detection.start,
+		end: detection.end,
+		label: detection.label,
+		score: detection.score,
+		provider_id: detection.providerId,
+		detection_id: detection.detectionId
+	}))
+});
+var PreparedNativeRedactionSession = class {
+	#session;
+	constructor(session) {
+		this.#session = session;
+	}
+	sessionId() {
+		return this.#session.sessionId();
+	}
+	session_id() {
+		return this.sessionId();
+	}
+	mappingCount() {
+		return this.#session.mappingCount();
+	}
+	mapping_count() {
+		return this.mappingCount();
+	}
+	restoreText(fullText, observedAtEpochSeconds) {
+		if (observedAtEpochSeconds === void 0) {
+			const restore = this.#session.restoreText;
+			if (!restore) throw new Error("Native anonymize binding does not support session restoration");
+			return restore.call(this.#session, fullText);
+		}
+		const restore = this.#session.restoreTextAt;
+		if (!restore) throw new Error("Native anonymize binding does not support session restoration lifecycle controls");
+		return restore.call(this.#session, fullText, observedAtEpochSeconds);
+	}
+	restore_text(fullText, observedAtEpochSeconds) {
+		return this.restoreText(fullText, observedAtEpochSeconds);
+	}
+	toPlaintextJson() {
+		return this.#session.toPlaintextJson();
+	}
+	to_plaintext_json() {
+		return this.toPlaintextJson();
+	}
+	toPlaintextJsonAt(observedAtEpochSeconds) {
+		const serialize = this.#session.toPlaintextJsonAt;
+		if (!serialize) throw new Error("Native anonymize binding does not support session lifecycle controls");
+		return serialize.call(this.#session, observedAtEpochSeconds);
+	}
+	to_plaintext_json_at(observedAtEpochSeconds) {
+		return this.toPlaintextJsonAt(observedAtEpochSeconds);
+	}
+	toEncryptedArchive(key) {
+		const serialize = this.#session.toEncryptedArchive;
+		if (!serialize) throw new Error("Native anonymize binding does not support encrypted session archives");
+		return serialize.call(this.#session, key);
+	}
+	to_encrypted_archive(key) {
+		return this.toEncryptedArchive(key);
+	}
+	toEncryptedArchiveAt(key, observedAtEpochSeconds) {
+		const serialize = this.#session.toEncryptedArchiveAt;
+		if (!serialize) throw new Error("Native anonymize binding does not support encrypted session archives");
+		return serialize.call(this.#session, key, observedAtEpochSeconds);
+	}
+	to_encrypted_archive_at(key, observedAtEpochSeconds) {
+		return this.toEncryptedArchiveAt(key, observedAtEpochSeconds);
+	}
+	inspect(observedAtEpochSeconds) {
+		const inspect = this.#session.inspectJson;
+		if (!inspect) throw new Error("Native anonymize binding does not support session lifecycle controls");
+		const metadata = JSON.parse(inspect.call(this.#session, observedAtEpochSeconds));
+		return {
+			sessionId: metadata.session_id,
+			createdAtEpochSeconds: metadata.created_at_epoch_seconds,
+			expiresAtEpochSeconds: metadata.expires_at_epoch_seconds,
+			mappingCount: metadata.mapping_count,
+			status: metadata.status
+		};
+	}
+	delete() {
+		const deleteSession = this.#session.deleteJson;
+		if (!deleteSession) throw new Error("Native anonymize binding does not support session lifecycle controls");
+		const summary = JSON.parse(deleteSession.call(this.#session));
+		return {
+			sessionId: summary.session_id,
+			deletedMappingCount: summary.deleted_mapping_count
+		};
+	}
+	redactStaticEntities(fullText, operators) {
+		const result = JSON.parse(this.redact_text_json(fullText, operators));
+		return fromCanonicalStaticRedactionResult(result);
+	}
+	redactText(fullText, operators) {
+		return this.redactStaticEntities(fullText, operators);
+	}
+	redact_text(fullText, operators) {
+		return this.redactText(fullText, operators);
+	}
+	redactTextJson(fullText, operators) {
+		return this.redact_text_json(fullText, operators);
+	}
+	redact_text_json(fullText, operators) {
+		return this.#session.redactStaticEntitiesJson(fullText, toBindingOperatorConfig(operators));
+	}
+	redactStaticEntitiesAt(options) {
+		const result = JSON.parse(this.redactTextJsonAt(options));
+		return fromCanonicalStaticRedactionResult(result);
+	}
+	redactTextAt(options) {
+		return this.redactStaticEntitiesAt(options);
+	}
+	redact_text_at(options) {
+		return this.redactTextAt(options);
+	}
+	redact_static_entities_at(options) {
+		return this.redactStaticEntitiesAt(options);
+	}
+	redactTextJsonAt({ fullText, observedAtEpochSeconds, operators }) {
+		const redact = this.#session.redactStaticEntitiesJsonAt;
+		if (!redact) throw new Error("Native anonymize binding does not support session lifecycle controls");
+		return redact.call(this.#session, fullText, observedAtEpochSeconds, toBindingOperatorConfig(operators));
+	}
+	redact_text_json_at(options) {
+		return this.redactTextJsonAt(options);
+	}
+	planTextBatchWithCallerDetections({ inputs, operators, observedAtEpochSeconds }) {
+		const plan = this.#session.planStaticEntitiesWithCallerDetections;
+		if (!plan) throw new Error("Native anonymize binding does not support transactional caller-detection session plans");
+		const bindingOperators = toBindingOperatorConfig(operators);
+		return new PreparedNativeSessionRedactionPlan(plan.call(this.#session, {
+			inputs: inputs.map(({ detections, fullText }) => ({
+				fullText,
+				requestJson: callerDetectionRequestJson(detections)
+			})),
+			...bindingOperators === void 0 ? {} : { operators: bindingOperators },
+			...observedAtEpochSeconds === void 0 ? {} : { observedAtEpochSeconds }
+		}));
+	}
+};
+var PreparedNativeSessionRedactionPlan = class {
+	blocks;
+	#plan;
+	constructor(plan) {
+		this.#plan = plan;
+		const blocks = JSON.parse(plan.resultJson());
+		this.blocks = blocks.map(({ caller_entity_count, entity_count, replacements }) => ({
+			replacements,
+			entityCount: entity_count,
+			callerEntityCount: caller_entity_count
+		}));
+	}
+	commit() {
+		this.#plan.commit();
+	}
+};
 var PreparedNativeAnonymizer = class {
 	#prepared;
 	constructor(prepared) {
@@ -28,6 +189,43 @@ var PreparedNativeAnonymizer = class {
 	warm_lazy_regex_diagnostics_json() {
 		return this.warmLazyRegexDiagnosticsJson();
 	}
+	createRedactionSession(sessionId) {
+		const create = this.#prepared.createRedactionSession;
+		if (!create) throw new Error("Native anonymize binding does not support redaction sessions");
+		return new PreparedNativeRedactionSession(create.call(this.#prepared, sessionId));
+	}
+	create_redaction_session(sessionId) {
+		return this.createRedactionSession(sessionId);
+	}
+	createRedactionSessionWithLifecycle({ sessionId, createdAtEpochSeconds, expiresAtEpochSeconds }) {
+		const create = this.#prepared.createRedactionSessionWithLifecycle;
+		if (!create) throw new Error("Native anonymize binding does not support session lifecycle controls");
+		return new PreparedNativeRedactionSession(create.call(this.#prepared, sessionId, createdAtEpochSeconds, expiresAtEpochSeconds));
+	}
+	create_redaction_session_with_lifecycle(options) {
+		return this.createRedactionSessionWithLifecycle(options);
+	}
+	restoreRedactionSession(plaintextJson) {
+		const restore = this.#prepared.restoreRedactionSession;
+		if (!restore) throw new Error("Native anonymize binding does not support redaction sessions");
+		return new PreparedNativeRedactionSession(restore.call(this.#prepared, plaintextJson));
+	}
+	restore_redaction_session(plaintextJson) {
+		return this.restoreRedactionSession(plaintextJson);
+	}
+	restoreEncryptedRedactionSession({ archive, key, expectedSessionId, observedAtEpochSeconds }) {
+		const restore = this.#prepared.restoreEncryptedRedactionSession;
+		if (!restore) throw new Error("Native anonymize binding does not support encrypted session archives");
+		return new PreparedNativeRedactionSession(restore.call(this.#prepared, {
+			archive,
+			key,
+			expectedSessionId,
+			...observedAtEpochSeconds === void 0 ? {} : { observedAtEpochSeconds }
+		}));
+	}
+	restore_encrypted_redaction_session(options) {
+		return this.restoreEncryptedRedactionSession(options);
+	}
 	redactStaticEntities(fullText, operators) {
 		return toNativeStaticRedactionResult(this.#prepared.redactStaticEntities(fullText, toBindingOperatorConfig(operators)));
 	}
@@ -39,6 +237,32 @@ var PreparedNativeAnonymizer = class {
 		if (this.#prepared.redactStaticEntitiesJson) return this.#prepared.redactStaticEntitiesJson(fullText, bindingOperators);
 		return JSON.stringify(toBindingStaticRedactionResult(toNativeStaticRedactionResult(this.#prepared.redactStaticEntities(fullText, bindingOperators))));
 	}
+	redactStaticEntitiesWithCallerDetections(fullText, options) {
+		if (!this.#prepared.redactStaticEntitiesWithCallerDetectionsJson) throw new Error("Native anonymize binding does not support caller detections");
+		const requestJson = callerDetectionRequestJson(options.detections);
+		const operators = toBindingOperatorConfig(options.operators);
+		const result = JSON.parse(this.#prepared.redactStaticEntitiesWithCallerDetectionsJson(fullText, {
+			requestJson,
+			...operators ? { operators } : {}
+		}));
+		return fromCanonicalStaticRedactionResult(result);
+	}
+	redact_text_with_caller_detections(fullText, options) {
+		return this.redactStaticEntitiesWithCallerDetections(fullText, options);
+	}
+	redactStaticEntitiesWithCallerDetectionsDiagnosticsJson(fullText, options) {
+		const redact = this.#prepared.redactStaticEntitiesWithCallerDetectionsDiagnosticsJson;
+		if (!redact) return null;
+		const requestJson = callerDetectionRequestJson(options.detections);
+		const operators = toBindingOperatorConfig(options.operators);
+		return redact.call(this.#prepared, fullText, {
+			requestJson,
+			...operators ? { operators } : {}
+		});
+	}
+	redact_static_entities_with_caller_detections_diagnostics_json(fullText, options) {
+		return this.redactStaticEntitiesWithCallerDetectionsDiagnosticsJson(fullText, options);
+	}
 	redactTextJson(fullText, operators) {
 		return this.redact_text_json(fullText, operators);
 	}
@@ -94,6 +318,30 @@ var PreparedNativePipeline = class {
 	warm_lazy_regex_diagnostics_json() {
 		return this.warmLazyRegexDiagnosticsJson();
 	}
+	createRedactionSession(sessionId) {
+		return this.#anonymizer.createRedactionSession(sessionId);
+	}
+	create_redaction_session(sessionId) {
+		return this.createRedactionSession(sessionId);
+	}
+	createRedactionSessionWithLifecycle(options) {
+		return this.#anonymizer.createRedactionSessionWithLifecycle(options);
+	}
+	create_redaction_session_with_lifecycle(options) {
+		return this.createRedactionSessionWithLifecycle(options);
+	}
+	restoreRedactionSession(plaintextJson) {
+		return this.#anonymizer.restoreRedactionSession(plaintextJson);
+	}
+	restore_redaction_session(plaintextJson) {
+		return this.restoreRedactionSession(plaintextJson);
+	}
+	restoreEncryptedRedactionSession(options) {
+		return this.#anonymizer.restoreEncryptedRedactionSession(options);
+	}
+	restore_encrypted_redaction_session(options) {
+		return this.restoreEncryptedRedactionSession(options);
+	}
 	redactText(fullText, operators) {
 		return this.#anonymizer.redactStaticEntities(fullText, operators);
 	}
@@ -103,6 +351,18 @@ var PreparedNativePipeline = class {
 	redact_text_json(fullText, operators) {
 		return this.#anonymizer.redact_text_json(fullText, operators);
 	}
+	redactTextWithCallerDetections(fullText, options) {
+		return this.#anonymizer.redactStaticEntitiesWithCallerDetections(fullText, options);
+	}
+	redact_text_with_caller_detections(fullText, options) {
+		return this.redactTextWithCallerDetections(fullText, options);
+	}
+	redactTextWithCallerDetectionsDiagnosticsJson(fullText, options) {
+		return this.#anonymizer.redactStaticEntitiesWithCallerDetectionsDiagnosticsJson(fullText, options);
+	}
+	redact_text_with_caller_detections_diagnostics_json(fullText, options) {
+		return this.redactTextWithCallerDetectionsDiagnosticsJson(fullText, options);
+	}
 	redactTextJson(fullText, operators) {
 		return this.redact_text_json(fullText, operators);
 	}
@@ -177,6 +437,20 @@ const toNativeStaticRedactionResult = (result) => ({
 	resolvedEntities: result.resolvedEntities.map(toNativePipelineEntity),
 	redaction: toNativeRedactionResult(result.redaction)
 });
+const fromCanonicalStaticRedactionResult = (result) => ({
+	resolvedEntities: result.resolved_entities.map(({ source_detail, provider_id, detection_id, ...entity }) => ({
+		...entity,
+		...source_detail ? { sourceDetail: source_detail } : {},
+		...provider_id ? { providerId: provider_id } : {},
+		...detection_id ? { detectionId: detection_id } : {}
+	})),
+	redaction: {
+		redactedText: result.redaction.redacted_text,
+		redactionMap: toRedactionMap(result.redaction.redaction_map),
+		operatorMap: toOperatorMap(result.redaction.operator_map),
+		entityCount: result.redaction.entity_count
+	}
+});
 const toBindingStaticRedactionResult = (result) => ({
 	resolved_entities: result.resolvedEntities.map(toBindingPipelineEntity),
 	redaction: {
@@ -199,11 +473,15 @@ const toNativePipelineEntity = (entity) => ({
 	text: entity.text,
 	score: entity.score,
 	source: entity.source,
-	...entity.sourceDetail ? { sourceDetail: entity.sourceDetail } : {}
+	...entity.sourceDetail ? { sourceDetail: entity.sourceDetail } : {},
+	...entity.providerId ? { providerId: entity.providerId } : {},
+	...entity.detectionId ? { detectionId: entity.detectionId } : {}
 });
-const toBindingPipelineEntity = ({ sourceDetail, ...entity }) => ({
+const toBindingPipelineEntity = ({ sourceDetail, providerId, detectionId, ...entity }) => ({
 	...entity,
-	source_detail: sourceDetail ?? null
+	source_detail: sourceDetail ?? null,
+	provider_id: providerId ?? null,
+	detection_id: detectionId ?? null
 });
 const toNativeRedactionResult = (result) => ({
 	redactedText: result.redactedText,
@@ -222,6 +500,20 @@ const toOperatorMap = (entries) => {
 	return map;
 };
 //#endregion
+//#region src/context.ts
+/** Create a fresh, empty pipeline context. */
+const createPipelineContext = () => ({
+	nativePipelinePackage: null,
+	nativePipelinePackageKey: "",
+	nativePipelinePackagePromise: null
+});
+/**
+* Module-level default context. Used when callers
+* don't provide an explicit context, preserving full
+* backward compatibility with the existing API.
+*/
+const defaultContext = createPipelineContext();
+//#endregion
 //#region src/redact.ts
 /**
 * Serialize the redaction key to JSON for export.
@@ -246,6 +538,317 @@ const deanonymise = (redactedText, redactionMap) => {
 	return result;
 };
 //#endregion
+//#region src/types.ts
+const isLegalFormsEnabled = (config) => config.enableLegalForms !== false;
+//#endregion
+//#region src/language-scope.ts
+const scopeData = {
+	_comment: "Default dictionary scopes for content language hints. Lower-level caller config can still override name corpus languages and deny-list countries independently.",
+	languages: {
+		"cs": {
+			"nameCorpusLanguages": ["cs", "sk"],
+			"denyListCountries": ["CZ", "SK"]
+		},
+		"de": {
+			"nameCorpusLanguages": ["de"],
+			"denyListCountries": [
+				"DE",
+				"AT",
+				"CH"
+			]
+		},
+		"en": {
+			"nameCorpusLanguages": ["en"],
+			"denyListCountries": [
+				"US",
+				"GB",
+				"CA",
+				"AU",
+				"IE"
+			]
+		},
+		"es": {
+			"nameCorpusLanguages": ["es"],
+			"denyListCountries": [
+				"ES",
+				"MX",
+				"AR",
+				"CL",
+				"CO",
+				"PE",
+				"EC",
+				"VE",
+				"UY",
+				"PY",
+				"BO",
+				"CR",
+				"PA",
+				"DO",
+				"GT",
+				"HN",
+				"SV",
+				"NI",
+				"CU"
+			]
+		},
+		"fr": {
+			"nameCorpusLanguages": ["fr"],
+			"denyListCountries": [
+				"FR",
+				"BE",
+				"CH",
+				"CA",
+				"LU",
+				"MC"
+			]
+		},
+		"hu": {
+			"nameCorpusLanguages": ["hu"],
+			"denyListCountries": ["HU"]
+		},
+		"it": {
+			"nameCorpusLanguages": ["it"],
+			"denyListCountries": ["IT", "CH"]
+		},
+		"pl": {
+			"nameCorpusLanguages": ["pl"],
+			"denyListCountries": ["PL"]
+		},
+		"pt-br": {
+			"nameCorpusLanguages": ["pt-br"],
+			"denyListCountries": ["BR"]
+		},
+		"ro": {
+			"nameCorpusLanguages": ["ro"],
+			"denyListCountries": ["RO", "MD"]
+		},
+		"sk": {
+			"nameCorpusLanguages": ["sk", "cs"],
+			"denyListCountries": ["SK", "CZ"]
+		},
+		"sv": {
+			"nameCorpusLanguages": ["sv"],
+			"denyListCountries": ["SE", "FI"]
+		}
+	}
+};
+const normalizeLanguage$1 = (language) => language.trim().toLowerCase();
+const fallbackLanguage = (language) => {
+	const index = language.indexOf("-");
+	return index === -1 ? null : language.slice(0, index);
+};
+const uniquePush = (target, values) => {
+	const seen = new Set(target);
+	for (const value of values) {
+		if (seen.has(value)) continue;
+		seen.add(value);
+		target.push(value);
+	}
+};
+const resolveLanguageScope = (language) => {
+	const normalized = normalizeLanguage$1(language);
+	if (normalized.length === 0) return null;
+	const exact = scopeData.languages[normalized];
+	if (exact !== void 0) return exact;
+	const fallback = fallbackLanguage(normalized);
+	return fallback === null ? null : scopeData.languages[fallback] ?? null;
+};
+const configuredLanguages = (config) => {
+	if (config.languages !== void 0) return config.languages;
+	return config.language === void 0 ? [] : [config.language];
+};
+const applyPipelineLanguageScope = (config) => {
+	const languages = configuredLanguages(config);
+	if (languages.length === 0) return config;
+	const nameCorpusLanguages = [];
+	const denyListCountries = [];
+	for (const language of languages) {
+		const scope = resolveLanguageScope(language);
+		if (scope === null) continue;
+		uniquePush(nameCorpusLanguages, scope.nameCorpusLanguages ?? []);
+		uniquePush(denyListCountries, scope.denyListCountries ?? []);
+	}
+	const next = {};
+	if (config.nameCorpusLanguages === void 0 && nameCorpusLanguages.length > 0) next.nameCorpusLanguages = nameCorpusLanguages;
+	if (config.denyListCountries === void 0 && denyListCountries.length > 0) next.denyListCountries = denyListCountries;
+	return Object.keys(next).length === 0 ? config : {
+		...config,
+		...next
+	};
+};
+//#endregion
+//#region src/util/language-selection.ts
+const normalizeLanguageCode = (language) => language.trim().toLowerCase();
+const normalizeLanguageSelection = (languages) => languages === void 0 ? [] : languages.map(normalizeLanguageCode).filter((language) => language.length > 0);
+const languageSelectionKey = (languages) => {
+	const normalized = normalizeLanguageSelection(languages).toSorted();
+	return normalized.length === 0 ? "*" : normalized.join(",");
+};
+//#endregion
+//#region src/pipeline-cache-key.ts
+const DEFAULT_CUSTOM_REGEX_SCORE = .9;
+const contentLanguageFingerprint = (config) => {
+	return languageSelectionKey(config.languages ?? (config.language === void 0 ? [] : [config.language]));
+};
+const pipelineConfigKey = (config, gazetteerEntries) => {
+	const legalFormsEnabled = isLegalFormsEnabled(config);
+	const customDenyFingerprint = config.enableDenyList && config.customDenyList ? config.customDenyList.map((entry) => JSON.stringify({
+		label: entry.label,
+		value: entry.value,
+		variants: [...entry.variants ?? []].sort()
+	})).sort().join("\n") : "";
+	const customRegexFingerprint = config.enableRegex && config.customRegexes ? config.customRegexes.map((entry) => JSON.stringify({
+		label: entry.label,
+		pattern: entry.pattern,
+		preparedArtifactPolicy: entry.preparedArtifactPolicy ?? null,
+		score: entry.score ?? DEFAULT_CUSTOM_REGEX_SCORE
+	})).sort().join("\n") : "";
+	const gazFingerprint = config.enableGazetteer && gazetteerEntries.length > 0 ? gazetteerEntries.map((entry) => `${entry.id}:${entry.canonical}:${entry.label}:${[...entry.variants].sort().join(",")}`).toSorted().join(";") : "";
+	return `${config.enableDenyList}:${config.enableTriggerPhrases}:${legalFormsEnabled}:${config.enableNameCorpus}:${contentLanguageFingerprint(config)}:${config.nameCorpusLanguages?.toSorted().join(",") ?? ""}:${config.enableRegex}:${config.threshold}:${config.enableConfidenceBoost}:${config.enableHotwordRules === true}:${config.enableCoreference === true}:${config.enableZoneClassification === true}:${config.labels.toSorted().join(",")}:${config.denyListCountries?.toSorted().join(",") ?? ""}:${config.denyListRegions?.toSorted().join(",") ?? ""}:${config.denyListExcludeCategories?.toSorted().join(",") ?? ""}:${customDenyFingerprint}:${customRegexFingerprint}:${config.enableGazetteer}:${gazFingerprint}:${config.enableCountries !== false}`;
+};
+//#endregion
+//#region src/native-pipeline.ts
+const sharedPackageByDictionaries = /* @__PURE__ */ new WeakMap();
+const sharedPackageWithoutDictionaries = /* @__PURE__ */ new Map();
+const dictionaryCacheIds = /* @__PURE__ */ new WeakMap();
+let nextDictionaryCacheId = 0;
+const dictionaryCacheKey = (dictionaries) => {
+	if (dictionaries === void 0) return "none";
+	const existing = dictionaryCacheIds.get(dictionaries);
+	if (existing !== void 0) return `dict:${existing}`;
+	nextDictionaryCacheId += 1;
+	dictionaryCacheIds.set(dictionaries, nextDictionaryCacheId);
+	return `dict:${nextDictionaryCacheId}`;
+};
+const sharedPackageCacheFor = (dictionaries) => {
+	if (dictionaries === void 0) return sharedPackageWithoutDictionaries;
+	const cached = sharedPackageByDictionaries.get(dictionaries);
+	if (cached !== void 0) return cached;
+	const created = /* @__PURE__ */ new Map();
+	sharedPackageByDictionaries.set(dictionaries, created);
+	return created;
+};
+const getNativePipelineCompatibility = (config) => {
+	const unsupportedFeatures = [];
+	if (config.enableNer) unsupportedFeatures.push("enableNer");
+	if (unsupportedFeatures.length === 0) return { status: "supported" };
+	return {
+		status: "unsupported",
+		unsupportedFeatures
+	};
+};
+const assertNativePipelineSupported = (config) => {
+	const compatibility = getNativePipelineCompatibility(config);
+	if (compatibility.status === "supported") return;
+	throw new Error(`Native pipeline does not yet support: ${compatibility.unsupportedFeatures.join(", ")}`);
+};
+const encoder = new TextEncoder();
+/**
+* Serialize the assembler inputs the Rust binding expects. Dictionaries are
+* stripped from the pipeline config and passed out of band: the assembler reads
+* the separate bundle preferentially, and keeping the (large) dictionaries out
+* of the config JSON avoids serializing them twice.
+*/
+const toAssembleInputs = ({ dictionaries, enableNer = false, ...config }, gazetteerEntries) => ({
+	pipelineConfigJson: encoder.encode(JSON.stringify({
+		...config,
+		enableNer
+	})),
+	dictionariesJson: dictionaries === void 0 ? void 0 : encoder.encode(JSON.stringify(dictionaries)),
+	gazetteerJson: gazetteerEntries.length === 0 ? void 0 : encoder.encode(JSON.stringify(gazetteerEntries))
+});
+const assemblePackageBytes = (binding, { pipelineConfigJson, dictionariesJson, gazetteerJson }, compressed) => {
+	const assemble = compressed ? binding.assembleStaticSearchCompressedPackageBytes : binding.assembleStaticSearchPackageBytes;
+	if (assemble === void 0) throw new Error("Native anonymize binding does not support static-search config assembly");
+	return assemble(pipelineConfigJson, dictionariesJson, gazetteerJson);
+};
+const prepareNativePipelineConfig = async ({ binding, config, gazetteerEntries = [] }) => {
+	const scopedConfig = applyPipelineLanguageScope(config);
+	assertNativePipelineSupported(scopedConfig);
+	const assemble = binding.assembleStaticSearchConfigJson;
+	if (assemble === void 0) throw new Error("Native anonymize binding does not support static-search config assembly");
+	const { pipelineConfigJson, dictionariesJson, gazetteerJson } = toAssembleInputs(scopedConfig, gazetteerEntries);
+	const configJson = assemble(pipelineConfigJson, dictionariesJson, gazetteerJson);
+	return JSON.parse(new TextDecoder().decode(configJson));
+};
+const prepareNativePipelinePackage = async ({ binding, config, gazetteerEntries = [], context, compressed = false }) => {
+	const packageBytes = await getCachedNativePipelinePackage({
+		config,
+		binding,
+		gazetteerEntries,
+		...context ? { context } : {},
+		compressed
+	});
+	return new Uint8Array(packageBytes);
+};
+const createNativePipelineFromConfig = async ({ binding, config, gazetteerEntries = [], context }) => {
+	return createNativePipelineFromPackage({
+		binding,
+		packageBytes: await getCachedNativePipelinePackage({
+			binding,
+			config,
+			gazetteerEntries,
+			...context ? { context } : {}
+		})
+	});
+};
+const getCachedNativePipelinePackage = async ({ binding, config, gazetteerEntries = [], context, compressed = false }) => {
+	const scopedConfig = applyPipelineLanguageScope(config);
+	assertNativePipelineSupported(scopedConfig);
+	const ctx = context ?? defaultContext;
+	const key = nativePackageCacheKey({
+		binding,
+		config: scopedConfig,
+		gazetteerEntries,
+		compressed
+	});
+	if (ctx.nativePipelinePackage && ctx.nativePipelinePackageKey === key) return ctx.nativePipelinePackage;
+	if (ctx.nativePipelinePackagePromise && ctx.nativePipelinePackageKey === key) return ctx.nativePipelinePackagePromise;
+	const sharedCache = sharedPackageCacheFor(scopedConfig.dictionaries);
+	const shared = sharedCache.get(key);
+	if (shared !== void 0) {
+		const packageBytes = await shared;
+		ctx.nativePipelinePackage = packageBytes;
+		ctx.nativePipelinePackageKey = key;
+		ctx.nativePipelinePackagePromise = null;
+		return packageBytes;
+	}
+	ctx.nativePipelinePackage = null;
+	ctx.nativePipelinePackageKey = key;
+	const promise = buildNativePipelinePackage({
+		binding,
+		config: scopedConfig,
+		gazetteerEntries,
+		compressed
+	});
+	ctx.nativePipelinePackagePromise = promise;
+	sharedCache.set(key, promise);
+	let packageBytes;
+	try {
+		packageBytes = await promise;
+	} catch (error) {
+		if (sharedCache.get(key) === promise) sharedCache.delete(key);
+		if (ctx.nativePipelinePackageKey === key && ctx.nativePipelinePackagePromise === promise) {
+			ctx.nativePipelinePackage = null;
+			ctx.nativePipelinePackagePromise = null;
+		}
+		throw error;
+	}
+	if (sharedCache.get(key) === promise) sharedCache.set(key, packageBytes);
+	if (ctx.nativePipelinePackageKey === key) {
+		ctx.nativePipelinePackage = packageBytes;
+		ctx.nativePipelinePackagePromise = null;
+	}
+	return packageBytes;
+};
+const buildNativePipelinePackage = async ({ binding, config, gazetteerEntries, compressed }) => assemblePackageBytes(binding, toAssembleInputs(config, gazetteerEntries), compressed);
+const nativePackageCacheKey = ({ binding, config, gazetteerEntries, compressed }) => [
+	binding.nativePackageVersion(),
+	compressed ? "compressed" : "raw",
+	dictionaryCacheKey(config.dictionaries),
+	pipelineConfigKey(config, gazetteerEntries)
+].join(":");
+//#endregion
 //#region src/wasm.ts
 const NODE_GLUE_MODULE = "index.wasi.cjs";
 const BROWSER_GLUE_MODULE = "index.wasi-browser.js";
@@ -262,10 +865,12 @@ const getBinding = () => {
 	return bindingPromise;
 };
 const loadWasmBinding = async () => {
-	return toNativeAnonymizeBinding(await import(
+	const glueModule = isNodeRuntime() ? NODE_GLUE_MODULE : BROWSER_GLUE_MODULE;
+	const loaded = await import(
 		/* @vite-ignore */
-		assetUrl(isNodeRuntime() ? NODE_GLUE_MODULE : BROWSER_GLUE_MODULE).href
-));
+		assetUrl(glueModule).href
+);
+	return toNativeAnonymizeBinding(loaded);
 };
 const isNodeRuntime = () => {
 	const globals = globalThis;
@@ -425,6 +1030,6 @@ const normalizeLanguage = (language) => {
 	return normalized;
 };
 //#endregion
-export { DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, OPERATOR_TYPES, PreparedAnonymizer, PreparedNativeAnonymizer, PreparedNativePipeline, PreparedSearch, assertNativeBindingVersion, createNativeAnonymizerFromConfig, createNativeAnonymizerFromPackage, createNativePipelineFromPackage, deanonymise, defaultPackageUrl, diagnostics_json, diagnostics_stream_json, encodeNativeSearchConfig, encodeNativeSearchConfigInput, exportRedactionKey, getBinding, getDefaultPipeline, getNativeBindingVersion, loadDefaultPipeline, loadPipeline, load_prepared_package, native_package_version, normalize_for_search, prepareNativeSearchPackage, prepare_search_package, redactDefaultText, redactDefaultTextJson, redact_text, redact_text_json, redact_text_stream_json, summary_diagnostics_json };
+export { CALLER_DETECTION_CONTRACT_VERSION, CAPABILITY_MANIFEST, CAPABILITY_MANIFEST_SCHEMA_VERSION, CAPABILITY_RUNTIMES, DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, ENTITY_CAPABILITIES, ENTITY_LABELS, ENTITY_SELECTIONS, OPERATOR_TYPES, PreparedAnonymizer, PreparedNativeAnonymizer, PreparedNativePipeline, PreparedNativeRedactionSession, PreparedNativeSessionRedactionPlan, PreparedSearch, assertNativeBindingVersion, assertNativePipelineSupported, createNativeAnonymizerFromConfig, createNativeAnonymizerFromPackage, createNativePipelineFromConfig, createNativePipelineFromPackage, createPipelineContext, deanonymise, defaultPackageUrl, diagnostics_json, diagnostics_stream_json, encodeNativeSearchConfig, encodeNativeSearchConfigInput, exportRedactionKey, getBinding, getDefaultPipeline, getNativeBindingVersion, getNativePipelineCompatibility, loadDefaultPipeline, loadPipeline, load_prepared_package, native_package_version, normalize_for_search, prepareNativePipelineConfig, prepareNativePipelinePackage, prepareNativeSearchPackage, prepare_search_package, redactDefaultText, redactDefaultTextJson, redact_text, redact_text_json, redact_text_stream_json, summary_diagnostics_json };
 
 //# sourceMappingURL=wasm.mjs.map