@ggalmazor/decoy 0.0.0-stage → 1.1.0

package/dist-cli/decoy.mjs

@@ -0,0 +1,1790 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command, InvalidArgumentError } from "commander";
+import { GlobalFonts, ImageData as ImageData$1, createCanvas, loadImage } from "@napi-rs/canvas";
+import { readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/core/rng.ts
+function mulberry32(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = a;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+function lcg(seed) {
+	let s = seed >>> 0;
+	return () => {
+		s = s * 1664525 + 1013904223 >>> 0;
+		return s / 4294967296;
+	};
+}
+function hashString(text, seed = 7) {
+	let h = seed >>> 0;
+	for (let i = 0; i < text.length; i++) h = Math.imul(h, 31) + text.charCodeAt(i) >>> 0;
+	return h;
+}
+function randomSeed() {
+	if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+		const buf = /* @__PURE__ */ new Uint32Array(1);
+		crypto.getRandomValues(buf);
+		return buf[0];
+	}
+	return Math.floor(Math.random() * 4294967296) >>> 0;
+}
+function shuffle(rng, items) {
+	const out = items.slice();
+	for (let i = out.length - 1; i > 0; i--) {
+		const j = Math.floor(rng() * (i + 1));
+		[out[i], out[j]] = [out[j], out[i]];
+	}
+	return out;
+}
+//#endregion
+//#region src/core/grawlix.ts
+var PROFANE = [
+	"fucking",
+	"fuck",
+	"shithead",
+	"dipshit",
+	"shit",
+	"piss",
+	"bugger",
+	"bollocks",
+	"sod",
+	"fu"
+];
+var SYMBOLS = [
+	"@",
+	"#",
+	"$",
+	"%",
+	"&",
+	"*",
+	"!"
+];
+var VOWELS = /* @__PURE__ */ new Set([
+	"a",
+	"e",
+	"i",
+	"o",
+	"u"
+]);
+var pattern = new RegExp(`\\b(${PROFANE.join("|")})\\b`, "gi");
+function grawlixWord(word, rng) {
+	const letters = word.split("");
+	let masked = 0;
+	for (let i = 1; i < letters.length; i++) if (VOWELS.has(letters[i].toLowerCase())) {
+		letters[i] = SYMBOLS[Math.floor(rng() * SYMBOLS.length)];
+		masked++;
+	}
+	if (masked === 0 && letters.length > 1) letters[1] = SYMBOLS[Math.floor(rng() * SYMBOLS.length)];
+	return letters.join("");
+}
+function grawlix(text) {
+	const rng = mulberry32(hashString(text, 11));
+	return text.replace(pattern, (word) => grawlixWord(word, rng));
+}
+//#endregion
+//#region src/core/color.ts
+var INK_FALLBACK = [
+	23,
+	20,
+	15
+];
+var PAPER_FALLBACK = [
+	246,
+	241,
+	230
+];
+function parseHex(value, fallback) {
+	const m = /^#?([0-9a-f]{6})$/i.exec(String(value ?? "").trim());
+	if (!m) return fallback;
+	const v = parseInt(m[1], 16);
+	return [
+		v >> 16 & 255,
+		v >> 8 & 255,
+		v & 255
+	];
+}
+function toHex(rgb) {
+	return "#" + rgb.map((c) => Math.max(0, Math.min(255, Math.round(c))).toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+function luma(r, g, b) {
+	return .2126 * r + .7152 * g + .0722 * b;
+}
+function lerpColor(from, to, t) {
+	return [
+		Math.round(from[0] + (to[0] - from[0]) * t),
+		Math.round(from[1] + (to[1] - from[1]) * t),
+		Math.round(from[2] + (to[2] - from[2]) * t)
+	];
+}
+//#endregion
+//#region src/core/mosaic.ts
+var MAX_DARKNESS = .9;
+var JITTER = .06;
+function mosaicGrid(w, h, cell) {
+	return {
+		cols: Math.max(1, Math.round(w / cell)),
+		rows: Math.max(1, Math.round(h / cell))
+	};
+}
+function mosaicSeed(text) {
+	return hashString(text, 7);
+}
+function coverageFromRgba(rgba, w, h) {
+	const out = new Float32Array(w * h);
+	for (let i = 0; i < w * h; i++) out[i] = 1 - rgba[i * 4] / 255;
+	return out;
+}
+function blockDarkness(coverage, w, h, cols, rows) {
+	const dark = new Float64Array(cols * rows);
+	for (let y = 0; y < h; y++) {
+		const r = Math.min(rows - 1, Math.floor(y * rows / h));
+		for (let x = 0; x < w; x++) {
+			const c = Math.min(cols - 1, Math.floor(x * cols / w));
+			dark[r * cols + c] += coverage[y * w + x];
+		}
+	}
+	const area = w / cols * (h / rows);
+	for (let k = 0; k < dark.length; k++) dark[k] = dark[k] / area;
+	return dark;
+}
+function mosaicCells(darkness, ink, paper, seed) {
+	const rnd = lcg(seed);
+	let max = 0;
+	for (let k = 0; k < darkness.length; k++) if (darkness[k] > max) max = darkness[k];
+	const cells = new Uint8ClampedArray(darkness.length * 3);
+	for (let k = 0; k < darkness.length; k++) {
+		let t = max > 0 ? Math.min(1, darkness[k] / max * MAX_DARKNESS) : 0;
+		t = Math.max(0, Math.min(1, t + (rnd() - .5) * JITTER));
+		const [r, g, b] = lerpColor(paper, ink, t);
+		cells[k * 3] = r;
+		cells[k * 3 + 1] = g;
+		cells[k * 3 + 2] = b;
+	}
+	return cells;
+}
+function rasterizeCells(cells, cols, rows, w, h) {
+	const out = new Uint8ClampedArray(w * h * 4);
+	for (let r = 0; r < rows; r++) {
+		const y0 = Math.round(r * h / rows);
+		const y1 = r === rows - 1 ? h : Math.round((r + 1) * h / rows);
+		for (let c = 0; c < cols; c++) {
+			const x0 = Math.round(c * w / cols);
+			const x1 = c === cols - 1 ? w : Math.round((c + 1) * w / cols);
+			const k = (r * cols + c) * 3;
+			const red = cells[k];
+			const green = cells[k + 1];
+			const blue = cells[k + 2];
+			for (let y = y0; y < y1; y++) {
+				let i = (y * w + x0) * 4;
+				for (let x = x0; x < x1; x++) {
+					out[i] = red;
+					out[i + 1] = green;
+					out[i + 2] = blue;
+					out[i + 3] = 255;
+					i += 4;
+				}
+			}
+		}
+	}
+	return out;
+}
+function mosaicFromCoverage(coverage, params) {
+	const { w, h, cell, ink, paper, seed } = params;
+	const { cols, rows } = mosaicGrid(w, h, cell);
+	return rasterizeCells(mosaicCells(blockDarkness(coverage, w, h, cols, rows), ink, paper, seed), cols, rows, w, h);
+}
+//#endregion
+//#region src/core/phrases.ts
+var MOODS = [
+	"rude",
+	"smug",
+	"corporate",
+	"wholesome"
+];
+var DEFAULT_MOOD = "smug";
+var p = (text) => ({
+	text,
+	profane: true
+});
+var c = (text) => ({
+	text,
+	profane: false
+});
+var s = (text, profane = false) => profane ? {
+	text,
+	profane
+} : { text };
+var DATA = {
+	rude: {
+		fixed: [
+			p("fuck off"),
+			p("fuck right off"),
+			p("kindly fuck off"),
+			p("piss off, nerd"),
+			p("sod off"),
+			p("bugger off"),
+			p("nice try, dipshit"),
+			p("fuck off and enhance that"),
+			p("absolutely fucking not"),
+			p("not a chance, shithead"),
+			p("eat shit, snoop"),
+			p("go fuck a cactus"),
+			p("bollocks to you"),
+			p("piss off and zoom out"),
+			c("none of your business"),
+			c("mind your own business"),
+			c("get your own password"),
+			c("go away"),
+			c("absolutely not, mate"),
+			c("who asked?"),
+			c("back off, creep"),
+			c("get a life"),
+			c("stop squinting"),
+			c("zoom out, loser"),
+			c("not today, buddy"),
+			c("keep dreaming"),
+			c("how about no"),
+			c("take a hike"),
+			c("get lost"),
+			c("bite me"),
+			c("nosy little gremlin"),
+			c("eat glass, snoop"),
+			c("nope, nosy"),
+			c("go bother someone else"),
+			c("cry about it"),
+			c("you wish, creep"),
+			c("nothing here for you, weirdo"),
+			c("stop it, get some help"),
+			c("not yours"),
+			c("buzz off"),
+			c("shove off"),
+			c("do one, pal"),
+			c("no. go away."),
+			p("sod it"),
+			p("piss off")
+		],
+		templates: [{
+			pattern: "{off} off, {target}",
+			slots: {
+				off: [
+					s("fuck", true),
+					s("piss", true),
+					s("sod", true),
+					s("bugger", true),
+					s("back"),
+					s("buzz"),
+					s("shove")
+				],
+				target: [
+					s("nerd"),
+					s("creep"),
+					s("buddy"),
+					s("pal"),
+					s("snoop"),
+					s("detective"),
+					s("hacker"),
+					s("weirdo")
+				]
+			}
+		}]
+	},
+	smug: {
+		fixed: [
+			c("you thought this was a password?"),
+			c("nice try, enhance harder"),
+			c("enhance harder, detective"),
+			c("wow, you really zoomed in"),
+			c("nothing to see here, nerd"),
+			c("lol no"),
+			c("imagine trying this hard"),
+			c("you've been decoyed"),
+			c("this is not the password"),
+			c("still not the password"),
+			c("keep squinting"),
+			c("nope, try again"),
+			c("did you really think that'd work?"),
+			c("the real one is in my head"),
+			c("congratulations, you found nothing"),
+			c("10/10 effort, 0/10 result"),
+			c("zoom and enhance... nope"),
+			c("this took you how long?"),
+			c("plot twist: it's not here"),
+			c("your depixelizer is proud of you"),
+			c("adorable attempt"),
+			c("imagine trying this hard, lol"),
+			c("so much effort, so little reward"),
+			c("the pixels were never the point"),
+			c("decoded: a waste of your time"),
+			c("you un-blurred a joke"),
+			c("next time try asking nicely"),
+			c("that was the decoy, genius"),
+			c("close, but entirely wrong"),
+			c("you're reading a decoy right now"),
+			c("great tool, wrong target"),
+			c("a+ for effort, f for outcome"),
+			c("hope the enhance was worth it"),
+			c("all that compute, for this"),
+			c("nice try"),
+			c("lol nope"),
+			c("try again"),
+			c("not today"),
+			c("no chance"),
+			c("cute try"),
+			c("nope, nerd"),
+			c("so close"),
+			c("good luck"),
+			c("keep going"),
+			c("enhance this")
+		],
+		templates: [{
+			pattern: "{opener}, {target}",
+			slots: {
+				opener: [
+					s("nice try"),
+					s("good effort"),
+					s("so close"),
+					s("bless your heart"),
+					s("adorable attempt"),
+					s("almost")
+				],
+				target: [
+					s("detective"),
+					s("nerd"),
+					s("sherlock"),
+					s("genius"),
+					s("buddy"),
+					s("champ"),
+					s("inspector")
+				]
+			}
+		}]
+	},
+	corporate: {
+		fixed: [
+			c("per my last email: no"),
+			c("let's take this offline"),
+			c("circling back: no"),
+			c("this is above your pay grade"),
+			c("please see attached nothing"),
+			c("as previously discussed, no"),
+			c("let's park this indefinitely"),
+			c("not a priority this quarter"),
+			c("request denied by legal"),
+			c("out of office, forever"),
+			c("synergy not found"),
+			c("we'll circle back never"),
+			c("this has been escalated to nobody"),
+			c("thanks for your interest. no."),
+			c("ticket closed: won’t fix"),
+			c("HR has been notified"),
+			c("noted, and ignored"),
+			c("per policy, no"),
+			c("not in scope"),
+			c("kindly revert with nothing"),
+			c("moving forward, no"),
+			c("pending approval until the heat death"),
+			c("access denied, see your manager"),
+			c("this meeting could have been a no"),
+			c("aligned on: nothing for you"),
+			c("redacted per compliance"),
+			c("let me loop in nobody"),
+			c("low priority, high nope"),
+			c("we value your curiosity. no."),
+			c("action item: stop"),
+			c("hard pass"),
+			c("declined"),
+			c("noted. no."),
+			c("no budget"),
+			c("see policy"),
+			c("per policy"),
+			c("out of scope"),
+			c("n/a"),
+			c("parked"),
+			c("escalated")
+		],
+		templates: [{
+			pattern: "{opener}: {verdict}",
+			slots: {
+				opener: [
+					s("per my last email"),
+					s("as discussed"),
+					s("circling back"),
+					s("just flagging"),
+					s("quick sync"),
+					s("to close the loop"),
+					s("friendly reminder")
+				],
+				verdict: [
+					s("no"),
+					s("still no"),
+					s("hard pass"),
+					s("won't fix"),
+					s("not happening"),
+					s("declined")
+				]
+			}
+		}]
+	},
+	wholesome: {
+		fixed: [
+			c("go drink some water"),
+			c("you're doing great, sweetie"),
+			c("have you eaten today?"),
+			c("call your mother"),
+			c("take a deep breath"),
+			c("go touch some grass"),
+			c("you deserve a nap"),
+			c("stretch your back"),
+			c("be kind to yourself"),
+			c("go outside, it's sunny"),
+			c("pet a dog today"),
+			c("hydrate, then investigate"),
+			c("you are enough"),
+			c("posture check"),
+			c("go to bed, it's late"),
+			c("make yourself a tea"),
+			c("drink water, not secrets"),
+			c("text a friend back"),
+			c("unclench your jaw"),
+			c("blink. you forgot to blink."),
+			c("nothing here, but you look nice"),
+			c("proud of you for trying"),
+			c("rest your eyes for a bit"),
+			c("eat a vegetable today"),
+			c("you did your best, champ"),
+			c("go for a little walk"),
+			c("somebody is glad you exist"),
+			c("a snack would help right now"),
+			c("drink water"),
+			c("nap time"),
+			c("breathe"),
+			c("you got this"),
+			c("eat a snack"),
+			c("stretch"),
+			c("go outside"),
+			c("be gentle"),
+			c("rest up"),
+			c("you're loved")
+		],
+		templates: [{
+			pattern: "{advice}, {endearment}",
+			slots: {
+				advice: [
+					s("drink some water"),
+					s("take a deep breath"),
+					s("go touch some grass"),
+					s("stretch your back"),
+					s("go to bed"),
+					s("have a snack"),
+					s("call your mother"),
+					s("rest your eyes"),
+					s("be gentle with yourself")
+				],
+				endearment: [
+					s("friend"),
+					s("sweetie"),
+					s("pal"),
+					s("champ"),
+					s("buddy")
+				]
+			}
+		}]
+	}
+};
+var FALLBACKS = [
+	c("no"),
+	c("nope"),
+	c("lol"),
+	c("nah"),
+	c("no.")
+];
+var RUDE_FALLBACKS = [p("fu"), ...FALLBACKS];
+function expandTemplate(template) {
+	const names = Object.keys(template.slots);
+	let partial = [{
+		text: template.pattern,
+		profane: template.profane ?? false
+	}];
+	for (const name of names) {
+		const values = template.slots[name];
+		const next = [];
+		for (const item of partial) for (const value of values) next.push({
+			text: item.text.split(`{${name}}`).join(value.text),
+			profane: item.profane || (value.profane ?? false)
+		});
+		partial = next;
+	}
+	return partial;
+}
+var cache = /* @__PURE__ */ new Map();
+function allPhrases(mood) {
+	const hit = cache.get(mood);
+	if (hit) return hit;
+	const data = DATA[mood];
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const phrase of [...data.fixed, ...data.templates.flatMap(expandTemplate)]) {
+		const key = phrase.text.toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(phrase);
+	}
+	cache.set(mood, out);
+	return out;
+}
+function phrasesFor(mood, clean) {
+	const all = allPhrases(mood);
+	return clean ? all.filter((phrase) => !phrase.profane) : all;
+}
+function fallbacksFor(mood, clean) {
+	const all = mood === "rude" ? RUDE_FALLBACKS : FALLBACKS;
+	return clean ? all.filter((phrase) => !phrase.profane) : all;
+}
+//#endregion
+//#region src/doc/types.ts
+var LoadError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "LoadError";
+	}
+};
+var LOAD_MESSAGES = {
+	unsupported: "That's not a PDF, PNG, JPG or WebP. We only redact the classics.",
+	encrypted: "This PDF is password-protected. Ironic. Unlock it first.",
+	corrupt: "That file wouldn't open. It may be damaged, or not what its name says."
+};
+var MAX_PAGE_PX = 4500;
+function sniffMime(bytes) {
+	const head = Buffer.from(bytes.subarray(0, 12));
+	if (head.subarray(0, 4).toString("latin1") === "%PDF") return "application/pdf";
+	if (head[0] === 137 && head.subarray(1, 4).toString("latin1") === "PNG") return "image/png";
+	if (head[0] === 255 && head[1] === 216) return "image/jpeg";
+	if (head.subarray(0, 4).toString("latin1") === "RIFF" && head.subarray(8, 12).toString("latin1") === "WEBP") return "image/webp";
+	return null;
+}
+async function loadImageDocument(path, bytes, mime) {
+	let image;
+	try {
+		image = await loadImage(Buffer.from(bytes));
+	} catch {
+		throw new LoadError("corrupt", "That image wouldn't decode.");
+	}
+	const canvas = createCanvas(image.width, image.height);
+	canvas.getContext("2d").drawImage(image, 0, 0);
+	return {
+		path,
+		name: basename(path),
+		kind: "image",
+		mime,
+		info: {},
+		pages: [{
+			index: 0,
+			width: canvas.width,
+			height: canvas.height,
+			canvas,
+			items: []
+		}]
+	};
+}
+function pdfjsRoot() {
+	const require = createRequire(import.meta.url);
+	return dirname(require.resolve("pdfjs-dist/package.json"));
+}
+function apply(m, x, y) {
+	return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+function itemRect(transform, width, height, viewport) {
+	const size = height || Math.hypot(transform[2], transform[3]) || 1;
+	const corners = [
+		apply(transform, 0, -.22),
+		apply(transform, 0, .8),
+		apply(transform, 0, .8),
+		apply(transform, 0, -.22)
+	];
+	const advance = width / size;
+	corners[2] = apply(transform, advance, .8);
+	corners[3] = apply(transform, advance, -.22);
+	const points = corners.map(([x, y]) => apply(viewport, x, y));
+	const xs = points.map((p) => p[0]);
+	const ys = points.map((p) => p[1]);
+	const x = Math.min(...xs);
+	const y = Math.min(...ys);
+	return {
+		x,
+		y,
+		w: Math.max(...xs) - x,
+		h: Math.max(...ys) - y
+	};
+}
+async function nativeImageSize(page, OPS) {
+	try {
+		const ops = await page.getOperatorList();
+		const paints = ops.fnArray.map((fn, i) => fn === OPS.paintImageXObject ? i : -1).filter((i) => i >= 0);
+		if (paints.length !== 1) return null;
+		const name = ops.argsArray[paints[0]][0];
+		const image = await new Promise((done) => {
+			try {
+				page.objs.get(name, (value) => done(value));
+			} catch {
+				done(null);
+			}
+		});
+		if (!image?.width || !image.height) return null;
+		return {
+			w: image.width,
+			h: image.height
+		};
+	} catch {
+		return null;
+	}
+}
+async function loadPdfDocument(path, bytes, options) {
+	const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+	const root = pdfjsRoot();
+	const task = pdfjs.getDocument({
+		data: bytes,
+		cMapUrl: join(root, "cmaps/"),
+		cMapPacked: true,
+		standardFontDataUrl: join(root, "standard_fonts/"),
+		iccUrl: join(root, "iccs/"),
+		wasmUrl: join(root, "wasm/"),
+		useSystemFonts: false,
+		stopAtErrors: false
+	});
+	task.onPassword = () => {
+		throw new LoadError("encrypted", "password");
+	};
+	let pdf;
+	try {
+		pdf = await task.promise;
+	} catch (error) {
+		if (error instanceof LoadError) throw error;
+		if (error.name === "PasswordException") throw new LoadError("encrypted", "password");
+		throw new LoadError("corrupt", "That PDF wouldn't open.");
+	}
+	const pages = [];
+	let info = {};
+	try {
+		const meta = await pdf.getMetadata().catch(() => null);
+		if (meta?.info) info = Object.fromEntries(Object.entries(meta.info).filter(([, v]) => typeof v === "string").map(([k, v]) => [k, v]));
+		for (let i = 1; i <= pdf.numPages; i++) {
+			const page = await pdf.getPage(i);
+			const base = page.getViewport({ scale: 1 });
+			let scale = 150 / 72;
+			const native = options.nativeImages ? await nativeImageSize(page, pdfjs.OPS) : null;
+			if (native && Math.abs(native.w / native.h - base.width / base.height) < .01) scale = native.w / base.width;
+			const longest = Math.max(base.width, base.height) * scale;
+			if (longest > MAX_PAGE_PX) scale *= MAX_PAGE_PX / longest;
+			const viewport = page.getViewport({ scale });
+			const canvas = createCanvas(Math.round(viewport.width), Math.round(viewport.height));
+			await page.render({
+				canvas,
+				viewport,
+				background: "#ffffff"
+			}).promise;
+			const content = await page.getTextContent();
+			const items = [];
+			for (const item of content.items) {
+				if (!("str" in item) || item.str.length === 0) continue;
+				items.push({
+					str: item.str,
+					rect: itemRect(item.transform, item.width, item.height, viewport.transform)
+				});
+			}
+			pages.push({
+				index: i - 1,
+				width: canvas.width,
+				height: canvas.height,
+				canvas,
+				points: {
+					w: base.width,
+					h: base.height
+				},
+				items
+			});
+			page.cleanup();
+		}
+	} finally {
+		await task.destroy();
+	}
+	return {
+		path,
+		name: basename(path),
+		kind: "pdf",
+		mime: "application/pdf",
+		pages,
+		info
+	};
+}
+async function loadDocument(path, options = {}) {
+	let bytes;
+	try {
+		bytes = new Uint8Array(await readFile(path));
+	} catch {
+		throw new LoadError("corrupt", `${path} could not be read.`);
+	}
+	const mime = sniffMime(bytes);
+	if (!mime) throw new LoadError("unsupported", "unsupported");
+	if (mime === "application/pdf") return loadPdfDocument(path, bytes, options);
+	return loadImageDocument(path, bytes, mime);
+}
+//#endregion
+//#region src/core/fit.ts
+var FONT_SCALE = .82;
+var TARGET_RATIO = .95;
+var JOINER = ". ";
+var RANK_UNIT = .05;
+var RANK_NOISE = 1.5;
+function fontSizeFor(h) {
+	return Math.max(1, Math.round(h * FONT_SCALE));
+}
+function availableWidth(w) {
+	return Math.max(1, w - 4);
+}
+function capacityFor(w, h, measure) {
+	const avg = measure("the quick brown fox 0123", fontSizeFor(h)) / 24;
+	if (!(avg > 0)) return 0;
+	return Math.max(0, Math.floor(availableWidth(w) / avg));
+}
+function closeness(ratio) {
+	return Math.abs(ratio - TARGET_RATIO) / RANK_UNIT;
+}
+function inBand(ratio) {
+	return ratio >= .85 && ratio <= 1;
+}
+function rank(seed, scored) {
+	const rng = mulberry32(seed);
+	return shuffle(rng, scored).map((item) => ({
+		item,
+		key: closeness(item.ratio) + rng() * RANK_NOISE
+	})).sort((a, b) => a.key - b.key).map(({ item }) => item);
+}
+function chains(singles, avail, px, measure, seed) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (let attempt = 0; attempt < 16 && out.length < 12; attempt++) {
+		const order = shuffle(mulberry32(seed + attempt * 7919 >>> 0), singles);
+		let text = "";
+		for (const item of order) {
+			const next = text ? text + JOINER + item.text : item.text;
+			const ratio = measure(next, px) / avail;
+			if (ratio > 1) continue;
+			text = next;
+			if (ratio >= .85) break;
+		}
+		if (!text || seen.has(text)) continue;
+		const ratio = measure(text, px) / avail;
+		if (inBand(ratio)) {
+			seen.add(text);
+			out.push({
+				text,
+				ratio
+			});
+		}
+	}
+	return out;
+}
+function pairs(singles, avail, px, measure, seed) {
+	const joinerWidth = measure(JOINER, px);
+	const widths = singles.map((item) => item.ratio * avail);
+	const order = shuffle(mulberry32(seed ^ 2654435769), singles.map((_, i) => i));
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const i of order) for (const j of order) {
+		if (i === j) continue;
+		if (!inBand((widths[i] + joinerWidth + widths[j]) / avail)) continue;
+		const text = singles[i].text + JOINER + singles[j].text;
+		if (seen.has(text)) continue;
+		seen.add(text);
+		const ratio = measure(text, px) / avail;
+		if (inBand(ratio)) out.push({
+			text,
+			ratio
+		});
+		if (out.length >= 24) return out;
+	}
+	return out;
+}
+function fitDecoy(options) {
+	const { w, h, measure, pool, fallbacks, seed, exclude } = options;
+	const px = fontSizeFor(h);
+	const avail = availableWidth(w);
+	const capacity = capacityFor(w, h, measure);
+	const singles = pool.map((phrase) => ({
+		text: phrase.text,
+		ratio: measure(phrase.text, px) / avail
+	}));
+	let candidates = singles.filter((item) => inBand(item.ratio));
+	if (candidates.length === 0 && singles.length > 0) {
+		if (singles.every((item) => item.ratio < .85)) {
+			candidates = pairs(singles, avail, px, measure, seed);
+			if (candidates.length === 0) candidates = chains(singles, avail, px, measure, seed);
+			if (candidates.length === 0) {
+				const widest = [...singles].sort((a, b) => b.ratio - a.ratio).slice(0, 6);
+				candidates = widest.flatMap((a) => widest.filter((b) => b.text !== a.text).map((b) => {
+					const text = a.text + JOINER + b.text;
+					return {
+						text,
+						ratio: measure(text, px) / avail
+					};
+				}));
+			}
+		}
+	}
+	if (candidates.length === 0) {
+		const roomy = singles.filter((item) => item.ratio <= 1 && item.ratio >= .5).sort((a, b) => b.ratio - a.ratio);
+		if (roomy.length > 0) {
+			const top = roomy[0].ratio;
+			candidates = roomy.filter((item) => item.ratio >= top - .1);
+		}
+	}
+	if (candidates.length === 0) {
+		const scoredFallbacks = fallbacks.map((phrase) => ({
+			text: phrase.text,
+			ratio: measure(phrase.text, px) / avail
+		}));
+		const fitting = scoredFallbacks.filter((item) => item.ratio <= 1);
+		candidates = fitting.length > 0 ? fitting : [...scoredFallbacks].sort((a, b) => a.ratio - b.ratio).slice(0, 1);
+		if (fitting.length > 0) {
+			candidates.sort((a, b) => b.ratio - a.ratio);
+			const best = candidates[0];
+			return {
+				best: best.text,
+				alternatives: candidates.slice(1, 4).map((item) => item.text),
+				ratio: best.ratio,
+				capacity,
+				fontSize: px
+			};
+		}
+	}
+	const ranked = rank(seed, candidates);
+	const withoutCurrent = exclude ? ranked.filter((item) => item.text !== exclude) : ranked;
+	const ordered = withoutCurrent.length > 0 ? withoutCurrent : ranked;
+	const best = ordered[0];
+	const alternatives = [];
+	for (const item of ordered.slice(1)) {
+		if (item.text === best.text) continue;
+		alternatives.push(item.text);
+		if (alternatives.length === 3) break;
+	}
+	return {
+		best: best.text,
+		alternatives,
+		ratio: best.ratio,
+		capacity,
+		fontSize: px
+	};
+}
+//#endregion
+//#region src/core/geometry.ts
+function clampRect(rect, bounds) {
+	const w = Math.max(1, Math.min(Math.round(rect.w), bounds.w));
+	const h = Math.max(1, Math.min(Math.round(rect.h), bounds.h));
+	return {
+		x: Math.max(0, Math.min(Math.round(rect.x), bounds.w - w)),
+		y: Math.max(0, Math.min(Math.round(rect.y), bounds.h - h)),
+		w,
+		h
+	};
+}
+function expandRect(rect, margin, bounds) {
+	const x0 = Math.max(0, rect.x - margin);
+	const y0 = Math.max(0, rect.y - margin);
+	const x1 = Math.min(bounds.w, rect.x + rect.w + margin);
+	const y1 = Math.min(bounds.h, rect.y + rect.h + margin);
+	return {
+		x: x0,
+		y: y0,
+		w: Math.max(0, x1 - x0),
+		h: Math.max(0, y1 - y0)
+	};
+}
+//#endregion
+//#region src/core/sample.ts
+var MIN_CONTRAST = 48;
+function meanOf(data, indices) {
+	if (indices.length === 0) return [
+		0,
+		0,
+		0
+	];
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	for (const i of indices) {
+		r += data[i * 4];
+		g += data[i * 4 + 1];
+		b += data[i * 4 + 2];
+	}
+	const n = indices.length;
+	return [
+		Math.round(r / n),
+		Math.round(g / n),
+		Math.round(b / n)
+	];
+}
+function sampleInkPaper(region) {
+	const { data, w, h } = region;
+	const n = w * h;
+	if (n === 0) return {
+		ink: INK_FALLBACK,
+		paper: [
+			255,
+			255,
+			255
+		],
+		lowContrast: true
+	};
+	const lumas = new Float32Array(n);
+	for (let i = 0; i < n; i++) lumas[i] = luma(data[i * 4], data[i * 4 + 1], data[i * 4 + 2]);
+	const sorted = Array.from(lumas).sort((a, b) => a - b);
+	const p60 = sorted[Math.min(n - 1, Math.floor(n * .6))];
+	const p5 = sorted[Math.min(n - 1, Math.floor(n * .05))];
+	const bright = [];
+	const dark = [];
+	for (let i = 0; i < n; i++) {
+		if (lumas[i] >= p60) bright.push(i);
+		if (lumas[i] <= p5) dark.push(i);
+	}
+	const paper = meanOf(data, bright);
+	let ink = meanOf(data, dark);
+	const lowContrast = Math.abs(luma(...paper) - luma(...ink)) < MIN_CONTRAST;
+	if (lowContrast) ink = INK_FALLBACK;
+	return {
+		ink,
+		paper,
+		lowContrast
+	};
+}
+//#endregion
+//#region src/doc/pdf-assemble.ts
+var PRODUCER = "DECOY";
+async function assemblePdf(pages, options) {
+	const { PDFDocument } = await import("pdf-lib");
+	const out = await PDFDocument.create({ updateMetadata: false });
+	for (const page of pages) {
+		const image = page.kind === "jpeg" ? await out.embedJpg(page.bytes) : await out.embedPng(page.bytes);
+		const size = page.points ?? {
+			w: page.width * 72 / 150,
+			h: page.height * 72 / 150
+		};
+		out.addPage([size.w, size.h]).drawImage(image, {
+			x: 0,
+			y: 0,
+			width: size.w,
+			height: size.h
+		});
+	}
+	out.setTitle(options.title ?? "");
+	out.setAuthor("");
+	out.setSubject("");
+	out.setKeywords([]);
+	out.setCreator("");
+	out.setProducer(PRODUCER);
+	return out.save({ useObjectStreams: true });
+}
+//#endregion
+//#region src/render/backend.ts
+var factory = null;
+function setCanvasFactory(next) {
+	factory = next;
+}
+function canvasFactory() {
+	return factory;
+}
+//#endregion
+//#region src/render/text.ts
+var DECOY_FONT_FAMILY = "\"Courier Prime\", \"Courier New\", Courier, monospace";
+function font(px) {
+	return `700 ${px}px ${DECOY_FONT_FAMILY}`;
+}
+function makeCanvas(w, h) {
+	const factory = canvasFactory();
+	if (factory) return { ctx: factory(w, h) };
+	if (typeof OffscreenCanvas !== "undefined") {
+		const ctx = new OffscreenCanvas(w, h).getContext("2d", { willReadFrequently: true });
+		if (ctx) return { ctx };
+	}
+	const canvas = document.createElement("canvas");
+	canvas.width = w;
+	canvas.height = h;
+	const ctx = canvas.getContext("2d", { willReadFrequently: true });
+	if (!ctx) throw new Error("2D canvas is not available");
+	return { ctx };
+}
+var measureCtx = null;
+var widthCache = /* @__PURE__ */ new Map();
+function measureText(text, px) {
+	const key = `${px}|${text}`;
+	const hit = widthCache.get(key);
+	if (hit !== void 0) return hit;
+	measureCtx ??= makeCanvas(1, 1).ctx;
+	measureCtx.font = font(px);
+	const width = measureCtx.measureText(text).width;
+	if (widthCache.size > 5e3) widthCache.clear();
+	widthCache.set(key, width);
+	return width;
+}
+function rasterizeText(text, w, h) {
+	const { ctx } = makeCanvas(w, h);
+	ctx.fillStyle = "#fff";
+	ctx.fillRect(0, 0, w, h);
+	let size = fontSizeFor(h);
+	ctx.font = font(size);
+	const width = ctx.measureText(text).width;
+	const avail = availableWidth(w);
+	if (width > avail) {
+		size = Math.max(6, size * avail / width);
+		ctx.font = font(size);
+	}
+	ctx.fillStyle = "#000";
+	ctx.textBaseline = "middle";
+	ctx.fillText(text, 2, h / 2 + 1);
+	return ctx.getImageData(0, 0, w, h).data;
+}
+//#endregion
+//#region src/render/mosaic.ts
+function mosaicPixels(spec) {
+	const w = Math.max(1, Math.round(spec.w));
+	const h = Math.max(1, Math.round(spec.h));
+	return {
+		data: mosaicFromCoverage(coverageFromRgba(rasterizeText(spec.text, w, h), w, h), {
+			w,
+			h,
+			cell: spec.cell,
+			ink: parseHex(spec.ink, INK_FALLBACK),
+			paper: parseHex(spec.paper, PAPER_FALLBACK),
+			seed: mosaicSeed(spec.text)
+		}),
+		w,
+		h
+	};
+}
+//#endregion
+//#region src/cli/backend.ts
+var FONTS = [{
+	file: "courier-prime-latin-700-normal.woff2",
+	family: "Courier Prime"
+}, {
+	file: "ibm-plex-mono-latin-600-normal.woff2",
+	family: "IBM Plex Mono"
+}];
+function fontPath(file) {
+	const here = dirname(fileURLToPath(import.meta.url));
+	for (const rel of ["fonts", "../../design/fonts"]) {
+		const candidate = join(here, rel, file);
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+var ready = false;
+function setupNodeCanvas() {
+	if (ready) return;
+	for (const font of FONTS) {
+		const path = fontPath(font.file);
+		if (!path) throw new Error(`The font ${font.file} is missing next to the CLI; reinstall the package.`);
+		GlobalFonts.registerFromPath(path, font.family);
+	}
+	setCanvasFactory((w, h) => createCanvas(w, h).getContext("2d"));
+	ready = true;
+}
+function union(a, b) {
+	const x = Math.min(a.x, b.x);
+	const y = Math.min(a.y, b.y);
+	return {
+		x,
+		y,
+		w: Math.max(a.x + a.w, b.x + b.w) - x,
+		h: Math.max(a.y + a.h, b.y + b.h) - y
+	};
+}
+function linesFromItems(items) {
+	const sorted = items.filter((item) => item.str.length > 0 && item.rect.w > 0 && item.rect.h > 0).map((item) => ({
+		item,
+		cy: item.rect.y + item.rect.h / 2
+	})).sort((a, b) => a.cy - b.cy || a.item.rect.x - b.item.rect.x);
+	const groups = [];
+	for (const { item, cy } of sorted) {
+		const last = groups[groups.length - 1];
+		if (last && Math.abs(cy - last.cy) <= Math.max(last.h, item.rect.h) / 2) last.items.push(item);
+		else groups.push({
+			items: [item],
+			cy,
+			h: item.rect.h
+		});
+	}
+	return groups.map(({ items: group }) => {
+		group.sort((a, b) => a.rect.x - b.rect.x);
+		let text = "";
+		let rect = group[0].rect;
+		const lineItems = [];
+		group.forEach((item, i) => {
+			if (i > 0) {
+				const prev = group[i - 1];
+				if (item.rect.x - (prev.rect.x + prev.rect.w) > item.rect.h * .2 && !text.endsWith(" ") && !item.str.startsWith(" ")) text += " ";
+			}
+			lineItems.push({
+				item,
+				start: text.length,
+				end: text.length + item.str.length
+			});
+			text += item.str;
+			rect = union(rect, item.rect);
+		});
+		return {
+			text,
+			items: lineItems,
+			rect
+		};
+	});
+}
+function rectOfRange(line, start, end) {
+	let rect = null;
+	for (const { item, start: s, end: e } of line.items) {
+		const from = Math.max(start, s);
+		const to = Math.min(end, e);
+		if (to <= from) continue;
+		const len = Math.max(1, e - s);
+		const x0 = item.rect.x + item.rect.w * (from - s) / len;
+		const x1 = item.rect.x + item.rect.w * (to - s) / len;
+		const part = {
+			x: x0,
+			y: item.rect.y,
+			w: x1 - x0,
+			h: item.rect.h
+		};
+		rect = rect ? union(rect, part) : part;
+	}
+	return rect;
+}
+function padRect(rect, pad, bounds) {
+	const x = Math.max(0, Math.floor(rect.x - pad));
+	const y = Math.max(0, Math.floor(rect.y - pad));
+	let w = Math.ceil(rect.x + rect.w + pad) - x;
+	let h = Math.ceil(rect.y + rect.h + pad) - y;
+	if (bounds) {
+		w = Math.min(w, bounds.w - x);
+		h = Math.min(h, bounds.h - y);
+	}
+	return {
+		x,
+		y,
+		w,
+		h
+	};
+}
+function compilePattern(source) {
+	const flags = "gu";
+	try {
+		return new RegExp(source, flags);
+	} catch (error) {
+		throw new Error(`Bad pattern ${JSON.stringify(source)}: ${error.message}`, { cause: error });
+	}
+}
+function findMatches(lines, pattern, bounds) {
+	const matches = [];
+	for (const line of lines) {
+		pattern.lastIndex = 0;
+		for (const m of line.text.matchAll(pattern)) {
+			if (m[0].length === 0) continue;
+			const rect = rectOfRange(line, m.index, m.index + m[0].length);
+			if (!rect) continue;
+			matches.push({
+				text: m[0],
+				line: line.text,
+				rect: padRect(rect, 2, bounds)
+			});
+		}
+	}
+	return matches;
+}
+//#endregion
+//#region src/cli/redact.ts
+var DEFAULT_OPTIONS = {
+	mood: DEFAULT_MOOD,
+	clean: false,
+	cell: 8,
+	watermark: false,
+	keepTitle: false
+};
+function findInDocument(doc, patterns) {
+	const compiled = patterns.map(compilePattern);
+	return doc.pages.map((page) => {
+		const lines = linesFromItems(page.items);
+		const bounds = {
+			w: page.width,
+			h: page.height
+		};
+		const matches = compiled.flatMap((pattern) => findMatches(lines, pattern, bounds));
+		return {
+			page: page.index,
+			matches
+		};
+	});
+}
+function boxesFromMatches(found) {
+	return found.flatMap(({ page, matches }) => matches.map((m) => ({
+		page,
+		rect: m.rect,
+		source: m.text
+	})));
+}
+function parseBoxArg(text) {
+	const [coords, pageText] = text.split("@");
+	const parts = coords.split(",").map((n) => Number(n.trim()));
+	if (parts.length !== 4 || parts.some((n) => !Number.isFinite(n) || n < 0)) throw new Error(`A box is x,y,w,h in page pixels, optionally @page: got ${JSON.stringify(text)}`);
+	const page = pageText === void 0 ? 1 : Number(pageText);
+	if (!Number.isInteger(page) || page < 1) throw new Error(`Bad page in ${JSON.stringify(text)}`);
+	const [x, y, w, h] = parts;
+	return {
+		page: page - 1,
+		rect: {
+			x,
+			y,
+			w,
+			h
+		},
+		source: "box"
+	};
+}
+function sampleColours(page, rect) {
+	const region = expandRect(rect, 6, {
+		w: page.width,
+		h: page.height
+	});
+	const image = page.canvas.getContext("2d").getImageData(region.x, region.y, Math.max(1, region.w), Math.max(1, region.h));
+	const sampled = sampleInkPaper({
+		data: image.data,
+		w: image.width,
+		h: image.height
+	});
+	return {
+		ink: toHex(sampled.ink),
+		paper: toHex(sampled.paper)
+	};
+}
+function normalise(rect, page) {
+	return clampRect({
+		x: Math.round(rect.x),
+		y: Math.round(rect.y),
+		w: Math.max(4, Math.round(rect.w)),
+		h: Math.max(4, Math.round(rect.h))
+	}, {
+		w: page.width,
+		h: page.height
+	});
+}
+function planDecoys(doc, boxes, options) {
+	setupNodeCanvas();
+	return boxes.map((box, i) => {
+		const page = doc.pages[box.page];
+		if (!page) throw new Error(`Page ${box.page + 1} does not exist; the document has ${doc.pages.length}.`);
+		const rect = normalise(box.rect, page);
+		const seed = options.seed === void 0 ? randomSeed() : hashString(`${options.seed}:${i}`);
+		const colours = sampleColours(page, rect);
+		const text = options.text ?? fitDecoy({
+			w: rect.w,
+			h: rect.h,
+			measure: measureText,
+			pool: phrasesFor(options.mood, options.clean),
+			fallbacks: fallbacksFor(options.mood, options.clean),
+			seed
+		}).best;
+		return {
+			page: box.page,
+			rect,
+			source: box.source,
+			text,
+			ink: colours.ink,
+			paper: colours.paper,
+			seed
+		};
+	});
+}
+function drawWatermark(canvas) {
+	const ctx = canvas.getContext("2d");
+	const px = Math.max(9, Math.round(Math.min(canvas.width, canvas.height) / 90));
+	ctx.save();
+	ctx.font = `600 ${px}px "IBM Plex Mono", "Courier New", monospace`;
+	ctx.textBaseline = "alphabetic";
+	ctx.textAlign = "right";
+	ctx.fillStyle = "rgba(23, 20, 15, 0.55)";
+	ctx.fillText("decoyed", canvas.width - px, canvas.height - px);
+	ctx.restore();
+}
+function flattenPage(page, decoys, options) {
+	setupNodeCanvas();
+	const canvas = createCanvas(page.width, page.height);
+	const ctx = canvas.getContext("2d");
+	ctx.drawImage(page.canvas, 0, 0);
+	for (const decoy of decoys) {
+		const mosaic = mosaicPixels({
+			text: decoy.text,
+			w: decoy.rect.w,
+			h: decoy.rect.h,
+			cell: options.cell,
+			ink: decoy.ink,
+			paper: decoy.paper
+		});
+		ctx.putImageData(new ImageData$1(new Uint8ClampedArray(mosaic.data), mosaic.w, mosaic.h), decoy.rect.x, decoy.rect.y);
+	}
+	if (options.watermark) drawWatermark(canvas);
+	return canvas;
+}
+function baseName(name) {
+	return name.replace(/\.[^.]+$/, "") || "document";
+}
+function defaultFormat(doc) {
+	return doc.kind === "pdf" ? "pdf" : "png";
+}
+function defaultOutput(doc, format) {
+	return join(dirname(doc.path), `${baseName(doc.name)}-decoyed.${format}`);
+}
+async function writeRedacted(doc, decoys, options, format, out) {
+	const flattened = doc.pages.map((page) => flattenPage(page, decoys.filter((d) => d.page === page.index), options));
+	if (format === "png") {
+		const many = flattened.length > 1;
+		const files = [];
+		for (const [i, canvas] of flattened.entries()) {
+			const path = many ? out.replace(/\.png$/i, "") + `-p${i + 1}.png` : out;
+			const bytes = await canvas.encode("png");
+			await writeFile(path, bytes);
+			files.push({
+				path,
+				bytes: bytes.byteLength
+			});
+		}
+		return files;
+	}
+	const photographic = doc.kind === "image" && doc.mime === "image/jpeg";
+	const pages = [];
+	for (const [i, canvas] of flattened.entries()) {
+		const bytes = photographic ? await canvas.encode("jpeg", 92) : await canvas.encode("png");
+		pages.push({
+			bytes: new Uint8Array(bytes),
+			kind: photographic ? "jpeg" : "png",
+			width: canvas.width,
+			height: canvas.height,
+			points: doc.pages[i].points
+		});
+	}
+	const pdf = await assemblePdf(pages, { title: options.keepTitle ? baseName(doc.name) : null });
+	await writeFile(out, pdf);
+	return [{
+		path: out,
+		bytes: pdf.byteLength
+	}];
+}
+//#endregion
+//#region src/cli/run.ts
+function runFind(doc, patterns) {
+	const pages = doc.pages.map((p) => ({
+		page: p.index + 1,
+		width: p.width,
+		height: p.height
+	}));
+	if (patterns.length === 0) {
+		const lines = doc.pages.flatMap((p) => linesFromItems(p.items).map((line) => ({
+			page: p.index + 1,
+			text: line.text,
+			rect: round(line.rect)
+		})));
+		return {
+			file: doc.path,
+			kind: doc.kind,
+			pages,
+			lines
+		};
+	}
+	const matches = findInDocument(doc, patterns).flatMap(({ page, matches }) => matches.map((m) => ({
+		page: page + 1,
+		text: m.text,
+		line: m.line,
+		rect: round(m.rect)
+	})));
+	return {
+		file: doc.path,
+		kind: doc.kind,
+		pages,
+		matches
+	};
+}
+async function runRedact(doc, request) {
+	const options = {
+		mood: request.mood ?? DEFAULT_OPTIONS.mood,
+		clean: request.clean ?? DEFAULT_OPTIONS.clean,
+		cell: request.cell ?? DEFAULT_OPTIONS.cell,
+		seed: request.seed,
+		text: request.text,
+		watermark: request.watermark ?? DEFAULT_OPTIONS.watermark,
+		keepTitle: request.keepTitle ?? DEFAULT_OPTIONS.keepTitle
+	};
+	const boxes = [...request.patterns.length > 0 ? boxesFromMatches(findInDocument(doc, request.patterns)) : [], ...request.boxes];
+	if (boxes.length === 0) throw new Error(doc.kind === "pdf" ? "Nothing to redact: no pattern matched the text layer and no box was given." : "Nothing to redact: images have no text layer, so give boxes in page pixels.");
+	const decoys = planDecoys(doc, boxes, options);
+	const format = request.format ?? defaultFormat(doc);
+	const outputs = await writeRedacted(doc, decoys, options, format, request.out ?? defaultOutput(doc, format));
+	return {
+		file: doc.path,
+		format,
+		outputs,
+		decoys: decoys.map((d) => ({
+			page: d.page + 1,
+			covered: d.source,
+			rect: d.rect,
+			text: d.text,
+			seed: d.seed
+		}))
+	};
+}
+function round(rect) {
+	return {
+		x: Math.round(rect.x),
+		y: Math.round(rect.y),
+		w: Math.round(rect.w),
+		h: Math.round(rect.h)
+	};
+}
+//#endregion
+//#region src/cli/verify.ts
+function inside(rects, x, y) {
+	return rects.some((r) => x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h);
+}
+function watermarkCorner(w, h) {
+	const px = Math.max(9, Math.round(Math.min(w, h) / 90));
+	return {
+		x: w - px * 9,
+		y: h - px * 3,
+		w: px * 9,
+		h: px * 3
+	};
+}
+function pixelChecks(original, output, boxesByPage) {
+	const checks = [];
+	if (original.pages.length !== output.pages.length) return [{
+		name: "pages",
+		ok: false,
+		detail: `the original has ${original.pages.length} page(s), the output ${output.pages.length}`
+	}];
+	for (const page of original.pages) {
+		const other = output.pages[page.index];
+		if (page.width !== other.width || page.height !== other.height) {
+			checks.push({
+				name: `page ${page.index + 1} size`,
+				ok: false,
+				detail: `${page.width}×${page.height} became ${other.width}×${other.height}; pixels cannot be compared`
+			});
+			continue;
+		}
+		const a = page.canvas.getContext("2d").getImageData(0, 0, page.width, page.height).data;
+		const b = other.canvas.getContext("2d").getImageData(0, 0, page.width, page.height).data;
+		const boxes = boxesByPage.get(page.index) ?? [];
+		const corner = watermarkCorner(page.width, page.height);
+		let insideChanged = 0;
+		let insideTotal = 0;
+		let outsideChanged = 0;
+		for (let y = 0; y < page.height; y++) for (let x = 0; x < page.width; x++) {
+			const i = (y * page.width + x) * 4;
+			const same = a[i] === b[i] && a[i + 1] === b[i + 1] && a[i + 2] === b[i + 2];
+			if (inside(boxes, x, y)) {
+				insideTotal++;
+				if (!same) insideChanged++;
+			} else if (!same && !inside([corner], x, y)) outsideChanged++;
+		}
+		if (boxes.length > 0) checks.push({
+			name: `page ${page.index + 1} matches covered`,
+			ok: insideChanged > 0,
+			detail: `${insideChanged} of ${insideTotal} pixels inside the ${boxes.length} matched box(es) differ from the original`
+		});
+		checks.push({
+			name: `page ${page.index + 1} untouched elsewhere`,
+			ok: outsideChanged === 0,
+			detail: outsideChanged === 0 ? "every pixel outside the boxes (and the watermark corner) is identical to the original" : `${outsideChanged} pixel(s) outside the boxes changed`
+		});
+	}
+	return checks;
+}
+async function verifyOutput(path, options) {
+	const output = await loadDocument(path, { nativeImages: true });
+	const checks = [];
+	if (output.kind === "pdf") {
+		const text = output.pages.reduce((n, p) => n + p.items.filter((i) => i.str.trim()).length, 0);
+		checks.push({
+			name: "no text layer",
+			ok: text === 0,
+			detail: text === 0 ? "every page is image-only" : `${text} text run(s) survive in the PDF`
+		});
+		const producer = output.info.Producer ?? "";
+		checks.push({
+			name: "written by DECOY",
+			ok: producer === PRODUCER,
+			detail: producer ? `producer is "${producer}"` : "no producer field"
+		});
+		const leftovers = [
+			"Author",
+			"Subject",
+			"Keywords",
+			"Creator"
+		].filter((k) => (output.info[k] ?? "") !== "");
+		checks.push({
+			name: "metadata cleared",
+			ok: leftovers.length === 0,
+			detail: leftovers.length === 0 ? "author, subject, keywords, and creator are empty" : `${leftovers.join(", ")} set`
+		});
+	}
+	if (options.patterns.length > 0) {
+		const hits = findInDocument(output, options.patterns).reduce((n, p) => n + p.matches.length, 0);
+		checks.push({
+			name: "patterns absent",
+			ok: hits === 0,
+			detail: hits === 0 ? "no pattern matches any text in the output" : `${hits} match(es) still readable as text`
+		});
+	}
+	if (options.original) {
+		const original = await loadDocument(options.original);
+		const boxesByPage = /* @__PURE__ */ new Map();
+		for (const box of options.boxes ?? []) boxesByPage.set(box.page, [...boxesByPage.get(box.page) ?? [], box.rect]);
+		if (options.patterns.length > 0) {
+			for (const box of boxesFromMatches(findInDocument(original, options.patterns))) boxesByPage.set(box.page, [...boxesByPage.get(box.page) ?? [], box.rect]);
+			const total = [...boxesByPage.values()].reduce((n, r) => n + r.length, 0);
+			checks.push({
+				name: "patterns found in original",
+				ok: total > 0,
+				detail: total > 0 ? `${total} match(es) in the original` : "nothing matched in the original, so nothing was tested"
+			});
+		}
+		checks.push(...pixelChecks(original, output, boxesByPage));
+	}
+	return {
+		file: path,
+		ok: checks.every((c) => c.ok),
+		checks
+	};
+}
+//#endregion
+//#region src/cli/mcp.ts
+var moodSchema = z.enum(MOODS);
+var boxSchema = z.object({
+	page: z.number().int().min(1).describe("1-based page number"),
+	x: z.number().min(0),
+	y: z.number().min(0),
+	w: z.number().positive(),
+	h: z.number().positive()
+});
+function json(value) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(value, null, 2)
+	}] };
+}
+function failure(error) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: error.message
+		}]
+	};
+}
+async function serveMcp(version) {
+	const server = new McpServer({
+		name: "decoy",
+		version
+	});
+	server.registerTool("find_text", {
+		title: "Find text in a document",
+		description: "Lists the text runs of a PDF with their boxes in page pixels (150 dpi), optionally only those matching regular expressions. Images have no text layer and return nothing; redact them with explicit boxes.",
+		inputSchema: {
+			file: z.string().describe("Path to a PDF, PNG, JPG, or WebP file"),
+			patterns: z.array(z.string()).optional().describe("JavaScript regular expressions; omit to list every line")
+		}
+	}, async ({ file, patterns }) => {
+		try {
+			return json(runFind(await loadDocument(file), patterns ?? []));
+		} catch (error) {
+			return failure(error);
+		}
+	});
+	server.registerTool("redact", {
+		title: "Redact a document with decoys",
+		description: "Covers every match of the patterns, and every explicit box, with a pixelated decoy phrase, then writes a flattened copy next to the input (or at \"out\"). The mosaic is computed from the decoy phrase only; the original pixels under a box never influence the output. Returns what was covered and where the file went.",
+		inputSchema: {
+			file: z.string().describe("Path to a PDF, PNG, JPG, or WebP file"),
+			patterns: z.array(z.string()).optional().describe("JavaScript regular expressions to cover (PDFs only)"),
+			boxes: z.array(boxSchema).optional().describe("Explicit boxes in page pixels at 150 dpi"),
+			mood: moodSchema.optional().describe("Phrase mood: rude, smug, corporate, or wholesome (default smug)"),
+			clean: z.boolean().optional().describe("Skip profane phrases"),
+			cell: z.number().int().min(4).max(16).optional().describe("Mosaic block size in pixels"),
+			seed: z.number().int().optional().describe("Seed for reproducible phrase choice"),
+			text: z.string().optional().describe("Use this phrase for every box instead of choosing one"),
+			watermark: z.boolean().optional().describe("Stamp \"decoyed\" in the corner"),
+			format: z.enum(["pdf", "png"]).optional().describe("Output format; defaults to the input kind"),
+			out: z.string().optional().describe("Output path; defaults to <name>-decoyed.<format> next to the input")
+		}
+	}, async (args) => {
+		try {
+			const request = {
+				patterns: args.patterns ?? [],
+				boxes: (args.boxes ?? []).map((b) => ({
+					page: b.page - 1,
+					rect: {
+						x: b.x,
+						y: b.y,
+						w: b.w,
+						h: b.h
+					},
+					source: "box"
+				})),
+				mood: args.mood,
+				clean: args.clean,
+				cell: args.cell,
+				seed: args.seed,
+				text: args.text,
+				watermark: args.watermark,
+				format: args.format,
+				out: args.out
+			};
+			return json(await runRedact(await loadDocument(args.file), request));
+		} catch (error) {
+			return failure(error);
+		}
+	});
+	server.registerTool("verify", {
+		title: "Verify a redacted file",
+		description: "Checks a DECOY output: a PDF has no text layer and no metadata, none of the patterns is readable as text, and, given the original, only the matched boxes changed. Returns the checks and an overall ok.",
+		inputSchema: {
+			file: z.string().describe("Path to the redacted file"),
+			patterns: z.array(z.string()).optional().describe("Regular expressions that must not be readable"),
+			boxes: z.array(boxSchema).optional().describe("Boxes that were redacted by hand"),
+			original: z.string().optional().describe("Path to the original, to compare pixels outside the boxes")
+		}
+	}, async ({ file, patterns, boxes, original }) => {
+		try {
+			return json(await verifyOutput(file, {
+				patterns: patterns ?? [],
+				boxes: (boxes ?? []).map((b) => ({
+					page: b.page - 1,
+					rect: {
+						x: b.x,
+						y: b.y,
+						w: b.w,
+						h: b.h
+					},
+					source: "box"
+				})),
+				original
+			}));
+		} catch (error) {
+			return failure(error);
+		}
+	});
+	await server.connect(new StdioServerTransport());
+}
+//#endregion
+//#region src/cli/main.ts
+var VERSION = "1.1.0";
+function collect(value, previous) {
+	return [...previous, value];
+}
+function integer(min, max) {
+	return (value) => {
+		const n = Number(value);
+		if (!Number.isInteger(n) || n < min || n > max) throw new InvalidArgumentError(`expected an integer between ${min} and ${max}`);
+		return n;
+	};
+}
+function mood(value) {
+	if (!MOODS.includes(value)) throw new InvalidArgumentError(`expected one of ${MOODS.join(", ")}`);
+	return value;
+}
+function fail(error) {
+	const message = error instanceof LoadError ? LOAD_MESSAGES[error.code] : error.message ?? String(error);
+	console.error(`decoy: ${message}`);
+	process.exit(error instanceof LoadError ? 3 : 2);
+}
+var program = new Command().name("decoy").description("Redact PDFs and images by painting a pixelated decoy phrase over the secret. Runs entirely on this machine.").version(VERSION).option("--json", "machine-readable output");
+program.command("find").description("list the text of a PDF with boxes in page pixels, or only the matches of patterns").argument("<file>", "PDF, PNG, JPG, or WebP").option("-m, --match <regex>", "pattern to look for (repeatable)", collect, []).action(async (file, opts) => {
+	try {
+		const result = runFind(await loadDocument(file), opts.match);
+		if (program.opts().json) return console.log(JSON.stringify(result, null, 2));
+		if (result.kind === "image") return console.log("An image has no text layer; redact it with --box.");
+		const rows = result.matches ?? result.lines ?? [];
+		if (rows.length === 0) return console.log(opts.match.length ? "No match." : "No text.");
+		for (const row of rows) {
+			const r = row.rect;
+			console.log(`page ${row.page}  ${r.x},${r.y} ${r.w}×${r.h}  ${JSON.stringify(row.text)}`);
+		}
+	} catch (error) {
+		fail(error);
+	}
+});
+program.command("redact").description("cover every match and every box with a decoy and write a flattened copy").argument("<file>", "PDF, PNG, JPG, or WebP").option("-m, --match <regex>", "cover every match of this pattern (repeatable, PDFs only)", collect, []).option("-b, --box <x,y,w,h[@page]>", "cover this box in page pixels at 150 dpi (repeatable)", collect, []).option("--mood <mood>", `phrase mood: ${MOODS.join(", ")}`, mood).option("--clean", "no profanity").option("--cell <px>", `mosaic block size, 4-16`, integer(4, 16)).option("--seed <n>", "reproducible phrase choice", integer(0, Number.MAX_SAFE_INTEGER)).option("--text <phrase>", "use this phrase for every box").option("--watermark", "stamp \"decoyed\" in the corner").option("--keep-title", "keep the file name as the PDF title").option("-f, --format <pdf|png>", "output format; defaults to the input kind", (v) => {
+	if (v !== "pdf" && v !== "png") throw new InvalidArgumentError("expected pdf or png");
+	return v;
+}).option("-o, --out <path>", "output path; defaults to <name>-decoyed.<format> next to the input").action(async (file, opts) => {
+	try {
+		const result = await runRedact(await loadDocument(file), {
+			patterns: opts.match,
+			boxes: opts.box.map(parseBoxArg),
+			mood: opts.mood,
+			clean: opts.clean,
+			cell: opts.cell,
+			seed: opts.seed,
+			text: opts.text,
+			watermark: opts.watermark,
+			keepTitle: opts.keepTitle,
+			format: opts.format,
+			out: opts.out
+		});
+		if (program.opts().json) return console.log(JSON.stringify(result, null, 2));
+		for (const d of result.decoys) {
+			const r = d.rect;
+			const covered = d.covered === "box" ? "box" : JSON.stringify(d.covered);
+			console.log(`page ${d.page}  ${r.x},${r.y} ${r.w}×${r.h}  ${covered} -> "${grawlix(d.text)}"`);
+		}
+		for (const out of result.outputs) console.log(`wrote ${out.path} (${(out.bytes / 1024).toFixed(1)} kB)`);
+	} catch (error) {
+		fail(error);
+	}
+});
+program.command("verify").description("check a redacted file: no text layer, no metadata, patterns gone, nothing else touched").argument("<file>", "the redacted PDF or image").option("-m, --match <regex>", "pattern that must not be readable (repeatable)", collect, []).option("-b, --box <x,y,w,h[@page]>", "box that was redacted by hand (repeatable)", collect, []).option("--original <file>", "the original, to confirm only the matched boxes changed").action(async (file, opts) => {
+	try {
+		const report = await verifyOutput(file, {
+			patterns: opts.match,
+			boxes: opts.box.map(parseBoxArg),
+			original: opts.original
+		});
+		if (program.opts().json) console.log(JSON.stringify(report, null, 2));
+		else {
+			for (const c of report.checks) console.log(`${c.ok ? "ok  " : "FAIL"} ${c.name}: ${c.detail}`);
+			console.log(report.ok ? "verified" : "NOT verified");
+		}
+		process.exit(report.ok ? 0 : 1);
+	} catch (error) {
+		fail(error);
+	}
+});
+program.command("mcp").description("serve find_text, redact, and verify as MCP tools over stdio").action(async () => {
+	try {
+		await serveMcp(VERSION);
+	} catch (error) {
+		fail(error);
+	}
+});
+await program.parseAsync(process.argv);
+//#endregion
+export {};