@stll/anonymize-mcp 0.0.1-placeholder.0 → 2.4.1

package/dist/local.mjs

@@ -0,0 +1,1181 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CAPABILITY_MANIFEST } from "@stll/anonymize";
+import { DOCX_ARCHIVE_MAX_BYTES, DOCX_COVERAGE_MODES, anonymizeDocx, extractDocxText, restoreDocxText } from "@stll/anonymize-docx";
+import { PDF_DOCUMENT_MAX_BYTES, anonymizePdfRaster, renderPdfWithPopplerTesseract } from "@stll/anonymize-pdf";
+import * as nativeNode from "@stll/anonymize/native-node";
+import { constants, link, lstat, open, readdir, realpath, rename, stat, unlink } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import * as z from "zod/v4";
+//#region src/durable-sessions.ts
+const SESSION_ARCHIVE_KEY_BYTES = 32;
+const SESSION_ARCHIVE_MAX_BYTES = 16777273;
+const SESSION_ARCHIVE_MAX_COUNT = 256;
+const SESSION_ARCHIVE_TOTAL_MAX_BYTES = 256 * 1024 * 1024;
+const ARCHIVE_NAME = /^[a-f0-9]{64}\.stlasess$/u;
+const SESSION_ID$1 = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u;
+const STAGING_NAME = /^[a-f0-9]{64}\.stlasess\.tmp\.[0-9a-f]{8}-[0-9a-f-]{27}$/u;
+const READ_CHUNK_BYTES$1 = 64 * 1024;
+const LOCK_FILE_NAME = ".stella-session.lock";
+const DURABLE_SESSION_FAULT_POINTS = {
+	beforeDirectoryFsync: "before-directory-fsync",
+	beforeRename: "before-rename",
+	beforeStagingFsync: "before-staging-fsync",
+	beforeStagingWrite: "before-staging-write"
+};
+const sameFile$1 = (left, right) => left.dev === right.dev && left.ino === right.ino;
+const assertOwner = (uid, label) => {
+	if (typeof process.getuid === "function" && uid !== process.getuid()) throw new Error(`${label} must be owned by the current user`);
+};
+const assertPrivateMode = (mode, label) => {
+	if ((mode & 63) !== 0) throw new Error(`${label} must not grant group or other permissions`);
+};
+const assertPosixDurabilitySupport = () => {
+	if (process.platform !== "darwin" && process.platform !== "linux" || typeof process.getuid !== "function" || typeof constants.O_NOFOLLOW !== "number" || constants.O_NOFOLLOW === 0 || typeof constants.O_DIRECTORY !== "number" || constants.O_DIRECTORY === 0) throw new Error("Encrypted durable MCP sessions require supported POSIX owner, nofollow, directory-fsync, and advisory-lock semantics on macOS or Linux");
+};
+const acquireDirectoryLock = async (directoryPath) => {
+	const handle = await open(join(directoryPath, LOCK_FILE_NAME), constants.O_RDWR | constants.O_CREAT | constants.O_NOFOLLOW | constants.O_NONBLOCK, 384);
+	try {
+		const metadata = await handle.stat();
+		if (!metadata.isFile()) throw new Error("MCP session lock must be a regular file");
+		assertOwner(metadata.uid, "MCP session lock");
+		assertPrivateMode(metadata.mode, "MCP session lock");
+		const { tryLock } = await import("fs-native-extensions");
+		if (!tryLock(handle.fd)) throw new Error("MCP session directory is already locked by another server");
+		return handle;
+	} catch (error) {
+		await handle.close().catch(() => void 0);
+		throw error;
+	}
+};
+const canonicalAbsolutePath = async (path, label) => {
+	if (!isAbsolute(path)) throw new Error(`${label} must be an absolute path`);
+	const normalized = resolve(path);
+	const canonical = await realpath(normalized);
+	if (canonical !== normalized) throw new Error(`${label} must not contain symbolic links`);
+	return canonical;
+};
+const readHandleBounded$1 = async (handle, maximumBytes) => {
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const remaining = maximumBytes - total;
+		const chunk = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES$1, remaining + 1));
+		const { bytesRead } = await handle.read(chunk, 0, chunk.byteLength, null);
+		if (bytesRead === 0) return Buffer.concat(chunks, total);
+		total += bytesRead;
+		if (total > maximumBytes) throw new Error("Encrypted session archive exceeds the byte limit");
+		chunks.push(chunk.subarray(0, bytesRead));
+	}
+};
+const readKey = async (path) => {
+	const canonical = await canonicalAbsolutePath(path, "MCP session key file");
+	const linkedMetadata = await lstat(canonical);
+	if (!linkedMetadata.isFile() || linkedMetadata.isSymbolicLink()) throw new Error("MCP session key file must be a regular file");
+	assertOwner(linkedMetadata.uid, "MCP session key file");
+	assertPrivateMode(linkedMetadata.mode, "MCP session key file");
+	if (linkedMetadata.size !== 32) throw new Error(`MCP session key file must contain exactly 32 raw bytes`);
+	const handle = await open(canonical, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+	let keyBuffer;
+	try {
+		const openedMetadata = await handle.stat();
+		if (!openedMetadata.isFile() || !sameFile$1(linkedMetadata, openedMetadata) || openedMetadata.size !== 32) throw new Error("MCP session key file changed while it was validated");
+		keyBuffer = Buffer.alloc(33);
+		let keyLength = 0;
+		for (;;) {
+			const { bytesRead } = await handle.read(keyBuffer, keyLength, keyBuffer.byteLength - keyLength, null);
+			if (bytesRead === 0 || keyLength + bytesRead === keyBuffer.byteLength) {
+				keyLength += bytesRead;
+				break;
+			}
+			keyLength += bytesRead;
+		}
+		if (keyLength !== 32) {
+			keyBuffer.fill(0);
+			throw new Error(`MCP session key file must contain exactly 32 raw bytes`);
+		}
+		const currentMetadata = await stat(canonical);
+		if (!sameFile$1(openedMetadata, currentMetadata)) {
+			keyBuffer.fill(0);
+			throw new Error("MCP session key file changed while it was read");
+		}
+		const key = /* @__PURE__ */ new Uint8Array(32);
+		key.set(keyBuffer.subarray(0, 32));
+		keyBuffer.fill(0);
+		return key;
+	} finally {
+		keyBuffer?.fill(0);
+		await handle.close();
+	}
+};
+const archiveName = (sessionId) => `${createHash("sha256").update(sessionId, "utf8").digest("hex")}.stlasess`;
+const assertSessionId = (sessionId) => {
+	if (!SESSION_ID$1.test(sessionId)) throw new Error("MCP session ID is invalid");
+};
+var DurableSessionStore = class DurableSessionStore {
+	#closePromise;
+	#directory;
+	#faultInjector;
+	#key;
+	#lockHandle;
+	#mutationTail = Promise.resolve();
+	#state = "open";
+	constructor(directory, key, lockHandle, faultInjector) {
+		this.#directory = directory;
+		this.#key = key;
+		this.#lockHandle = lockHandle;
+		this.#faultInjector = faultInjector;
+	}
+	static async create({ keyFile, sessionDirectory, faultInjector }) {
+		assertPosixDurabilitySupport();
+		const directoryPath = await canonicalAbsolutePath(sessionDirectory, "MCP session directory");
+		const metadata = await lstat(directoryPath);
+		if (!metadata.isDirectory() || metadata.isSymbolicLink()) throw new Error("MCP session directory must be a directory");
+		assertOwner(metadata.uid, "MCP session directory");
+		assertPrivateMode(metadata.mode, "MCP session directory");
+		const key = await readKey(keyFile);
+		let lockHandle;
+		try {
+			lockHandle = await acquireDirectoryLock(directoryPath);
+			const store = new DurableSessionStore({
+				dev: metadata.dev,
+				ino: metadata.ino,
+				path: directoryPath
+			}, key, lockHandle, faultInjector);
+			await store.#validateInventory({ removeStagingFiles: true });
+			await store.#syncDirectory();
+			return store;
+		} catch (error) {
+			key.fill(0);
+			await lockHandle?.close().catch(() => void 0);
+			throw error;
+		}
+	}
+	seal(session, observedAtEpochSeconds) {
+		this.#assertOpen();
+		return session.toEncryptedArchiveAt(this.#key, observedAtEpochSeconds);
+	}
+	restore({ archive, expectedSessionId, observedAtEpochSeconds, restorer }) {
+		this.#assertOpen();
+		return restorer.restoreEncryptedRedactionSession({
+			archive,
+			expectedSessionId,
+			key: this.#key,
+			observedAtEpochSeconds
+		});
+	}
+	async close() {
+		if (this.#closePromise !== void 0) return this.#closePromise;
+		this.#state = "closing";
+		this.#closePromise = (async () => {
+			await this.#mutationTail;
+			this.#key.fill(0);
+			await this.#lockHandle.close();
+			this.#state = "closed";
+		})();
+		return this.#closePromise;
+	}
+	async load(sessionId) {
+		this.#assertOpen();
+		return this.#withMutation(() => this.#load(sessionId));
+	}
+	async #load(sessionId) {
+		assertSessionId(sessionId);
+		await this.#validateInventory({ removeStagingFiles: false });
+		const path = this.#path(sessionId);
+		let handle;
+		try {
+			handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			throw new Error("Encrypted session archive could not be opened", { cause: error });
+		}
+		try {
+			const metadata = await handle.stat();
+			if (!metadata.isFile()) throw new Error("Encrypted session archive must be a regular file");
+			assertOwner(metadata.uid, "Encrypted session archive");
+			assertPrivateMode(metadata.mode, "Encrypted session archive");
+			if (metadata.size > 16777273) throw new Error("Encrypted session archive exceeds the byte limit");
+			const bytes = await readHandleBounded$1(handle, SESSION_ARCHIVE_MAX_BYTES);
+			await this.#assertDirectory();
+			const currentMetadata = await lstat(path);
+			if (!currentMetadata.isFile() || !sameFile$1(metadata, currentMetadata)) throw new Error("Encrypted session archive changed while it was read");
+			return { bytes };
+		} finally {
+			await handle.close();
+		}
+	}
+	async save(sessionId, archive) {
+		this.#assertOpen();
+		return this.#withMutation(() => this.#save(sessionId, archive));
+	}
+	async #save(sessionId, archive) {
+		assertSessionId(sessionId);
+		if (archive.byteLength > 16777273) throw new Error("Encrypted session archive exceeds the byte limit");
+		const inventory = await this.#validateInventory({ removeStagingFiles: false });
+		await this.#assertDirectory();
+		const destination = this.#path(sessionId);
+		const temporary = `${destination}.tmp.${randomUUID()}`;
+		const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+		try {
+			const openedMetadata = await handle.stat();
+			if (!openedMetadata.isFile()) throw new Error("Encrypted session staging path is not a regular file");
+			await this.#inject(DURABLE_SESSION_FAULT_POINTS.beforeStagingWrite);
+			await handle.writeFile(archive);
+			await this.#inject(DURABLE_SESSION_FAULT_POINTS.beforeStagingFsync);
+			await handle.sync();
+			const stagedMetadata = await lstat(temporary);
+			if (!stagedMetadata.isFile() || !sameFile$1(openedMetadata, stagedMetadata)) throw new Error("Encrypted session staging file changed before publication");
+			await this.#assertDirectory();
+			const existing = await lstat(destination).catch((error) => {
+				if (error.code === "ENOENT") return;
+				throw error;
+			});
+			if (existing !== void 0 && (!existing.isFile() || existing.isSymbolicLink())) throw new Error("Encrypted session archive path is not a regular file");
+			const nextCount = inventory.archiveCount + (existing === void 0 ? 1 : 0);
+			const nextTotalBytes = inventory.totalBytes - (existing?.size ?? 0) + archive.byteLength;
+			if (nextCount > 256) throw new Error(`MCP session archives must not exceed 256`);
+			if (nextTotalBytes > 268435456) throw new Error("MCP session archives exceed the aggregate byte limit");
+			await this.#inject(DURABLE_SESSION_FAULT_POINTS.beforeRename);
+			await rename(temporary, destination);
+			await this.#assertDirectory();
+			const published = await lstat(destination);
+			if (!published.isFile() || !sameFile$1(openedMetadata, published)) throw new Error("Encrypted session archive publication was not atomic");
+			await this.#syncDirectory();
+		} finally {
+			await handle.close().catch(() => void 0);
+			await unlink(temporary).catch(() => void 0);
+		}
+	}
+	async delete(sessionId) {
+		this.#assertOpen();
+		return this.#withMutation(() => this.#delete(sessionId));
+	}
+	async #delete(sessionId) {
+		assertSessionId(sessionId);
+		await this.#assertDirectory();
+		const path = this.#path(sessionId);
+		const metadata = await lstat(path).catch((error) => {
+			if (error.code === "ENOENT") return;
+			throw error;
+		});
+		if (metadata === void 0) return;
+		if (!metadata.isFile() || metadata.isSymbolicLink()) throw new Error("Encrypted session archive path is not a regular file");
+		await unlink(path);
+		await this.#syncDirectory();
+		await this.#assertDirectory();
+	}
+	#path(sessionId) {
+		return join(this.#directory.path, archiveName(sessionId));
+	}
+	#assertOpen() {
+		if (this.#state !== "open") throw new Error("MCP durable session store is closing or closed");
+	}
+	async #withMutation(operation) {
+		const previous = this.#mutationTail;
+		let release = () => void 0;
+		const current = new Promise((resolvePromise) => {
+			release = resolvePromise;
+		});
+		this.#mutationTail = previous.then(() => current);
+		await previous;
+		try {
+			return await operation();
+		} finally {
+			release();
+		}
+	}
+	async #assertDirectory() {
+		const canonical = await realpath(this.#directory.path);
+		const metadata = await lstat(this.#directory.path);
+		if (canonical !== this.#directory.path || !metadata.isDirectory() || metadata.isSymbolicLink() || !sameFile$1(this.#directory, metadata)) throw new Error("MCP session directory changed while it was being used");
+		assertOwner(metadata.uid, "MCP session directory");
+		assertPrivateMode(metadata.mode, "MCP session directory");
+	}
+	async #syncDirectory() {
+		await this.#inject(DURABLE_SESSION_FAULT_POINTS.beforeDirectoryFsync);
+		const handle = await open(this.#directory.path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+		try {
+			const metadata = await handle.stat();
+			if (!metadata.isDirectory() || !sameFile$1(this.#directory, metadata)) throw new Error("MCP session directory changed before synchronization");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+	}
+	async #inject(point) {
+		await this.#faultInjector?.(point);
+	}
+	async #validateInventory({ removeStagingFiles }) {
+		await this.#assertDirectory();
+		const entries = await readdir(this.#directory.path, { withFileTypes: true });
+		let archiveCount = 0;
+		let totalBytes = 0;
+		for (const entry of entries) {
+			const path = join(this.#directory.path, entry.name);
+			if (entry.name === LOCK_FILE_NAME) {
+				const metadata = await lstat(path);
+				if (!metadata.isFile() || metadata.isSymbolicLink()) throw new Error("MCP session directory contains an unsafe lock path");
+				assertOwner(metadata.uid, "MCP session lock");
+				assertPrivateMode(metadata.mode, "MCP session lock");
+				continue;
+			}
+			if (STAGING_NAME.test(entry.name)) {
+				if (!removeStagingFiles) throw new Error("MCP session directory contains a partial archive");
+				const metadata = await lstat(path);
+				if (!metadata.isFile() || metadata.isSymbolicLink()) throw new Error("MCP session directory contains an unsafe staging path");
+				await unlink(path);
+				await this.#syncDirectory();
+				continue;
+			}
+			if (!ARCHIVE_NAME.test(entry.name) || !entry.isFile() || entry.isSymbolicLink()) throw new Error("MCP session directory contains an unsupported entry");
+			const metadata = await lstat(path);
+			if (!metadata.isFile() || metadata.isSymbolicLink()) throw new Error("MCP session directory contains an unsafe archive path");
+			assertOwner(metadata.uid, "Encrypted session archive");
+			assertPrivateMode(metadata.mode, "Encrypted session archive");
+			if (metadata.size > 16777273) throw new Error("Encrypted session archive exceeds the byte limit");
+			archiveCount += 1;
+			totalBytes += metadata.size;
+			if (archiveCount > 256) throw new Error(`MCP session archives must not exceed 256`);
+			if (totalBytes > 268435456) throw new Error("MCP session archives exceed the aggregate byte limit");
+		}
+		await this.#assertDirectory();
+		return {
+			archiveCount,
+			totalBytes
+		};
+	}
+};
+//#endregion
+//#region src/local.ts
+const TEXT_MAX_BYTES = 64 * 1024 * 1024;
+const EXTERNAL_DETECTION_BATCH_MAX_BYTES = 16 * 1024 * 1024;
+const EXTERNAL_DETECTION_BATCH_VERSION = 1;
+const PATH_MAX_CHARACTERS = 32768;
+const SESSION_MAX_COUNT = 256;
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u;
+const READ_CHUNK_BYTES = 64 * 1024;
+const observedAtEpochSeconds = () => {
+	const seconds = Math.floor(Date.now() / 1e3);
+	if (seconds < 0 || seconds > 4294967295) throw new Error("The current time is outside the supported session range");
+	return seconds;
+};
+const MCP_SESSION_MODES = {
+	durableEncrypted: "durable-encrypted",
+	memory: "memory"
+};
+const EXTERNAL_DETECTION_FAILURES = {
+	batchRejected: {
+		code: "EXTERNAL_DETECTION_BATCH_REJECTED",
+		message: "The external detection batch was rejected."
+	},
+	documentRejected: {
+		code: "EXTERNAL_DETECTION_DOCUMENT_REJECTED",
+		message: "The external detection document was rejected."
+	},
+	inputRejected: {
+		code: "EXTERNAL_DETECTION_INPUT_REJECTED",
+		message: "The external detection request paths were rejected."
+	},
+	operationFailed: {
+		code: "EXTERNAL_DETECTION_OPERATION_FAILED",
+		message: "The external detection operation failed safely."
+	},
+	sessionRejected: {
+		code: "EXTERNAL_DETECTION_SESSION_REJECTED",
+		message: "The external detection session was rejected."
+	}
+};
+var ExternalDetectionAuditError = class extends Error {
+	code;
+	constructor(failure) {
+		super(failure.message);
+		this.name = "ExternalDetectionAuditError";
+		this.code = failure.code;
+	}
+};
+const externalDetectionFailure = (error, failure) => error instanceof ExternalDetectionAuditError ? error : new ExternalDetectionAuditError(failure);
+const externalDetectionStep = async (failure, operation) => {
+	try {
+		return await operation();
+	} catch (error) {
+		throw externalDetectionFailure(error, failure);
+	}
+};
+const inside = (root, target) => {
+	const path = relative(root, target);
+	return path === "" || path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+};
+const readHandleBounded = async (handle, maximumBytes, label) => {
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const chunk = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES, maximumBytes - total + 1));
+		const { bytesRead } = await handle.read(chunk, 0, chunk.byteLength, null);
+		if (bytesRead === 0) return Buffer.concat(chunks, total);
+		total += bytesRead;
+		if (total > maximumBytes) throw new Error(`${label} inputs must not exceed ${maximumBytes} bytes`);
+		chunks.push(chunk.subarray(0, bytesRead));
+	}
+};
+var ScopedOutput = class {
+	parent;
+	path;
+	constructor(path, parent) {
+		this.path = path;
+		this.parent = parent;
+	}
+	async write(bytes) {
+		await safeWrite(this, bytes);
+	}
+};
+var PathScope = class PathScope {
+	#roots;
+	constructor(roots) {
+		this.#roots = roots;
+	}
+	static async create(roots) {
+		if (roots.length === 0) throw new Error("At least one --root directory is required");
+		const canonical = await Promise.all(roots.map(async (root) => {
+			if (!isAbsolute(root)) throw new Error("MCP roots must be absolute paths");
+			const path = await realpath(root);
+			if (!(await stat(path)).isDirectory()) throw new Error("Every MCP root must be a directory");
+			return path;
+		}));
+		return new PathScope([...new Set(canonical)]);
+	}
+	async readInput({ path, extension, maximumBytes, label }) {
+		if (!isAbsolute(path) || extname(path).toLowerCase() !== extension) throw new Error(`Input must be an absolute ${extension} path`);
+		const initiallyCanonical = await realpath(path);
+		if (!this.#roots.some((root) => inside(root, initiallyCanonical))) throw new Error("Input is outside the configured roots");
+		if (!(await lstat(path)).isFile()) throw new Error("Input must be a regular file");
+		const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+		try {
+			const openedMetadata = await handle.stat();
+			if (!openedMetadata.isFile()) throw new Error("Input must be a regular file");
+			const canonical = await realpath(path);
+			if (!this.#roots.some((root) => inside(root, canonical))) throw new Error("Input is outside the configured roots");
+			const currentMetadata = await stat(canonical);
+			if (currentMetadata.dev !== openedMetadata.dev || currentMetadata.ino !== openedMetadata.ino) throw new Error("Input changed while it was being validated");
+			if (openedMetadata.size > maximumBytes) throw new Error(`${label} inputs must not exceed ${maximumBytes} bytes`);
+			return {
+				bytes: await readHandleBounded(handle, maximumBytes, label),
+				path: canonical
+			};
+		} finally {
+			await handle.close();
+		}
+	}
+	async output(path, extension) {
+		if (!isAbsolute(path) || extname(path).toLowerCase() !== extension) throw new Error(`Output must be an absolute ${extension} path`);
+		const normalized = resolve(path);
+		const parent = await realpath(dirname(normalized));
+		if (!this.#roots.some((root) => inside(root, parent))) throw new Error("Output is outside the configured roots");
+		const parentMetadata = await stat(parent);
+		try {
+			await lstat(normalized);
+		} catch (error) {
+			if (error.code === "ENOENT") return new ScopedOutput(normalized, {
+				dev: parentMetadata.dev,
+				ino: parentMetadata.ino,
+				path: parent
+			});
+			throw new Error("Output availability could not be verified", { cause: error });
+		}
+		throw new Error("Output already exists; overwriting is not supported");
+	}
+};
+const nativeNodeSurface = nativeNode;
+const assertOutputParent = async ({ parent, path }) => {
+	const canonical = await realpath(dirname(path));
+	const metadata = await stat(canonical);
+	if (canonical !== parent.path || metadata.dev !== parent.dev || metadata.ino !== parent.ino) throw new Error("Output directory changed while it was being used");
+};
+const sameFile = (left, right) => left.dev === right.dev && left.ino === right.ino;
+const safeWrite = async (output, bytes) => {
+	await assertOutputParent(output);
+	const temporary = `${output.path}.stella-${randomUUID()}.tmp`;
+	let published = false;
+	let committed = false;
+	let temporaryMetadata;
+	const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 256);
+	try {
+		temporaryMetadata = await handle.stat();
+		const canonicalTemporary = await realpath(temporary);
+		const currentTemporaryMetadata = await lstat(temporary);
+		if (dirname(canonicalTemporary) !== output.parent.path || !currentTemporaryMetadata.isFile() || !sameFile(temporaryMetadata, currentTemporaryMetadata)) throw new Error("Output staging file changed while it was being used");
+		await handle.writeFile(bytes);
+		await handle.sync();
+		await assertOutputParent(output);
+		const stagedMetadata = await lstat(temporary);
+		if (!stagedMetadata.isFile() || !sameFile(temporaryMetadata, stagedMetadata)) throw new Error("Output staging file changed before publication");
+		await link(temporary, output.path);
+		published = true;
+		const publishedMetadata = await lstat(output.path);
+		if (!publishedMetadata.isFile() || !sameFile(temporaryMetadata, publishedMetadata)) throw new Error("Published output does not match the staged file");
+		await assertOutputParent(output);
+		await handle.chmod(384);
+		await handle.sync();
+		committed = true;
+	} finally {
+		if (!committed) {
+			await handle.truncate(0).catch(() => void 0);
+			await handle.sync().catch(() => void 0);
+			await handle.chmod(0).catch(() => void 0);
+		}
+		await handle.close().catch(() => void 0);
+		await unlink(temporary).catch(() => void 0);
+		if (published && !committed && temporaryMetadata !== void 0) {
+			const publishedMetadata = await lstat(output.path).catch(() => void 0);
+			if (publishedMetadata !== void 0 && sameFile(temporaryMetadata, publishedMetadata)) await unlink(output.path).catch(() => void 0);
+		}
+	}
+};
+const decodeText = (bytes) => {
+	return decodeUtf8(bytes, "Text inputs");
+};
+const decodeUtf8 = (bytes, label) => {
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch (error) {
+		throw new Error(`${label} must contain valid UTF-8`, { cause: error });
+	}
+};
+const applyTextReplacements = (text, replacements) => {
+	const parts = [];
+	let cursor = 0;
+	for (const replacement of replacements) {
+		if (!Number.isSafeInteger(replacement.start) || !Number.isSafeInteger(replacement.end) || replacement.start < cursor || replacement.end <= replacement.start || replacement.end > text.length || !isUtf16Boundary(text, replacement.start) || !isUtf16Boundary(text, replacement.end)) throw new Error("Native caller-detection plan returned invalid replacements");
+		parts.push(text.slice(cursor, replacement.start), replacement.replacement);
+		cursor = replacement.end;
+	}
+	parts.push(text.slice(cursor));
+	return parts.join("");
+};
+const isUtf16Boundary = (text, offset) => {
+	if (offset <= 0 || offset >= text.length) return true;
+	const before = text.charCodeAt(offset - 1);
+	const after = text.charCodeAt(offset);
+	return !(before >= 55296 && before <= 56319 && after >= 56320 && after <= 57343);
+};
+const assertDifferentPaths = (input, output) => {
+	if (input === output) throw new Error("Input and output paths must differ");
+};
+const textInput = z.object({
+	inputPath: z.string().min(1).max(PATH_MAX_CHARACTERS),
+	outputPath: z.string().min(1).max(PATH_MAX_CHARACTERS),
+	sessionId: z.string().regex(SESSION_ID),
+	language: z.string().min(2).max(35).optional()
+});
+const externalDetectionTextInput = textInput.extend({ detectionBatchPath: z.string().min(1).max(PATH_MAX_CHARACTERS) });
+const restoreInput = z.object({
+	inputPath: z.string().min(1).max(PATH_MAX_CHARACTERS),
+	outputPath: z.string().min(1).max(PATH_MAX_CHARACTERS),
+	sessionId: z.string().regex(SESSION_ID)
+});
+const docxRestoreInput = restoreInput.extend({ allowPartialCoverage: z.boolean().optional().default(false) });
+const docxInput = textInput.extend({ allowPartialCoverage: z.boolean().optional().default(false) });
+const pdfInput = z.object({
+	inputPath: z.string().min(1).max(PATH_MAX_CHARACTERS),
+	outputPath: z.string().min(1).max(PATH_MAX_CHARACTERS),
+	ocrLanguage: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*$/u),
+	detectionLanguage: z.string().min(2).max(35).optional(),
+	dpi: z.number().int().min(72).max(600).optional().default(300),
+	timeoutMs: z.number().int().min(100).max(3e5).optional().default(12e4),
+	fillRgb: z.tuple([
+		z.number().int().min(0).max(255),
+		z.number().int().min(0).max(255),
+		z.number().int().min(0).max(255)
+	]).optional().default([
+		0,
+		0,
+		0
+	])
+});
+var LocalAnonymizeService = class {
+	#activeOperations = 0;
+	#closePromise;
+	#operationsDrained;
+	#scope;
+	#pdfOperationTail = Promise.resolve();
+	#sessionInitializations = /* @__PURE__ */ new Set();
+	#sessions = /* @__PURE__ */ new Map();
+	#state = "open";
+	#durableSessions;
+	#faults;
+	#pdfProvider;
+	constructor(scope, options = {}) {
+		if (options instanceof DurableSessionStore) throw new TypeError("LocalAnonymizeService requires { durableSessions } as its second argument");
+		const { durableSessions, faults = {}, pdfProvider = {} } = options;
+		this.#scope = scope;
+		this.#durableSessions = durableSessions;
+		this.#faults = faults;
+		this.#pdfProvider = pdfProvider;
+	}
+	get sessionMode() {
+		return this.#durableSessions === void 0 ? MCP_SESSION_MODES.memory : MCP_SESSION_MODES.durableEncrypted;
+	}
+	async close() {
+		if (this.#closePromise !== void 0) return this.#closePromise;
+		this.#state = "closing";
+		this.#closePromise = (async () => {
+			if (this.#activeOperations > 0) await new Promise((resolvePromise) => {
+				this.#operationsDrained = resolvePromise;
+			});
+			this.#sessions.clear();
+			await this.#durableSessions?.close();
+			this.#state = "closed";
+		})();
+		return this.#closePromise;
+	}
+	async #runOperation(operation) {
+		if (this.#state !== "open") throw new Error("MCP anonymize service is closing or closed");
+		this.#activeOperations += 1;
+		try {
+			return await operation();
+		} finally {
+			this.#activeOperations -= 1;
+			if (this.#activeOperations === 0) {
+				this.#operationsDrained?.();
+				this.#operationsDrained = void 0;
+			}
+		}
+	}
+	async #session(sessionId, language) {
+		if (this.#durableSessions !== void 0 && language !== void 0) throw new Error("Durable sessions use the full all-language pipeline; omit language");
+		const existing = this.#sessions.get(sessionId);
+		if (existing !== void 0) {
+			if (language !== void 0 && existing.language !== language) throw new Error("A session cannot change language");
+			if (existing.status === "initializing") throw new Error("The requested session is still initializing");
+			if (existing.status === "busy") throw new Error("The requested session is handling another operation");
+			const checkpoint = existing.session.toPlaintextJson();
+			existing.status = "busy";
+			return {
+				entry: existing,
+				sessionId,
+				rollback: {
+					type: "restore",
+					checkpoint
+				}
+			};
+		}
+		if (this.#sessionInitializations.has(sessionId)) throw new Error("The requested session is still initializing");
+		this.#sessionInitializations.add(sessionId);
+		try {
+			if (this.#sessions.size >= SESSION_MAX_COUNT) throw new Error(`MCP sessions must not exceed ${SESSION_MAX_COUNT}`);
+			const pipeline = nativeNodeSurface.getDefaultNativePipeline(language === void 0 ? {} : { language });
+			const durableSessions = this.#durableSessions;
+			const stored = durableSessions === void 0 ? void 0 : await durableSessions.load(sessionId);
+			let session;
+			if (stored === void 0) session = pipeline.createRedactionSession(sessionId);
+			else {
+				if (durableSessions === void 0) throw new Error("Durable session storage is unavailable");
+				try {
+					session = durableSessions.restore({
+						archive: stored.bytes,
+						expectedSessionId: sessionId,
+						observedAtEpochSeconds: observedAtEpochSeconds(),
+						restorer: pipeline
+					});
+				} catch (error) {
+					throw new Error("The requested durable session is unavailable", { cause: error });
+				}
+			}
+			const entry = {
+				language,
+				session,
+				restoreSession: (plaintextJson) => pipeline.restoreRedactionSession(plaintextJson),
+				status: "initializing"
+			};
+			this.#sessions.set(sessionId, entry);
+			return {
+				entry,
+				sessionId,
+				rollback: stored === void 0 ? { type: "delete" } : {
+					type: "restore",
+					checkpoint: session.toPlaintextJson()
+				}
+			};
+		} finally {
+			this.#sessionInitializations.delete(sessionId);
+		}
+	}
+	#commitSession({ entry }) {
+		entry.status = "ready";
+	}
+	async #rollbackSession({ entry, rollback, sessionId }) {
+		if (this.#sessions.get(sessionId) !== entry) return;
+		if (rollback.type === "delete") {
+			this.#sessions.delete(sessionId);
+			await this.#durableSessions?.delete(sessionId).catch(() => void 0);
+			return;
+		}
+		if (rollback.type === "release") {
+			entry.status = "ready";
+			return;
+		}
+		try {
+			entry.session = entry.restoreSession(rollback.checkpoint);
+			entry.status = "ready";
+			await this.#persistSession(sessionId, entry.session);
+		} catch {
+			this.#sessions.delete(sessionId);
+		}
+	}
+	async #readSession(sessionId) {
+		let entry = this.#sessions.get(sessionId);
+		if (entry === void 0 && this.#durableSessions !== void 0) {
+			if (this.#sessionInitializations.has(sessionId)) throw new Error("The requested session is still initializing");
+			this.#sessionInitializations.add(sessionId);
+			try {
+				const pipeline = nativeNodeSurface.getDefaultNativePipeline({});
+				const stored = await this.#durableSessions.load(sessionId);
+				if (stored !== void 0) try {
+					entry = {
+						language: void 0,
+						session: this.#durableSessions.restore({
+							archive: stored.bytes,
+							expectedSessionId: sessionId,
+							observedAtEpochSeconds: observedAtEpochSeconds(),
+							restorer: pipeline
+						}),
+						restoreSession: (plaintextJson) => pipeline.restoreRedactionSession(plaintextJson),
+						status: "ready"
+					};
+					this.#sessions.set(sessionId, entry);
+				} catch (error) {
+					throw new Error("The requested durable session is unavailable", { cause: error });
+				}
+			} finally {
+				this.#sessionInitializations.delete(sessionId);
+			}
+		}
+		if (entry === void 0) throw new Error("The requested session is unavailable");
+		if (entry.status !== "ready") throw new Error("The requested in-memory session is unavailable");
+		entry.status = "busy";
+		return {
+			entry,
+			sessionId,
+			rollback: { type: "release" }
+		};
+	}
+	async #persistSession(sessionId, session) {
+		if (this.#durableSessions === void 0) return;
+		const archive = this.#durableSessions.seal(session, observedAtEpochSeconds());
+		await this.#durableSessions.save(sessionId, archive);
+	}
+	async anonymizeText(input) {
+		return this.#runOperation(() => this.#anonymizeText(input));
+	}
+	async anonymizePdf(input) {
+		return this.#runOperation(() => this.#serializePdfOperation(() => this.#anonymizePdf(input)));
+	}
+	async #serializePdfOperation(operation) {
+		const previous = this.#pdfOperationTail;
+		let release = () => void 0;
+		this.#pdfOperationTail = new Promise((resolvePromise) => {
+			release = resolvePromise;
+		});
+		await previous;
+		try {
+			return await operation();
+		} finally {
+			release();
+		}
+	}
+	async #anonymizePdf(input) {
+		const source = await this.#scope.readInput({
+			path: input.inputPath,
+			extension: ".pdf",
+			maximumBytes: PDF_DOCUMENT_MAX_BYTES,
+			label: "PDF"
+		});
+		const destination = await this.#scope.output(input.outputPath, ".pdf");
+		assertDifferentPaths(source.path, destination.path);
+		const pipeline = nativeNodeSurface.getDefaultNativePipeline(input.detectionLanguage === void 0 ? {} : { language: input.detectionLanguage });
+		const observed = await renderPdfWithPopplerTesseract({
+			document: source.bytes,
+			ocrLanguage: input.ocrLanguage,
+			dpi: input.dpi,
+			timeoutMs: input.timeoutMs,
+			...this.#pdfProvider
+		});
+		const anonymized = anonymizePdfRaster({
+			document: source.bytes,
+			pipeline,
+			provider: observed.provider,
+			pages: observed.pages,
+			fillRgb: input.fillRgb
+		});
+		if (anonymized.certificate.structurePixelRewriteVerified !== true || anonymized.certificate.piiCleanGuaranteed !== false) throw new Error("PDF raster verification did not satisfy MCP policy");
+		await this.#faults.beforeOutputPublish?.();
+		await destination.write(anonymized.document);
+		return {
+			operation: "anonymize",
+			format: "pdf",
+			outputCreated: true,
+			pageCount: anonymized.certificate.pageCount,
+			entityCount: anonymized.certificate.detectionCount,
+			mappedRegionCount: anonymized.certificate.mappedRegionCount,
+			structurePixelRewriteVerified: true,
+			piiCleanGuaranteed: false
+		};
+	}
+	async #anonymizeText(input) {
+		const source = await this.#scope.readInput({
+			path: input.inputPath,
+			extension: ".txt",
+			maximumBytes: TEXT_MAX_BYTES,
+			label: "Text"
+		});
+		const destination = await this.#scope.output(input.outputPath, ".txt");
+		assertDifferentPaths(source.path, destination.path);
+		const text = decodeText(source.bytes);
+		const lease = await this.#session(input.sessionId, input.language);
+		try {
+			const result = lease.entry.session.redact_text(text);
+			await this.#persistSession(input.sessionId, lease.entry.session);
+			await this.#faults.beforeOutputPublish?.();
+			await destination.write(result.redaction.redactedText);
+			this.#commitSession(lease);
+			return {
+				operation: "anonymize",
+				format: "text",
+				outputCreated: true,
+				sessionId: input.sessionId,
+				entityCount: result.redaction.entityCount
+			};
+		} catch (error) {
+			await this.#rollbackSession(lease);
+			throw error;
+		}
+	}
+	async restoreText(input) {
+		return this.#runOperation(() => this.#restoreText(input));
+	}
+	async anonymizeTextWithExternalDetections(input) {
+		try {
+			return await this.#runOperation(() => this.#anonymizeTextWithExternalDetections(input));
+		} catch (error) {
+			throw externalDetectionFailure(error, EXTERNAL_DETECTION_FAILURES.operationFailed);
+		}
+	}
+	async #anonymizeTextWithExternalDetections(input) {
+		const { batch, destination, source } = await externalDetectionStep(EXTERNAL_DETECTION_FAILURES.inputRejected, async () => {
+			const scopedSource = await this.#scope.readInput({
+				path: input.inputPath,
+				extension: ".txt",
+				maximumBytes: TEXT_MAX_BYTES,
+				label: "Text"
+			});
+			const scopedBatch = await this.#scope.readInput({
+				path: input.detectionBatchPath,
+				extension: ".json",
+				maximumBytes: EXTERNAL_DETECTION_BATCH_MAX_BYTES,
+				label: "External detection batch"
+			});
+			const scopedDestination = await this.#scope.output(input.outputPath, ".txt");
+			assertDifferentPaths(scopedSource.path, scopedDestination.path);
+			assertDifferentPaths(scopedBatch.path, scopedDestination.path);
+			assertDifferentPaths(scopedSource.path, scopedBatch.path);
+			return {
+				batch: scopedBatch,
+				destination: scopedDestination,
+				source: scopedSource
+			};
+		});
+		const text = await externalDetectionStep(EXTERNAL_DETECTION_FAILURES.documentRejected, () => decodeText(source.bytes));
+		const detections = await externalDetectionStep(EXTERNAL_DETECTION_FAILURES.batchRejected, () => nativeNodeSurface.convert_external_detection_batch(source.bytes, decodeUtf8(batch.bytes, "External detection batches")));
+		const lease = await externalDetectionStep(EXTERNAL_DETECTION_FAILURES.sessionRejected, () => this.#session(input.sessionId, input.language));
+		try {
+			const plan = lease.entry.session.planTextBatchWithCallerDetections({ inputs: [{
+				fullText: text,
+				detections
+			}] });
+			const block = plan.blocks.at(0);
+			if (plan.blocks.length !== 1 || block === void 0) throw new Error("Native caller-detection plan did not match the text input");
+			const redactedText = applyTextReplacements(text, block.replacements);
+			plan.commit();
+			await this.#persistSession(input.sessionId, lease.entry.session);
+			await this.#faults.beforeOutputPublish?.();
+			await destination.write(redactedText);
+			this.#commitSession(lease);
+			return {
+				operation: "anonymize",
+				format: "text",
+				outputCreated: true,
+				sessionId: input.sessionId,
+				entityCount: block.entityCount,
+				externalDetectionBatchStatus: "accepted",
+				externalDetectionCount: detections.length,
+				retainedExternalDetectionCount: block.callerEntityCount
+			};
+		} catch (error) {
+			await this.#rollbackSession(lease);
+			throw externalDetectionFailure(error, EXTERNAL_DETECTION_FAILURES.operationFailed);
+		}
+	}
+	async #restoreText(input) {
+		const source = await this.#scope.readInput({
+			path: input.inputPath,
+			extension: ".txt",
+			maximumBytes: TEXT_MAX_BYTES,
+			label: "Text"
+		});
+		const destination = await this.#scope.output(input.outputPath, ".txt");
+		assertDifferentPaths(source.path, destination.path);
+		const text = decodeText(source.bytes);
+		const lease = await this.#readSession(input.sessionId);
+		try {
+			const restored = lease.entry.session.restoreText(text);
+			await destination.write(restored);
+			this.#commitSession(lease);
+			return {
+				operation: "restore",
+				format: "text",
+				outputCreated: true,
+				sessionId: input.sessionId
+			};
+		} catch (error) {
+			await this.#rollbackSession(lease);
+			throw error;
+		}
+	}
+	async anonymizeDocx(input) {
+		return this.#runOperation(() => this.#anonymizeDocx(input));
+	}
+	async #anonymizeDocx(input) {
+		const source = await this.#scope.readInput({
+			path: input.inputPath,
+			extension: ".docx",
+			maximumBytes: DOCX_ARCHIVE_MAX_BYTES,
+			label: "DOCX"
+		});
+		const destination = await this.#scope.output(input.outputPath, ".docx");
+		assertDifferentPaths(source.path, destination.path);
+		const lease = await this.#session(input.sessionId, input.language);
+		try {
+			const result = anonymizeDocx({
+				document: source.bytes,
+				session: lease.entry.session,
+				expectedSessionId: input.sessionId,
+				policy: { coverage: { mode: input.allowPartialCoverage ? DOCX_COVERAGE_MODES.allowPartial : DOCX_COVERAGE_MODES.requireFull } }
+			});
+			await this.#persistSession(input.sessionId, lease.entry.session);
+			await this.#faults.beforeOutputPublish?.();
+			await destination.write(result.document);
+			this.#commitSession(lease);
+			return {
+				operation: "anonymize",
+				format: "docx",
+				outputCreated: true,
+				sessionId: input.sessionId,
+				entityCount: result.summary.entityCount,
+				blockCount: result.summary.blockCount,
+				rewrittenBlockCount: result.summary.rewrittenBlockCount,
+				coverageStatus: result.summary.coverage.status
+			};
+		} catch (error) {
+			await this.#rollbackSession(lease);
+			throw error;
+		}
+	}
+	async restoreDocx(input) {
+		return this.#runOperation(() => this.#restoreDocx(input));
+	}
+	async #restoreDocx(input) {
+		const source = await this.#scope.readInput({
+			path: input.inputPath,
+			extension: ".docx",
+			maximumBytes: DOCX_ARCHIVE_MAX_BYTES,
+			label: "DOCX"
+		});
+		const destination = await this.#scope.output(input.outputPath, ".docx");
+		assertDifferentPaths(source.path, destination.path);
+		const lease = await this.#readSession(input.sessionId);
+		try {
+			const result = restoreDocxText({
+				document: source.bytes,
+				session: lease.entry.session,
+				expectedSessionId: input.sessionId
+			});
+			if (result.coverage.status === "partial" && !input.allowPartialCoverage) throw new Error("DOCX restoration has partial coverage; set allowPartialCoverage to publish it");
+			await destination.write(result.document);
+			this.#commitSession(lease);
+			return {
+				operation: "restore",
+				format: "docx",
+				outputCreated: true,
+				sessionId: input.sessionId,
+				rewrittenBlockCount: result.restoredBlockCount,
+				restoredPlaceholderCount: result.restoredPlaceholderCount,
+				coverageStatus: result.coverage.status
+			};
+		} catch (error) {
+			await this.#rollbackSession(lease);
+			throw error;
+		}
+	}
+	async inspectDocx(inputPath) {
+		return this.#runOperation(() => this.#inspectDocx(inputPath));
+	}
+	async #inspectDocx(inputPath) {
+		const extraction = extractDocxText((await this.#scope.readInput({
+			path: inputPath,
+			extension: ".docx",
+			maximumBytes: DOCX_ARCHIVE_MAX_BYTES,
+			label: "DOCX"
+		})).bytes);
+		const unsupported = extraction.coverage.parts.some((part) => part.status === "unsupported");
+		const structuralGap = extraction.coverage.hyperlinkTextSegmentCount > 0 || extraction.coverage.revisionTextSegmentCount > 0 || extraction.coverage.unsupportedAlternateContentCount > 0 || extraction.coverage.unsupportedFieldInstructionCount > 0 || extraction.coverage.unsupportedSymbolCount > 0;
+		return {
+			operation: "inspect",
+			format: "docx",
+			outputCreated: false,
+			blockCount: extraction.blocks.length,
+			coverageStatus: unsupported || structuralGap ? "partial" : "full"
+		};
+	}
+};
+const result = (value) => ({
+	content: [{
+		type: "text",
+		text: JSON.stringify(value)
+	}],
+	structuredContent: { ...value }
+});
+const MCP_TOOL_NAMES = [
+	"anonymize_docx_file",
+	"anonymize_pdf_file",
+	"anonymize_text_file",
+	"anonymize_text_file_with_external_detections",
+	"capabilities",
+	"inspect_docx_file",
+	"restore_docx_file",
+	"restore_text_file"
+];
+const capabilitiesResult = (service) => {
+	const value = {
+		capabilityManifest: CAPABILITY_MANIFEST,
+		runtimeVersion: nativeNodeSurface.native_package_version(),
+		mcp: {
+			externalDetectionBatch: {
+				ingestion: "path-only",
+				version: EXTERNAL_DETECTION_BATCH_VERSION
+			},
+			formats: [
+				"docx",
+				"pdf",
+				"text"
+			],
+			sessionMode: service.sessionMode,
+			tools: MCP_TOOL_NAMES,
+			transport: "stdio"
+		}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(value)
+		}],
+		structuredContent: value
+	};
+};
+const externalDetectionErrorResult = (error) => {
+	const failure = externalDetectionFailure(error, EXTERNAL_DETECTION_FAILURES.operationFailed);
+	const value = {
+		errorCode: failure.code,
+		message: failure.message
+	};
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: JSON.stringify(value)
+		}],
+		structuredContent: value
+	};
+};
+const createAnonymizeMcpServer = (service) => {
+	const server = new McpServer({
+		name: "stella-anonymize-local",
+		version: nativeNodeSurface.native_package_version()
+	}, { instructions: "All tools accept local paths only. Never request or return document contents or session mappings. Outputs must be new explicit paths inside configured roots." });
+	server.registerTool("capabilities", {
+		description: "Return the public runtime capability manifest and MCP surface metadata.",
+		inputSchema: z.object({}),
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true
+		}
+	}, async () => capabilitiesResult(service));
+	server.registerTool("anonymize_text_file", {
+		description: "Anonymize a local UTF-8 text file into a new local file.",
+		inputSchema: textInput,
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: false
+		}
+	}, async (input) => result(await service.anonymizeText(input)));
+	server.registerTool("restore_text_file", {
+		description: "Restore a text file using the configured session store.",
+		inputSchema: restoreInput,
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: false
+		}
+	}, async (input) => result(await service.restoreText(input)));
+	server.registerTool("anonymize_text_file_with_external_detections", {
+		description: "Anonymize a local UTF-8 text file with a provider-neutral ExternalDetectionBatch v1 JSON sidecar into a new local file.",
+		inputSchema: externalDetectionTextInput,
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: false
+		}
+	}, async (input) => {
+		try {
+			return result(await service.anonymizeTextWithExternalDetections(input));
+		} catch (error) {
+			return externalDetectionErrorResult(error);
+		}
+	});
+	server.registerTool("anonymize_docx_file", {
+		description: "Structure-preservingly anonymize a local DOCX into a new local DOCX.",
+		inputSchema: docxInput,
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: false
+		}
+	}, async (input) => result(await service.anonymizeDocx(input)));
+	server.registerTool("anonymize_pdf_file", {
+		description: "Destructively raster-anonymize a local PDF into a fresh image-only PDF. Returns aggregate verification only; it does not claim perfect OCR or detector recall.",
+		inputSchema: pdfInput,
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: false
+		}
+	}, async (input) => result(await service.anonymizePdf(input)));
+	server.registerTool("restore_docx_file", {
+		description: "Restore a DOCX using the configured session store.",
+		inputSchema: docxRestoreInput,
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: false
+		}
+	}, async (input) => result(await service.restoreDocx(input)));
+	server.registerTool("inspect_docx_file", {
+		description: "Return only aggregate DOCX coverage and block counts; never document text.",
+		inputSchema: z.object({ inputPath: z.string().min(1).max(PATH_MAX_CHARACTERS) }),
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true
+		}
+	}, async ({ inputPath }) => result(await service.inspectDocx(inputPath)));
+	return server;
+};
+//#endregion
+export { DURABLE_SESSION_FAULT_POINTS as a, SESSION_ARCHIVE_MAX_BYTES as c, createAnonymizeMcpServer as i, SESSION_ARCHIVE_MAX_COUNT as l, MCP_SESSION_MODES as n, DurableSessionStore as o, PathScope as r, SESSION_ARCHIVE_KEY_BYTES as s, LocalAnonymizeService as t, SESSION_ARCHIVE_TOTAL_MAX_BYTES as u };
+
+//# sourceMappingURL=local.mjs.map