@stll/anonymize-wasm 2.8.2 → 2.9.0

package/dist/wasm.mjs

@@ -69,6 +69,11 @@ const isNativeAnonymizeBinding = (candidate) => {
 	return isBindingPropertyBag(preparedSearch) && NATIVE_BINDING_PARITY_MEMBERS.factories.every((name) => typeof preparedSearch[name] === "function");
 };
 const CALLER_DETECTION_CONTRACT_VERSION = 2;
+const CALLER_DETECTION_MAX_COUNT = 1e6;
+const CALLER_DETECTION_TEXT_MAX_BYTES = 64 * 1024 * 1024;
+const CALLER_DETECTION_REQUEST_JSON_MAX_BYTES = 16 * 1024 * 1024;
+const SESSION_CALLER_MAX_INPUTS = 1e5;
+const SESSION_CALLER_INPUTS_JSON_MAX_BYTES = 64 * 1024 * 1024;
 const EXTERNAL_DETECTION_BATCH_VERSION = 1;
 const EXTERNAL_DETECTION_BATCH_MAX_BYTES = 16 * 1024 * 1024;
 const EXTERNAL_DETECTION_DOCUMENT_MAX_BYTES = 64 * 1024 * 1024;
@@ -84,17 +89,184 @@ const EXTERNAL_DETECTION_OFFSET_UNITS = {
 const convert_external_detection_batch$1 = ({ binding, document, batch }) => {
 	return binding.convertExternalDetectionBatch(document, typeof batch === "string" ? batch : JSON.stringify(batch));
 };
-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
-	}))
-});
+const utf8ByteLengthWithin = (text, maximum) => {
+	let bytes = 0;
+	for (let index = 0; index < text.length; index += 1) {
+		const unit = text.charCodeAt(index);
+		if (unit <= 127) bytes += 1;
+		else if (unit <= 2047) bytes += 2;
+		else if (unit >= 55296 && unit <= 56319 && index + 1 < text.length && text.charCodeAt(index + 1) >= 56320 && text.charCodeAt(index + 1) <= 57343) {
+			bytes += 4;
+			index += 1;
+		} else bytes += 3;
+		if (bytes > maximum) return;
+	}
+	return bytes;
+};
+const validateCallerDetectionInput = (fullText, detections) => {
+	if (!Array.isArray(detections)) throw new TypeError("Caller detections must be an array");
+	if (detections.length > 1e6) throw new RangeError(`Caller detections contains ${detections.length} items; the maximum is ${CALLER_DETECTION_MAX_COUNT}`);
+	const textBytes = utf8ByteLengthWithin(fullText, CALLER_DETECTION_TEXT_MAX_BYTES);
+	if (textBytes === void 0) throw new RangeError(`Caller detection text exceeds the ${CALLER_DETECTION_TEXT_MAX_BYTES}-byte maximum`);
+	return textBytes;
+};
+var BoundedJsonSink = class {
+	#maximumBytes;
+	#label;
+	#reportedMaximumBytes;
+	#bytes = 0;
+	constructor(maximumBytes, label, suffix) {
+		this.#maximumBytes = maximumBytes - suffix.length;
+		this.#label = label;
+		this.#reportedMaximumBytes = maximumBytes;
+	}
+	appendAscii(value) {
+		this.#reserve(value.length);
+		this.capture(value);
+	}
+	appendOffset(value, field) {
+		this.#requireNumber(value, field);
+		if (!Number.isInteger(value) || value < 0 || value > 4294967295) throw new RangeError(`${field} must be an integer between 0 and 4294967295`);
+		this.#appendNumber(value);
+	}
+	appendScore(value, field) {
+		this.#requireNumber(value, field);
+		if (!Number.isFinite(value) || value < 0 || value > 1) throw new RangeError(`${field} must be finite and between 0 and 1`);
+		this.#appendNumber(value);
+	}
+	appendString(value, field) {
+		if (typeof value !== "string") throw new TypeError(`${field} must be a string`);
+		this.appendAscii("\"");
+		let runStart = 0;
+		for (let index = 0; index < value.length; index += 1) {
+			const unit = value.charCodeAt(index);
+			const escape = jsonEscape(unit);
+			if (escape !== void 0) {
+				this.#appendReservedRun(value, runStart, index);
+				this.appendAscii(escape);
+				runStart = index + 1;
+				continue;
+			}
+			if (unit >= 55296 && unit <= 56319 && index + 1 < value.length && value.charCodeAt(index + 1) >= 56320 && value.charCodeAt(index + 1) <= 57343) {
+				this.#reserve(4);
+				index += 1;
+				continue;
+			}
+			if (unit >= 55296 && unit <= 57343) {
+				this.#appendReservedRun(value, runStart, index);
+				this.appendAscii(`\\u${unit.toString(16).padStart(4, "0")}`);
+				runStart = index + 1;
+				continue;
+			}
+			let unitBytes = 3;
+			if (unit <= 127) unitBytes = 1;
+			else if (unit <= 2047) unitBytes = 2;
+			this.#reserve(unitBytes);
+		}
+		this.#appendReservedRun(value, runStart, value.length);
+		this.appendAscii("\"");
+	}
+	#appendReservedRun(value, start, end) {
+		if (end > start) this.capture(value.slice(start, end));
+	}
+	#appendNumber(value) {
+		this.appendAscii(JSON.stringify(value));
+	}
+	#requireNumber(value, field) {
+		if (typeof value !== "number") throw new TypeError(`${field} must be a number`);
+	}
+	#reserve(bytes) {
+		if (bytes > this.#maximumBytes - this.#bytes) throw new RangeError(`${this.#label} exceeds the ${this.#reportedMaximumBytes}-byte maximum`);
+		this.#bytes += bytes;
+	}
+};
+var CountingJsonBudget = class extends BoundedJsonSink {
+	capture(value) {}
+};
+var BoundedJsonWriter = class extends BoundedJsonSink {
+	#chunks = [];
+	#suffix;
+	constructor(maximumBytes, label, suffix) {
+		super(maximumBytes, label, suffix);
+		this.#suffix = suffix;
+	}
+	finish() {
+		return this.#chunks.join("") + this.#suffix;
+	}
+	capture(value) {
+		this.#chunks.push(value);
+	}
+};
+const jsonEscape = (unit) => {
+	switch (unit) {
+		case 8: return "\\b";
+		case 9: return "\\t";
+		case 10: return "\\n";
+		case 12: return "\\f";
+		case 13: return "\\r";
+		case 34: return "\\\"";
+		case 92: return "\\\\";
+		default: return unit < 32 ? `\\u${unit.toString(16).padStart(4, "0")}` : void 0;
+	}
+};
+const callerDetectionRequestJson = (fullText, detections) => {
+	validateCallerDetectionInput(fullText, detections);
+	return serializeCallerDetectionRequest(detections);
+};
+const serializeCallerDetectionRequest = (detections) => {
+	const writer = new BoundedJsonWriter(CALLER_DETECTION_REQUEST_JSON_MAX_BYTES, "Caller detection request JSON", "]}");
+	writer.appendAscii(`{"version":2,"detections":[`);
+	for (let index = 0; index < detections.length; index += 1) {
+		const detection = detections[index];
+		if (detection === void 0) throw new TypeError("Caller detections must not be sparse");
+		if (index > 0) writer.appendAscii(",");
+		writer.appendAscii("{\"start\":");
+		writer.appendOffset(detection.start, "Caller detection start");
+		writer.appendAscii(",\"end\":");
+		writer.appendOffset(detection.end, "Caller detection end");
+		writer.appendAscii(",\"label\":");
+		writer.appendString(detection.label, "Caller detection label");
+		writer.appendAscii(",\"score\":");
+		writer.appendScore(detection.score, "Caller detection score");
+		writer.appendAscii(",\"provider_id\":");
+		writer.appendString(detection.providerId, "Caller detection providerId");
+		writer.appendAscii(",\"detection_id\":");
+		writer.appendString(detection.detectionId, "Caller detection detectionId");
+		writer.appendAscii("}");
+	}
+	return writer.finish();
+};
+const toBindingSessionCallerInputs = (inputs) => {
+	if (!Array.isArray(inputs)) throw new TypeError("Session caller inputs must be an array");
+	if (inputs.length > 1e5) throw new RangeError(`Session caller inputs contains ${inputs.length} items; the maximum is ${SESSION_CALLER_MAX_INPUTS}`);
+	let detectionCount = 0;
+	let textBytes = 0;
+	const bindingInputs = [];
+	const budget = new CountingJsonBudget(SESSION_CALLER_INPUTS_JSON_MAX_BYTES, "Session caller inputs JSON", "]");
+	budget.appendAscii("[");
+	for (let index = 0; index < inputs.length; index += 1) {
+		const input = inputs[index];
+		if (input === void 0) throw new TypeError("Session caller inputs must not be sparse");
+		const { detections, fullText } = input;
+		const inputTextBytes = validateCallerDetectionInput(fullText, detections);
+		detectionCount += detections.length;
+		if (detectionCount > 1e6) throw new RangeError(`Session caller detections contains ${detectionCount} items; the maximum is ${CALLER_DETECTION_MAX_COUNT}`);
+		textBytes += inputTextBytes;
+		if (textBytes > 67108864) throw new RangeError(`Session caller text contains ${textBytes} bytes; the maximum is ${CALLER_DETECTION_TEXT_MAX_BYTES}`);
+		const requestJson = serializeCallerDetectionRequest(detections);
+		if (index > 0) budget.appendAscii(",");
+		budget.appendAscii("{\"full_text\":");
+		budget.appendString(fullText, "Session caller fullText");
+		budget.appendAscii(",\"request_json\":");
+		budget.appendString(requestJson, "Session caller requestJson");
+		budget.appendAscii("}");
+		bindingInputs.push({
+			fullText,
+			requestJson
+		});
+	}
+	return bindingInputs;
+};
 var PreparedNativeRedactionSession = class {
 	#session;
 	constructor(session) {
@@ -198,10 +370,7 @@ var PreparedNativeRedactionSession = class {
 	planTextBatchWithCallerDetections({ inputs, operators, observedAtEpochSeconds }) {
 		const bindingOperators = toBindingOperatorConfig(operators);
 		return new PreparedNativeSessionRedactionPlan(this.#session.planStaticEntitiesWithCallerDetections({
-			inputs: inputs.map(({ detections, fullText }) => ({
-				fullText,
-				requestJson: callerDetectionRequestJson(detections)
-			})),
+			inputs: toBindingSessionCallerInputs(inputs),
 			...bindingOperators === void 0 ? {} : { operators: bindingOperators },
 			...observedAtEpochSeconds === void 0 ? {} : { observedAtEpochSeconds }
 		}));
@@ -286,7 +455,7 @@ var PreparedNativeAnonymizer = class {
 		return this.#prepared.redactStaticEntitiesJson(fullText, bindingOperators);
 	}
 	redactStaticEntitiesWithCallerDetections(fullText, options) {
-		const requestJson = callerDetectionRequestJson(options.detections);
+		const requestJson = callerDetectionRequestJson(fullText, options.detections);
 		const operators = toBindingOperatorConfig(options.operators);
 		const result = JSON.parse(this.#prepared.redactStaticEntitiesWithCallerDetectionsJson(fullText, {
 			requestJson,
@@ -298,7 +467,7 @@ var PreparedNativeAnonymizer = class {
 		return this.redactStaticEntitiesWithCallerDetections(fullText, options);
 	}
 	redactStaticEntitiesWithCallerDetectionsDiagnosticsJson(fullText, options) {
-		const requestJson = callerDetectionRequestJson(options.detections);
+		const requestJson = callerDetectionRequestJson(fullText, options.detections);
 		const operators = toBindingOperatorConfig(options.operators);
 		return this.#prepared.redactStaticEntitiesWithCallerDetectionsDiagnosticsJson(fullText, {
 			requestJson,
@@ -628,10 +797,15 @@ const wrapSession = (raw) => ({
 	deleteJson: raw.deleteJson.bind(raw),
 	redactStaticEntitiesJson: (fullText, operators) => raw.redactStaticEntitiesJson(fullText, json(operators)),
 	redactStaticEntitiesJsonAt: (fullText, observedAtEpochSeconds, operators) => raw.redactStaticEntitiesJsonAt(fullText, observedAtEpochSeconds, json(operators)),
-	planStaticEntitiesWithCallerDetections: ({ inputs, operators, observedAtEpochSeconds }) => raw.planStaticEntitiesWithCallerDetections(JSON.stringify(inputs.map(({ fullText, requestJson }) => ({
-		full_text: fullText,
-		request_json: requestJson
-	}))), json(operators), observedAtEpochSeconds)
+	planStaticEntitiesWithCallerDetections: ({ inputs, operators, observedAtEpochSeconds }) => {
+		const inputsJson = JSON.stringify(inputs.map(({ fullText, requestJson }) => ({
+			full_text: fullText,
+			request_json: requestJson
+		})));
+		const inputsJsonBytes = new TextEncoder().encode(inputsJson).byteLength;
+		if (inputsJsonBytes > 67108864) throw new RangeError(`Session caller inputs JSON contains ${inputsJsonBytes} bytes; the maximum is ${SESSION_CALLER_INPUTS_JSON_MAX_BYTES}`);
+		return raw.planStaticEntitiesWithCallerDetections(inputsJson, json(operators), observedAtEpochSeconds);
+	}
 });
 const json = (value) => value === void 0 ? void 0 : JSON.stringify(value);
 const canonicalResult = (result) => ({
@@ -664,50 +838,62 @@ const assertPdfPixelPages = (pagePixels) => {
 	for (const [index, page] of pagePixels.entries()) if (!(page instanceof Uint8Array)) throw new TypeError(`PDF pagePixels[${index}] must be a Uint8Array`);
 };
 //#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.
-* Includes operator metadata so the export is self-describing.
-*/
-const exportRedactionKey = (redactionMap, operatorMap) => {
-	const entries = {};
-	for (const [placeholder, value] of redactionMap) entries[placeholder] = {
-		original: value,
-		operator: operatorMap.get(placeholder) ?? "replace"
-	};
-	return JSON.stringify({ entries }, null, 2);
-};
-/**
-* De-anonymise text using a redaction key.
-* Replaces placeholders back with original values.
-* Only works for reversible operators (replace).
-*/
-const deanonymise = (redactedText, redactionMap) => {
-	let result = redactedText;
-	for (const [placeholder, original] of redactionMap) result = result.replaceAll(placeholder, original);
-	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.",
+//#region src/data/language-scopes.json
+var language_scopes_default = {
+	_comment: "Default dictionary scopes for content language hints. The all-language city scope preserves the data package defaults and covers every supported language. Lower-level caller config can still override name corpus languages and deny-list countries independently.",
+	allLanguageCityCountries: [
+		"AR",
+		"AT",
+		"AU",
+		"BE",
+		"BG",
+		"BO",
+		"BR",
+		"CA",
+		"CH",
+		"CL",
+		"CO",
+		"CR",
+		"CU",
+		"CZ",
+		"DE",
+		"DK",
+		"DO",
+		"EC",
+		"ES",
+		"FI",
+		"FR",
+		"GB",
+		"GR",
+		"GT",
+		"HN",
+		"HR",
+		"HU",
+		"IE",
+		"IT",
+		"LU",
+		"LV",
+		"MC",
+		"MD",
+		"MX",
+		"NI",
+		"NL",
+		"NO",
+		"NZ",
+		"PA",
+		"PE",
+		"PL",
+		"PT",
+		"PY",
+		"RO",
+		"SE",
+		"SI",
+		"SK",
+		"SV",
+		"US",
+		"UY",
+		"VE"
+	],
 	languages: {
 		"cs": {
 			"nameCorpusLanguages": ["cs", "sk"],
@@ -800,7 +986,10 @@ const scopeData = {
 		}
 	}
 };
-const normalizeLanguage$1 = (language) => language.trim().toLowerCase();
+//#endregion
+//#region src/language-scope.ts
+const scopeData = language_scopes_default;
+const normalizeLanguage$2 = (language) => language.trim().toLowerCase();
 const fallbackLanguage = (language) => {
 	const index = language.indexOf("-");
 	return index === -1 ? null : language.slice(0, index);
@@ -814,7 +1003,7 @@ const uniquePush = (target, values) => {
 	}
 };
 const resolveLanguageScope = (language) => {
-	const normalized = normalizeLanguage$1(language);
+	const normalized = normalizeLanguage$2(language);
 	if (normalized.length === 0) return null;
 	const exact = scopeData.languages[normalized];
 	if (exact !== void 0) return exact;
@@ -830,21 +1019,50 @@ const applyPipelineLanguageScope = (config) => {
 	if (languages.length === 0) return config;
 	const nameCorpusLanguages = [];
 	const denyListCountries = [];
+	let hasResolvedScope = false;
 	for (const language of languages) {
 		const scope = resolveLanguageScope(language);
 		if (scope === null) continue;
+		hasResolvedScope = true;
 		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;
+	if (config.nameCorpusLanguages === void 0 && hasResolvedScope) next.nameCorpusLanguages = nameCorpusLanguages;
+	if (config.denyListCountries === void 0 && hasResolvedScope) next.denyListCountries = denyListCountries;
 	return Object.keys(next).length === 0 ? config : {
 		...config,
 		...next
 	};
 };
 //#endregion
+//#region src/build-native-package.ts
+const EMPTY_NAME_CORPUS_SCOPE = ["und"];
+const defaultDictionaryBundleOptions = (config) => ({
+	...config.denyListCountries === void 0 ? { cityCountries: language_scopes_default.allLanguageCityCountries } : {
+		countries: config.denyListCountries,
+		cityCountries: config.denyListCountries
+	},
+	...config.nameCorpusLanguages === void 0 ? {} : { nameLanguages: config.nameCorpusLanguages.length === 0 ? EMPTY_NAME_CORPUS_SCOPE : config.nameCorpusLanguages }
+});
+//#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/types.ts
+const isLegalFormsEnabled = (config) => config.enableLegalForms !== false;
+//#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);
@@ -1034,6 +1252,141 @@ const nativePackageCacheKey = ({ binding, config, gazetteerEntries, compressed }
 	pipelineConfigKey(config, gazetteerEntries)
 ].join(":");
 //#endregion
+//#region src/native-default-config.ts
+const DEFAULT_NATIVE_PIPELINE_CONFIG = {
+	threshold: .3,
+	enableTriggerPhrases: true,
+	enableRegex: true,
+	enableLegalForms: true,
+	enableNameCorpus: true,
+	enableDenyList: true,
+	enableGazetteer: false,
+	enableCountries: true,
+	enableConfidenceBoost: true,
+	enableCoreference: true,
+	enableHotwordRules: true,
+	enableZoneClassification: true,
+	standaloneStreetDetection: "off",
+	labels: [...DEFAULT_ENTITY_LABELS],
+	workspaceId: "native-pipeline-default"
+};
+//#endregion
+//#region src/pipeline-language.ts
+const isSupportedLanguage = (language) => Object.hasOwn(language_scopes_default.languages, language);
+const SUPPORTED_LANGUAGES = Object.freeze(Object.keys(language_scopes_default.languages).filter(isSupportedLanguage).toSorted());
+const normalizeLanguage$1 = (language) => {
+	if (typeof language !== "string") throw new TypeError("Pipeline language codes must be strings");
+	const normalized = language.trim().toLowerCase();
+	if (!isSupportedLanguage(normalized)) throw new RangeError(`Unsupported pipeline language ${JSON.stringify(language)}; expected one of: ${SUPPORTED_LANGUAGES.join(", ")}`);
+	return normalized;
+};
+const normalizePipelineLanguageSelection = (selection) => {
+	if (selection === void 0 || typeof selection === "string" && selection.trim().toLowerCase() === "all") return { type: "all" };
+	const requested = Array.isArray(selection) ? selection : [selection];
+	if (requested.length === 0) throw new RangeError("Pipeline language selection must not be empty");
+	const normalized = [...new Set(requested.map(normalizeLanguage$1))].toSorted();
+	const first = normalized.at(0);
+	if (first === void 0) throw new RangeError("Pipeline language selection must not be empty");
+	return {
+		type: "languages",
+		languages: [first, ...normalized.slice(1)]
+	};
+};
+const pipelineLanguageSelectionKey = (selection) => selection.type === "all" ? "all" : selection.languages.join(",");
+//#endregion
+//#region src/create-pipeline.ts
+const dictionaryCache = /* @__PURE__ */ new Map();
+const semanticPipelineCache = /* @__PURE__ */ new WeakMap();
+const MAX_SEMANTIC_PIPELINE_CACHE_ENTRIES = 8;
+const getCachedEntry = (cache, key) => {
+	const cached = cache.get(key);
+	if (cached === void 0) return;
+	cache.delete(key);
+	cache.set(key, cached);
+	return cached;
+};
+const setCachedEntry = (cache, key, value) => {
+	cache.set(key, value);
+	if (cache.size <= MAX_SEMANTIC_PIPELINE_CACHE_ENTRIES) return;
+	const oldestKey = cache.keys().next().value;
+	if (oldestKey !== void 0) cache.delete(oldestKey);
+};
+const loadSemanticDictionaries = (key, config) => {
+	const cached = getCachedEntry(dictionaryCache, key);
+	if (cached !== void 0) return cached;
+	let dictionaries;
+	dictionaries = import("@stll/anonymize-data/cities").then(({ loadDictionaryBundle }) => loadDictionaryBundle(defaultDictionaryBundleOptions(config))).catch((error) => {
+		if (dictionaryCache.get(key) === dictionaries) dictionaryCache.delete(key);
+		throw error;
+	});
+	setCachedEntry(dictionaryCache, key, dictionaries);
+	return dictionaries;
+};
+const pipelineConfigFor = (selection) => {
+	if (selection.type === "all") return {
+		...DEFAULT_NATIVE_PIPELINE_CONFIG,
+		labels: [...DEFAULT_NATIVE_PIPELINE_CONFIG.labels]
+	};
+	const [language, ...languages] = selection.languages;
+	return applyPipelineLanguageScope({
+		...DEFAULT_NATIVE_PIPELINE_CONFIG,
+		labels: [...DEFAULT_NATIVE_PIPELINE_CONFIG.labels],
+		workspaceId: `default-pipeline:${pipelineLanguageSelectionKey(selection)}`,
+		...languages.length === 0 ? { language } : { languages: [language, ...languages] }
+	});
+};
+const semanticPipelineCacheFor = (binding) => {
+	const cached = semanticPipelineCache.get(binding);
+	if (cached !== void 0) return cached;
+	const created = /* @__PURE__ */ new Map();
+	semanticPipelineCache.set(binding, created);
+	return created;
+};
+const createSemanticPipeline = ({ binding, selection }) => {
+	const key = pipelineLanguageSelectionKey(selection);
+	const cache = semanticPipelineCacheFor(binding);
+	const cached = getCachedEntry(cache, key);
+	if (cached !== void 0) return cached;
+	const config = pipelineConfigFor(selection);
+	let pipeline;
+	pipeline = loadSemanticDictionaries(key, config).then((dictionaries) => createNativePipelineFromConfig({
+		binding,
+		config: {
+			...config,
+			dictionaries
+		}
+	})).catch((error) => {
+		if (cache.get(key) === pipeline) cache.delete(key);
+		throw error;
+	});
+	setCachedEntry(cache, key, pipeline);
+	return pipeline;
+};
+//#endregion
+//#region src/redact.ts
+/**
+* Serialize the redaction key to JSON for export.
+* Includes operator metadata so the export is self-describing.
+*/
+const exportRedactionKey = (redactionMap, operatorMap) => {
+	const entries = {};
+	for (const [placeholder, value] of redactionMap) entries[placeholder] = {
+		original: value,
+		operator: operatorMap.get(placeholder) ?? "replace"
+	};
+	return JSON.stringify({ entries }, null, 2);
+};
+/**
+* De-anonymise text using a redaction key.
+* Replaces placeholders back with original values.
+* Only works for reversible operators (replace).
+*/
+const deanonymise = (redactedText, redactionMap) => {
+	let result = redactedText;
+	for (const [placeholder, original] of redactionMap) result = result.replaceAll(placeholder, original);
+	return result;
+};
+//#endregion
 //#region src/wasm.ts
 const GLUE_MODULE = "index.js";
 const WASM_MODULE = "index_bg.wasm";
@@ -1042,10 +1395,18 @@ const NATIVE_ASSET_DIR = "native";
 const ASSET_DIR_ENV = "STLL_ANONYMIZE_ASSET_DIR";
 const DEFAULT_PACKAGE_FILE = "native-pipeline.stlanonpkg";
 const LANGUAGE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const HTML_MEDIA_TYPES = /* @__PURE__ */ new Set(["application/xhtml+xml", "text/html"]);
 const DEFAULT_PIPELINE_CACHE_KEY = "<default>";
 const DEFAULT_PIPELINE_CACHE_MAX_ENTRIES = 32;
 let bindingPromise;
 const defaultPipelineCache = /* @__PURE__ */ new Map();
+const unavailablePackageUrls = /* @__PURE__ */ new Set();
+var PreparedPackageUnavailableError = class extends Error {
+	constructor(href, options) {
+		super(`Prepared package is unavailable: ${href}`, options);
+		this.name = "PreparedPackageUnavailableError";
+	}
+};
 /** Instantiate (once) and return the wasm binding. Safe to call repeatedly:
 * the underlying wasm module is instantiated a single time and cached. */
 const getBinding = () => {
@@ -1098,11 +1459,27 @@ const toPackageBytes = async (source) => {
 	if (source instanceof Uint8Array) return source;
 	if (source instanceof ArrayBuffer) return new Uint8Array(source);
 	const href = source instanceof URL ? source.href : source;
-	if (href.startsWith("file:")) return readFileUrlBytes(href);
+	if (href.startsWith("file:")) try {
+		return await readFileUrlBytes(href);
+	} catch (error) {
+		if (isMissingFileError(error)) throw new PreparedPackageUnavailableError(href, { cause: error });
+		throw error;
+	}
 	const response = await fetch(href);
-	if (!response.ok) throw new Error(`Failed to fetch prepared package (${response.status} ${response.statusText})`);
+	if (!response.ok) {
+		if (response.status === 404) throw new PreparedPackageUnavailableError(href);
+		throw new Error(`Failed to fetch prepared package (${response.status} ${response.statusText})`);
+	}
+	if (isHtmlResponse(response)) throw new PreparedPackageUnavailableError(href);
 	return new Uint8Array(await response.arrayBuffer());
 };
+const isHtmlResponse = (response) => {
+	const contentType = response.headers.get("content-type");
+	if (contentType === null) return false;
+	const mediaType = contentType.split(";", 1).at(0)?.trim().toLowerCase();
+	return mediaType !== void 0 && HTML_MEDIA_TYPES.has(mediaType);
+};
+const isMissingFileError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 /** Read a `file:` URL through node:fs. The import is dynamic and gated behind
 * the `file:` check (never reached in browsers); the specifier is a runtime
 * value so the bundler leaves it alone, mirroring the runtime glue import in
@@ -1143,6 +1520,7 @@ const loadDefaultPipeline = async (language, options) => {
 	try {
 		return await loadPipeline(defaultPackageUrl(language), options);
 	} catch (error) {
+		if (!(error instanceof PreparedPackageUnavailableError)) throw error;
 		const normalized = language === void 0 ? void 0 : normalizeLanguage(language);
 		const baseLanguage = normalized?.split("-").at(0);
 		if (baseLanguage === void 0 || baseLanguage === normalized) throw error;
@@ -1197,6 +1575,37 @@ const getDefaultPipeline = (language, options) => {
 	touchDefaultPipelineCacheEntry(key, pipeline);
 	return pipeline;
 };
+const createPipeline = async ({ language, ...bindingOptions } = {}) => {
+	const selection = normalizePipelineLanguageSelection(language);
+	if (selection.type === "all") {
+		const packageUrl = defaultPackageUrl();
+		if (!unavailablePackageUrls.has(packageUrl.href)) try {
+			return await getDefaultPipeline(void 0, bindingOptions);
+		} catch (error) {
+			if (!(error instanceof PreparedPackageUnavailableError)) throw error;
+			unavailablePackageUrls.add(packageUrl.href);
+		}
+		return createSemanticPipeline({
+			binding: await resolveBinding(bindingOptions),
+			selection
+		});
+	}
+	const [singleLanguage, ...additionalLanguages] = selection.languages;
+	if (additionalLanguages.length === 0) {
+		const packageUrl = defaultPackageUrl(singleLanguage);
+		if (!unavailablePackageUrls.has(packageUrl.href)) try {
+			return await getDefaultPipeline(singleLanguage, bindingOptions);
+		} catch (error) {
+			if (!(error instanceof PreparedPackageUnavailableError)) throw error;
+			unavailablePackageUrls.add(packageUrl.href);
+		}
+	}
+	return createSemanticPipeline({
+		binding: await resolveBinding(bindingOptions),
+		selection
+	});
+};
+const create_pipeline = createPipeline;
 const redactDefaultText = async (fullText, operators, language) => (await getDefaultPipeline(language)).redactText(fullText, operators);
 const redactDefaultTextJson = async (fullText, operators, language) => (await getDefaultPipeline(language)).redact_text_json(fullText, operators);
 const native_package_version = async (options) => native_package_version$1(await resolveBinding(options));
@@ -1271,6 +1680,6 @@ const normalizeLanguage = (language) => {
 	return normalized;
 };
 //#endregion
-export { CALLER_DETECTION_CONTRACT_VERSION, CAPABILITY_MANIFEST, CAPABILITY_MANIFEST_SCHEMA_VERSION, CAPABILITY_PARITY_PROFILES, CAPABILITY_RUNTIMES, CAPABILITY_SURFACES, DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, ENTITY_CAPABILITIES, ENTITY_LABELS, ENTITY_SELECTIONS, EXTERNAL_DETECTION_BATCH_MAX_BYTES, EXTERNAL_DETECTION_BATCH_VERSION, EXTERNAL_DETECTION_DOCUMENT_MAX_BYTES, EXTERNAL_DETECTION_MAX_DETECTIONS, EXTERNAL_DETECTION_MAX_LABEL_MAPPINGS, EXTERNAL_DETECTION_MAX_METADATA_BYTES, EXTERNAL_DETECTION_OFFSET_UNITS, EXTERNAL_DETECTION_PROVIDER_ID_MAX_BYTES, NATIVE_BINDING_PARITY_MEMBERS, OPERATOR_TYPES, PreparedAnonymizer, PreparedNativeAnonymizer, PreparedNativePipeline, PreparedNativeRedactionSession, PreparedNativeSessionRedactionPlan, PreparedSearch, assertNativeBindingVersion, assertNativePipelineSupported, convert_external_detection_batch, createNativeAnonymizerFromConfig, createNativeAnonymizerFromPackage, createNativePipelineFromConfig, createNativePipelineFromPackage, createPipelineContext, deanonymise, defaultPackageUrl, diagnostics_json, diagnostics_stream_json, encodeNativeSearchConfig, encodeNativeSearchConfigInput, exportRedactionKey, getBinding, getDefaultPipeline, getNativeBindingVersion, getNativePipelineCompatibility, inspect_pdf_json, isNativeAnonymizeBinding, 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 };
+export { CALLER_DETECTION_CONTRACT_VERSION, CALLER_DETECTION_MAX_COUNT, CALLER_DETECTION_REQUEST_JSON_MAX_BYTES, CALLER_DETECTION_TEXT_MAX_BYTES, CAPABILITY_MANIFEST, CAPABILITY_MANIFEST_SCHEMA_VERSION, CAPABILITY_PARITY_PROFILES, CAPABILITY_RUNTIMES, CAPABILITY_SURFACES, DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, ENTITY_CAPABILITIES, ENTITY_LABELS, ENTITY_SELECTIONS, EXTERNAL_DETECTION_BATCH_MAX_BYTES, EXTERNAL_DETECTION_BATCH_VERSION, EXTERNAL_DETECTION_DOCUMENT_MAX_BYTES, EXTERNAL_DETECTION_MAX_DETECTIONS, EXTERNAL_DETECTION_MAX_LABEL_MAPPINGS, EXTERNAL_DETECTION_MAX_METADATA_BYTES, EXTERNAL_DETECTION_OFFSET_UNITS, EXTERNAL_DETECTION_PROVIDER_ID_MAX_BYTES, NATIVE_BINDING_PARITY_MEMBERS, OPERATOR_TYPES, PreparedAnonymizer, PreparedNativeAnonymizer, PreparedNativePipeline, PreparedNativeRedactionSession, PreparedNativeSessionRedactionPlan, PreparedSearch, SESSION_CALLER_INPUTS_JSON_MAX_BYTES, SESSION_CALLER_MAX_INPUTS, SUPPORTED_LANGUAGES, assertNativeBindingVersion, assertNativePipelineSupported, convert_external_detection_batch, createNativeAnonymizerFromConfig, createNativeAnonymizerFromPackage, createNativePipelineFromConfig, createNativePipelineFromPackage, createPipeline, createPipelineContext, create_pipeline, deanonymise, defaultPackageUrl, diagnostics_json, diagnostics_stream_json, encodeNativeSearchConfig, encodeNativeSearchConfigInput, exportRedactionKey, getBinding, getDefaultPipeline, getNativeBindingVersion, getNativePipelineCompatibility, inspect_pdf_json, isNativeAnonymizeBinding, 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