slackmark-node 0.1.0

package/dist/index.js

@@ -0,0 +1,1792 @@
+import { createRequire } from "node:module";
+import { ConfigurationError, ConfigurationError as ConfigurationError$1, OperationAbortedError, OperationAbortedError as OperationAbortedError$1, OperationDeadlineExceededError, OperationDeadlineExceededError as OperationDeadlineExceededError$1, OperationError, OperationErrorCode, OperationErrorCode as OperationErrorCode$1, OperationShutdownError, OperationShutdownError as OperationShutdownError$1, RecordingReceiptCollector, attachReceipts, cloneOperationError, createConverter, isConfigurationError, isOperationError, lockReceiptSnapshot, resolveCapabilities } from "slackmark";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+import { SlackUploadError, SlackUploadStage } from "slackmark/slack";
+//#region src/errors.ts
+const NodeRenderErrorCode = {
+	AssetMissing: "asset_missing",
+	BrowserBinaryMissing: "browser_binary_missing",
+	BrowserDisconnected: "browser_disconnected",
+	BrowserFailed: "browser_failed",
+	CleanupFailed: "cleanup_failed",
+	CloseFailed: "close_failed",
+	ContextFailed: "context_failed",
+	DimensionLimit: "dimension_limit",
+	OutputLimit: "output_limit",
+	QueueFull: "queue_full",
+	RenderFailed: "render_failed",
+	SourceLimit: "source_limit"
+};
+const NodeRenderStage = {
+	Admission: "admission",
+	AssetLoad: "asset_load",
+	Browser: "browser",
+	BrowserCleanup: "browser_cleanup",
+	BrowserClose: "browser_close",
+	BrowserLaunch: "browser_launch",
+	ContextCleanup: "context_cleanup",
+	ContextCreate: "context_create",
+	Layout: "layout",
+	OutputValidation: "output_validation",
+	Render: "render",
+	SourceValidation: "source_validation"
+};
+var NodeShutdownTimeoutError = class extends Error {
+	name;
+	code;
+	stage;
+	retryable;
+	status;
+	receipts;
+	settledReceipts;
+	constructor(status, receipts, settledReceipts) {
+		super("Node converter shutdown timed out");
+		this.name = "NodeShutdownTimeoutError";
+		this.code = "shutdown_timeout";
+		this.stage = "close";
+		this.retryable = true;
+		this.status = status;
+		this.receipts = Object.freeze([...receipts]);
+		this.settledReceipts = settledReceipts;
+	}
+};
+/**
+* Sanitized failure from the Node rendering boundary.
+*/
+var NodeRenderError = class extends Error {
+	code;
+	stage;
+	retryable;
+	rendererId;
+	constructor(code, message, options = {
+		stage: "render",
+		retryable: false
+	}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "NodeRenderError";
+		this.code = code;
+		this.stage = options.stage;
+		this.retryable = options.retryable;
+		this.rendererId = options.rendererId;
+	}
+};
+function normalizeNodeRenderError(error, code, message, stage = NodeRenderStage.Render, retryable = false) {
+	return error instanceof NodeRenderError || isOperationError(error) ? error : new NodeRenderError(code, message, {
+		stage,
+		retryable,
+		cause: error
+	});
+}
+//#endregion
+//#region src/katex-assets.ts
+const resolver$1 = createRequire(import.meta.url);
+const WOFF2_URL_RE = /url\(fonts\/([A-Za-z0-9_-]+\.woff2)\)/g;
+const LEGACY_FONT_SOURCE_RE = /, url\(fonts\/[A-Za-z0-9_-]+\.(?:woff|ttf)\) format\("(?:woff|truetype)"\)/g;
+/**
+* Reads KaTeX's installed CSS/fonts and embeds WOFF2 files as data URLs once.
+*/
+var LocalKatexAssetLoader = class {
+	cssPromise;
+	scriptPromise;
+	constructor() {
+		this.cssPromise = void 0;
+		this.scriptPromise = void 0;
+	}
+	loadScript() {
+		this.scriptPromise ??= readFile(resolver$1.resolve("katex/dist/katex.min.js"), "utf8").catch((error) => {
+			this.scriptPromise = void 0;
+			throw normalizeNodeRenderError(error, NodeRenderErrorCode.AssetMissing, "Unable to load local KaTeX script", "asset_load", false);
+		});
+		return this.scriptPromise;
+	}
+	loadCss() {
+		this.cssPromise ??= this.loadCssFromPackage().catch((error) => {
+			this.cssPromise = void 0;
+			throw normalizeNodeRenderError(error, NodeRenderErrorCode.AssetMissing, "Unable to load local KaTeX assets", "asset_load", false);
+		});
+		return this.cssPromise;
+	}
+	async loadCssFromPackage() {
+		const cssPath = resolver$1.resolve("katex/dist/katex.css");
+		const css = await readFile(cssPath, "utf8");
+		const fontNames = /* @__PURE__ */ new Set();
+		for (const match of css.matchAll(WOFF2_URL_RE)) {
+			const fontName = match[1];
+			if (fontName !== void 0) fontNames.add(fontName);
+		}
+		const encodedFonts = await Promise.all([...fontNames].map(async (fontName) => {
+			return [fontName, (await readFile(join(dirname(cssPath), "fonts", fontName))).toString("base64")];
+		}));
+		let embedded = css.replace(LEGACY_FONT_SOURCE_RE, "");
+		for (const [fontName, base64] of encodedFonts) embedded = embedded.replaceAll(`url(fonts/${fontName})`, `url(data:font/woff2;base64,${base64})`);
+		return embedded;
+	}
+};
+//#endregion
+//#region src/image-output.ts
+const PNG_SIGNATURE = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+const PNG_WIDTH_OFFSET = 16;
+const PNG_HEIGHT_OFFSET = 20;
+const PNG_HEADER_BYTES = 24;
+const PNG_IHDR = new Uint8Array([
+	73,
+	72,
+	68,
+	82
+]);
+const PNG_IHDR_OFFSET = 12;
+function deterministicPngFilename(prefix, source, optionsFingerprint) {
+	return `${prefix}-${createHash("sha256").update(prefix).update("\0").update(optionsFingerprint).update("\0").update(source).digest("hex").slice(0, 16)}.png`;
+}
+function assertSourceLimit(source, maxSourceChars) {
+	if (source.length > maxSourceChars) throw new NodeRenderError(NodeRenderErrorCode.SourceLimit, `Render source exceeds ${String(maxSourceChars)} characters`, {
+		stage: NodeRenderStage.SourceValidation,
+		retryable: false
+	});
+}
+function assertPngLimits(data, limits) {
+	if (data.byteLength > limits.maxOutputBytes) throw new NodeRenderError(NodeRenderErrorCode.OutputLimit, `Rendered image exceeds ${String(limits.maxOutputBytes)} bytes`, {
+		stage: NodeRenderStage.OutputValidation,
+		retryable: false
+	});
+	const dimensions = readPngDimensions(data);
+	if (dimensions === void 0) throw new NodeRenderError(NodeRenderErrorCode.RenderFailed, "Renderer returned invalid PNG data", {
+		stage: NodeRenderStage.OutputValidation,
+		retryable: false
+	});
+	if (dimensions.width > limits.maxWidth || dimensions.height > limits.maxHeight) throw new NodeRenderError(NodeRenderErrorCode.DimensionLimit, `Rendered image exceeds ${String(limits.maxWidth)}x${String(limits.maxHeight)} pixels`, {
+		stage: NodeRenderStage.Layout,
+		retryable: false
+	});
+}
+function readPngDimensions(data) {
+	if (data.byteLength < PNG_HEADER_BYTES) return;
+	for (const [index, byte] of PNG_SIGNATURE.entries()) if (data[index] !== byte) return;
+	for (const [index, byte] of PNG_IHDR.entries()) if (data[PNG_IHDR_OFFSET + index] !== byte) return;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const width = view.getUint32(PNG_WIDTH_OFFSET);
+	const height = view.getUint32(PNG_HEIGHT_OFFSET);
+	return width > 0 && height > 0 ? {
+		width,
+		height
+	} : void 0;
+}
+//#endregion
+//#region src/node-options.ts
+function snapshotNodeOptions(options, allowed, label) {
+	if (!isPlainNodeObject(options)) throw invalidNodeOptions(`${label} options must be a plain object`);
+	const allowedKeys = new Set(allowed);
+	const snapshot = {};
+	let keys;
+	try {
+		keys = Object.keys(options);
+	} catch (cause) {
+		throw invalidNodeOptions(`${label} options could not be inspected`, cause);
+	}
+	for (const key of keys) {
+		if (!allowedKeys.has(key)) throw invalidNodeOptions(`Unknown ${label} option: ${key}`);
+		try {
+			snapshot[key] = Reflect.get(options, key);
+		} catch (cause) {
+			throw invalidNodeOptions(`${label}.${key} could not be read`, cause);
+		}
+	}
+	return Object.freeze(snapshot);
+}
+function snapshotOpenNodeOptions(options, label) {
+	let keys;
+	try {
+		keys = Object.keys(options);
+	} catch (cause) {
+		throw invalidNodeOptions(`${label} could not be inspected`, cause);
+	}
+	return snapshotNodeOptions(options, keys, label);
+}
+function assertNodeMethod(collaborator, method, label) {
+	try {
+		if (typeof collaborator !== "object" && typeof collaborator !== "function" || collaborator === null || typeof Reflect.get(collaborator, method) !== "function") throw new TypeError(`${method} must be a function`);
+	} catch (cause) {
+		throw invalidNodeOptions(`${label} collaborator is invalid`, cause);
+	}
+}
+function invalidNodeOptions(message, cause) {
+	return new ConfigurationError$1(message, {
+		code: "invalid_node_configuration",
+		stage: "configuration",
+		cause
+	});
+}
+function isPlainNodeObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	let prototype;
+	try {
+		prototype = Object.getPrototypeOf(value);
+	} catch {
+		return false;
+	}
+	return prototype === Object.prototype || prototype === null;
+}
+//#endregion
+//#region src/katex-renderer.ts
+const DEFAULT_MAX_SOURCE_CHARS$1 = 2e4;
+const DEFAULT_MAX_OUTPUT_BYTES$1 = 10 * 1024 * 1024;
+const DEFAULT_MAX_WIDTH$1 = 4096;
+const DEFAULT_MAX_HEIGHT$1 = 4096;
+const DEFAULT_MAX_EXPAND = 1e3;
+const DEFAULT_MAX_SIZE = 50;
+const DEFAULT_FONT_SIZE_PX = 20;
+const DEFAULT_PADDING_PX = 16;
+const DEFAULT_DEVICE_SCALE_FACTOR$1 = 2;
+const DEFAULT_BACKGROUND_COLOR$1 = "white";
+const DEFAULT_VIEWPORT_WIDTH$1 = 1280;
+const DEFAULT_VIEWPORT_HEIGHT$1 = 720;
+const KATEX_LANGUAGES = /* @__PURE__ */ new Set([
+	"katex",
+	"latex",
+	"math",
+	"tex"
+]);
+const KATEX_SHELL = "<!doctype html><html><head><meta charset=\"utf-8\"><meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; font-src data:; img-src 'none'; connect-src 'none'; worker-src 'none';\"></head><body><div id=\"math\"></div></body></html>";
+const KATEX_LAYOUT_CSS = "html,body{margin:0;padding:0}#math{display:inline-block;box-sizing:border-box}.katex-display{margin:0}";
+/**
+* Renders display TeX with KaTeX, local fonts, and an isolated browser screenshot.
+*/
+var KatexRenderer = class {
+	id;
+	output;
+	runtime;
+	assets;
+	backgroundColor;
+	deviceScaleFactor;
+	fontSizePx;
+	paddingPx;
+	maxExpand;
+	maxSize;
+	maxSourceChars;
+	imageLimits;
+	optionsFingerprint;
+	constructor(options) {
+		const validated = snapshotNodeOptions(options, [
+			"runtime",
+			"assets",
+			"backgroundColor",
+			"deviceScaleFactor",
+			"fontSizePx",
+			"paddingPx",
+			"maxExpand",
+			"maxSize",
+			"maxSourceChars",
+			"maxOutputBytes",
+			"maxWidth",
+			"maxHeight"
+		], "KatexRenderer");
+		assertNodeMethod(validated.runtime, "run", "RenderRuntime");
+		assertNodeMethod(validated.assets, "loadScript", "KatexAssetLoader");
+		assertNodeMethod(validated.assets, "loadCss", "KatexAssetLoader");
+		this.id = "katex";
+		this.output = "bytes";
+		this.runtime = validated.runtime;
+		this.assets = validated.assets;
+		this.backgroundColor = validated.backgroundColor ?? DEFAULT_BACKGROUND_COLOR$1;
+		this.deviceScaleFactor = validated.deviceScaleFactor ?? DEFAULT_DEVICE_SCALE_FACTOR$1;
+		this.fontSizePx = validated.fontSizePx ?? DEFAULT_FONT_SIZE_PX;
+		this.paddingPx = validated.paddingPx ?? DEFAULT_PADDING_PX;
+		this.maxExpand = validated.maxExpand ?? DEFAULT_MAX_EXPAND;
+		this.maxSize = validated.maxSize ?? DEFAULT_MAX_SIZE;
+		this.maxSourceChars = validated.maxSourceChars ?? DEFAULT_MAX_SOURCE_CHARS$1;
+		this.imageLimits = {
+			maxOutputBytes: validated.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES$1,
+			maxWidth: validated.maxWidth ?? DEFAULT_MAX_WIDTH$1,
+			maxHeight: validated.maxHeight ?? DEFAULT_MAX_HEIGHT$1
+		};
+		this.optionsFingerprint = [
+			this.backgroundColor,
+			String(this.deviceScaleFactor),
+			String(this.fontSizePx),
+			String(this.paddingPx),
+			String(this.maxExpand),
+			String(this.maxSize),
+			String(this.maxSourceChars),
+			String(this.imageLimits.maxOutputBytes),
+			String(this.imageLimits.maxWidth),
+			String(this.imageLimits.maxHeight)
+		].join(":");
+		validateOptions$1({
+			backgroundColor: this.backgroundColor,
+			deviceScaleFactor: this.deviceScaleFactor,
+			fontSizePx: this.fontSizePx,
+			paddingPx: this.paddingPx,
+			maxExpand: this.maxExpand,
+			maxSize: this.maxSize,
+			maxSourceChars: this.maxSourceChars,
+			imageLimits: this.imageLimits
+		});
+	}
+	canRender(request) {
+		return KATEX_LANGUAGES.has(request.lang.trim().toLowerCase());
+	}
+	async render(request, context) {
+		if (!this.canRender(request)) return null;
+		assertSourceLimit(request.source, this.maxSourceChars);
+		let data;
+		try {
+			data = await this.runtime.run(async (context) => {
+				const script = await this.assets.loadScript();
+				const css = await this.assets.loadCss();
+				const page = await context.newPage();
+				await page.setViewport({
+					width: DEFAULT_VIEWPORT_WIDTH$1,
+					height: DEFAULT_VIEWPORT_HEIGHT$1,
+					deviceScaleFactor: this.deviceScaleFactor
+				});
+				await page.setContent(KATEX_SHELL, { waitUntil: "domcontentloaded" });
+				await page.addStyleTag({ content: `${css}\n${KATEX_LAYOUT_CSS}` });
+				await page.addScriptTag({ content: script });
+				await page.$eval("body", (body, backgroundColor) => {
+					body.style.background = backgroundColor;
+				}, this.backgroundColor);
+				await page.$eval("#math", (container, values) => {
+					const katex = globalThis.katex;
+					if (katex === void 0) throw new Error("KaTeX browser harness failed to initialize");
+					container.innerHTML = katex.renderToString(values.source, {
+						displayMode: true,
+						globalGroup: false,
+						maxExpand: values.maxExpand,
+						maxSize: values.maxSize,
+						output: "html",
+						strict: "ignore",
+						throwOnError: true,
+						trust: false
+					});
+					container.setAttribute("style", `font-size:${String(values.fontSizePx)}px;padding:${String(values.paddingPx)}px`);
+				}, {
+					source: request.source,
+					maxExpand: this.maxExpand,
+					maxSize: this.maxSize,
+					fontSizePx: this.fontSizePx,
+					paddingPx: this.paddingPx
+				});
+				await page.evaluate(async () => {
+					await document.fonts.ready;
+				});
+				const element = await page.$("#math");
+				if (element === null) throw new Error("KaTeX screenshot element is missing");
+				const box = await element.boundingBox();
+				if (box === null) throw new Error("KaTeX screenshot element has no dimensions");
+				const pixelWidth = Math.ceil(box.width * this.deviceScaleFactor);
+				const pixelHeight = Math.ceil(box.height * this.deviceScaleFactor);
+				if (pixelWidth > this.imageLimits.maxWidth || pixelHeight > this.imageLimits.maxHeight) throw new NodeRenderError(NodeRenderErrorCode.DimensionLimit, `Rendered image exceeds ${String(this.imageLimits.maxWidth)}x${String(this.imageLimits.maxHeight)} pixels`, {
+					stage: NodeRenderStage.Layout,
+					retryable: false
+				});
+				return element.screenshot({
+					type: "png",
+					omitBackground: this.backgroundColor === "transparent"
+				});
+			}, context);
+		} catch (error) {
+			if (isOperationError(error)) throw error;
+			if (error instanceof NodeRenderError) {
+				const sanitizedRenderFailure = error.code === NodeRenderErrorCode.RenderFailed && error.cause === void 0;
+				if (error.code !== NodeRenderErrorCode.RenderFailed || sanitizedRenderFailure) throw error;
+			}
+			throw new NodeRenderError(NodeRenderErrorCode.RenderFailed, "KaTeX rendering failed", {
+				stage: "render",
+				retryable: false
+			});
+		}
+		assertPngLimits(data, this.imageLimits);
+		return {
+			kind: "bytes",
+			data,
+			mimeType: "image/png",
+			filename: deterministicPngFilename("math", request.source, this.optionsFingerprint),
+			altText: request.altText
+		};
+	}
+};
+function validateOptions$1(renderer) {
+	if (typeof renderer.backgroundColor !== "string" || renderer.backgroundColor.length === 0) throw invalidNodeOptions("backgroundColor must be a nonempty string");
+	validatePositiveFinite$1(renderer.deviceScaleFactor, "deviceScaleFactor");
+	validatePositiveFinite$1(renderer.fontSizePx, "fontSizePx");
+	validateNonNegativeFinite(renderer.paddingPx, "paddingPx");
+	validatePositiveInteger$3(renderer.maxExpand, "maxExpand");
+	validatePositiveFinite$1(renderer.maxSize, "maxSize");
+	validatePositiveInteger$3(renderer.maxSourceChars, "maxSourceChars");
+	validatePositiveInteger$3(renderer.imageLimits.maxOutputBytes, "maxOutputBytes");
+	validatePositiveInteger$3(renderer.imageLimits.maxWidth, "maxWidth");
+	validatePositiveInteger$3(renderer.imageLimits.maxHeight, "maxHeight");
+}
+function validatePositiveInteger$3(value, name) {
+	if (!Number.isInteger(value) || value <= 0) throw invalidNodeOptions(`${name} must be a positive integer`);
+}
+function validatePositiveFinite$1(value, name) {
+	if (!Number.isFinite(value) || value <= 0) throw invalidNodeOptions(`${name} must be positive`);
+}
+function validateNonNegativeFinite(value, name) {
+	if (!Number.isFinite(value) || value < 0) throw invalidNodeOptions(`${name} must be non-negative`);
+}
+//#endregion
+//#region src/mermaid-assets.ts
+const resolver = createRequire(import.meta.url);
+var LocalMermaidAssetLoader = class {
+	scriptPromise;
+	constructor() {
+		this.scriptPromise = void 0;
+	}
+	loadScript() {
+		this.scriptPromise ??= readFile(resolver.resolve("mermaid/dist/mermaid.min.js"), "utf8").catch((error) => {
+			this.scriptPromise = void 0;
+			throw new NodeRenderError(NodeRenderErrorCode.AssetMissing, "Unable to load Mermaid browser assets", {
+				stage: "asset_load",
+				retryable: false,
+				cause: error
+			});
+		});
+		return this.scriptPromise;
+	}
+};
+//#endregion
+//#region src/mermaid-renderer.ts
+const DEFAULT_MAX_SOURCE_CHARS = 5e4;
+const DEFAULT_MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
+const DEFAULT_MAX_WIDTH = 4096;
+const DEFAULT_MAX_HEIGHT = 4096;
+const DEFAULT_MAX_EDGES = 500;
+const DEFAULT_DEVICE_SCALE_FACTOR = 2;
+const DEFAULT_BACKGROUND_COLOR = "white";
+const DEFAULT_VIEWPORT_WIDTH = 1280;
+const DEFAULT_VIEWPORT_HEIGHT = 720;
+const MERMAID_SHELL = "<!doctype html><html><head><meta charset=\"utf-8\"><meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src 'none'; font-src 'none'; connect-src 'none'; worker-src 'none'; object-src 'none'; frame-src 'none';\"></head><body><div id=\"diagram\"></div></body></html>";
+const SECURE_MERMAID_KEYS = [
+	"secure",
+	"securityLevel",
+	"startOnLoad",
+	"maxTextSize",
+	"suppressErrorRendering",
+	"maxEdges",
+	"deterministicIds",
+	"deterministicIDSeed",
+	"layout"
+];
+const MERMAID_THEMES = /* @__PURE__ */ new Set([
+	"base",
+	"dark",
+	"default",
+	"forest",
+	"neutral"
+]);
+var MermaidRenderer = class {
+	id;
+	output;
+	runtime;
+	assets;
+	theme;
+	backgroundColor;
+	deviceScaleFactor;
+	maxSourceChars;
+	maxEdges;
+	imageLimits;
+	optionsFingerprint;
+	constructor(options) {
+		const validated = snapshotNodeOptions(options, [
+			"runtime",
+			"assets",
+			"theme",
+			"backgroundColor",
+			"deviceScaleFactor",
+			"maxSourceChars",
+			"maxEdges",
+			"maxOutputBytes",
+			"maxWidth",
+			"maxHeight"
+		], "MermaidRenderer");
+		assertNodeMethod(validated.runtime, "run", "RenderRuntime");
+		assertNodeMethod(validated.assets, "loadScript", "MermaidAssetLoader");
+		this.id = "mermaid";
+		this.output = "bytes";
+		this.runtime = validated.runtime;
+		this.assets = validated.assets;
+		this.theme = validated.theme ?? "default";
+		this.backgroundColor = validated.backgroundColor ?? DEFAULT_BACKGROUND_COLOR;
+		this.deviceScaleFactor = validated.deviceScaleFactor ?? DEFAULT_DEVICE_SCALE_FACTOR;
+		this.maxSourceChars = validated.maxSourceChars ?? DEFAULT_MAX_SOURCE_CHARS;
+		this.maxEdges = validated.maxEdges ?? DEFAULT_MAX_EDGES;
+		this.imageLimits = {
+			maxOutputBytes: validated.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
+			maxWidth: validated.maxWidth ?? DEFAULT_MAX_WIDTH,
+			maxHeight: validated.maxHeight ?? DEFAULT_MAX_HEIGHT
+		};
+		this.optionsFingerprint = [
+			this.theme,
+			this.backgroundColor,
+			String(this.deviceScaleFactor),
+			String(this.maxSourceChars),
+			String(this.maxEdges),
+			String(this.imageLimits.maxOutputBytes),
+			String(this.imageLimits.maxWidth),
+			String(this.imageLimits.maxHeight)
+		].join(":");
+		validateOptions({
+			theme: this.theme,
+			backgroundColor: this.backgroundColor,
+			deviceScaleFactor: this.deviceScaleFactor,
+			maxSourceChars: this.maxSourceChars,
+			maxEdges: this.maxEdges,
+			imageLimits: this.imageLimits
+		});
+	}
+	canRender(request) {
+		return request.lang.trim().toLowerCase() === "mermaid";
+	}
+	async render(request, context) {
+		if (!this.canRender(request)) return null;
+		assertSourceLimit(request.source, this.maxSourceChars);
+		let data;
+		try {
+			data = await this.runtime.run(async (context) => {
+				const script = await this.assets.loadScript();
+				const page = await context.newPage();
+				await page.setRequestInterception(true);
+				page.on("request", blockRequest);
+				await page.setViewport({
+					width: DEFAULT_VIEWPORT_WIDTH,
+					height: DEFAULT_VIEWPORT_HEIGHT,
+					deviceScaleFactor: this.deviceScaleFactor
+				});
+				await page.setContent(MERMAID_SHELL, { waitUntil: "domcontentloaded" });
+				await page.addScriptTag({ content: script });
+				await page.evaluate(async (input) => {
+					const mermaid = globalThis.mermaid;
+					const container = document.querySelector("#diagram");
+					if (mermaid === void 0 || container === null) throw new Error("Mermaid browser harness failed to initialize");
+					mermaid.initialize({
+						deterministicIds: true,
+						deterministicIDSeed: "slackmark-node",
+						layout: "dagre",
+						logLevel: "fatal",
+						maxEdges: input.maxEdges,
+						maxTextSize: input.maxSourceChars,
+						secure: input.secureKeys,
+						securityLevel: "strict",
+						startOnLoad: false,
+						suppressErrorRendering: true,
+						theme: input.theme
+					});
+					await mermaid.parse(input.source, { suppressErrors: false });
+					container.innerHTML = (await mermaid.render("slackmark-diagram", input.source, container)).svg;
+					document.body.style.background = input.backgroundColor;
+				}, {
+					source: request.source,
+					theme: this.theme,
+					backgroundColor: this.backgroundColor,
+					maxSourceChars: this.maxSourceChars,
+					maxEdges: this.maxEdges,
+					secureKeys: SECURE_MERMAID_KEYS
+				});
+				const element = await page.$("#diagram svg");
+				if (element === null) throw new Error("Mermaid produced no SVG");
+				const box = await element.boundingBox();
+				if (box === null) throw new Error("Mermaid SVG has no dimensions");
+				const pixelWidth = Math.ceil(box.width * this.deviceScaleFactor);
+				const pixelHeight = Math.ceil(box.height * this.deviceScaleFactor);
+				if (pixelWidth > this.imageLimits.maxWidth || pixelHeight > this.imageLimits.maxHeight) throw new NodeRenderError(NodeRenderErrorCode.DimensionLimit, "Rendered Mermaid image exceeds configured dimensions", {
+					stage: "layout",
+					retryable: false
+				});
+				return element.screenshot({
+					type: "png",
+					omitBackground: this.backgroundColor === "transparent"
+				});
+			}, context);
+		} catch (error) {
+			if (isOperationError(error)) throw error;
+			if (error instanceof NodeRenderError) {
+				if (error.code !== NodeRenderErrorCode.RenderFailed) throw error;
+			}
+			throw new NodeRenderError(NodeRenderErrorCode.RenderFailed, "Mermaid rendering failed", {
+				stage: "render",
+				retryable: false
+			});
+		}
+		assertPngLimits(data, this.imageLimits);
+		return {
+			kind: "bytes",
+			data,
+			mimeType: "image/png",
+			filename: deterministicPngFilename("mermaid", request.source, this.optionsFingerprint),
+			altText: request.altText
+		};
+	}
+};
+function blockRequest(request) {
+	request.abort("blockedbyclient");
+}
+function validateOptions(renderer) {
+	if (typeof renderer.theme !== "string" || !MERMAID_THEMES.has(renderer.theme)) throw invalidNodeOptions("theme must be base, dark, default, forest, or neutral");
+	if (typeof renderer.backgroundColor !== "string" || renderer.backgroundColor.length === 0) throw invalidNodeOptions("backgroundColor must be a nonempty string");
+	validatePositiveFinite(renderer.deviceScaleFactor, "deviceScaleFactor");
+	validatePositiveInteger$2(renderer.maxSourceChars, "maxSourceChars");
+	validatePositiveInteger$2(renderer.maxEdges, "maxEdges");
+	validatePositiveInteger$2(renderer.imageLimits.maxOutputBytes, "maxOutputBytes");
+	validatePositiveInteger$2(renderer.imageLimits.maxWidth, "maxWidth");
+	validatePositiveInteger$2(renderer.imageLimits.maxHeight, "maxHeight");
+}
+function validatePositiveInteger$2(value, name) {
+	if (!Number.isInteger(value) || value <= 0) throw invalidNodeOptions(`${name} must be a positive integer`);
+}
+function validatePositiveFinite(value, name) {
+	if (!Number.isFinite(value) || value <= 0) throw invalidNodeOptions(`${name} must be positive`);
+}
+//#endregion
+//#region src/operation-control.ts
+var OperationScope = class {
+	context;
+	parentSignal;
+	controller;
+	abortFromParent;
+	deadlineTimer;
+	constructor(context, stage) {
+		this.parentSignal = context.signal;
+		this.controller = new AbortController();
+		this.abortFromParent = () => {
+			const reason = this.parentSignal?.reason;
+			this.controller.abort(isOperationError(reason) ? cloneOperationError(reason, stage) : new OperationAbortedError$1(stage, { cause: reason }));
+		};
+		if (this.parentSignal?.aborted === true) this.abortFromParent();
+		else this.parentSignal?.addEventListener("abort", this.abortFromParent, { once: true });
+		if (context.deadlineMs === void 0) this.deadlineTimer = void 0;
+		else if (context.deadlineMs <= Date.now()) {
+			this.deadlineTimer = void 0;
+			this.controller.abort(new OperationDeadlineExceededError$1(stage));
+		} else this.deadlineTimer = setTimeout(() => {
+			this.controller.abort(new OperationDeadlineExceededError$1(stage));
+		}, context.deadlineMs - Date.now());
+		this.context = Object.freeze({
+			signal: this.controller.signal,
+			deadlineMs: context.deadlineMs
+		});
+	}
+	abortForShutdown(stage) {
+		this.controller.abort(new OperationShutdownError$1(stage));
+	}
+	abort(reason) {
+		this.controller.abort(reason);
+	}
+	race(promise) {
+		return raceWithContext(promise, this.context);
+	}
+	cleanup() {
+		if (this.deadlineTimer !== void 0) clearTimeout(this.deadlineTimer);
+		this.parentSignal?.removeEventListener("abort", this.abortFromParent);
+	}
+};
+function createOperationScope(options = {}, stage) {
+	validateOperationOptions(options);
+	return new OperationScope({
+		signal: options.signal,
+		deadlineMs: options.timeoutMs === void 0 ? void 0 : Date.now() + options.timeoutMs
+	}, stage);
+}
+function raceWithContext(promise, context) {
+	const signal = context.signal;
+	if (signal?.aborted === true) return Promise.reject(signal.reason ?? new OperationAbortedError$1("operation"));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			signal?.removeEventListener("abort", onAbort);
+			reject(signal?.reason ?? new OperationAbortedError$1("operation"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal?.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+function operationReason(signal) {
+	return isOperationError(signal.reason) ? signal.reason : new OperationAbortedError$1("operation", { cause: signal.reason });
+}
+function validateOperationOptions(options) {
+	if (!isPlainObject(options)) throw new ConfigurationError$1("Operation options must be a plain object", {
+		code: "invalid_operation_options",
+		stage: "configuration"
+	});
+	for (const key of Object.keys(options)) if (key !== "signal" && key !== "timeoutMs") throw new ConfigurationError$1(`Unknown operation option: ${key}`, {
+		code: "invalid_operation_options",
+		stage: "configuration"
+	});
+	if (options.signal !== void 0 && (typeof options.signal !== "object" || options.signal === null || typeof options.signal.addEventListener !== "function" || typeof options.signal.removeEventListener !== "function")) throw new ConfigurationError$1("signal must be an AbortSignal", {
+		code: "invalid_signal",
+		stage: "configuration"
+	});
+	if (options.timeoutMs !== void 0 && (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) throw new ConfigurationError$1("timeoutMs must be positive", {
+		code: "invalid_timeout",
+		stage: "configuration"
+	});
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+//#endregion
+//#region src/puppeteer-render-runtime.ts
+const DEFAULT_CONCURRENCY = 2;
+const DEFAULT_MAX_QUEUE_SIZE = 32;
+const INTERNAL_LAUNCH_TIMEOUT_MS = 1e4;
+const INTERNAL_CLEANUP_TIMEOUT_MS = 2e3;
+const DENY_NETWORK_PROXY = "http://127.0.0.1:9";
+var PuppeteerRenderRuntime = class {
+	launcher;
+	launchOptions;
+	concurrency;
+	maxQueueSize;
+	contextOptions;
+	pendingJobs;
+	activeScopes;
+	idleResolvers;
+	activeJobs;
+	browserPromise;
+	currentBrowser;
+	launchController;
+	launchWaiters;
+	launchPending;
+	launchAbandoned;
+	launchError;
+	forceCloseBrowser;
+	forceClosePromise;
+	closePromise;
+	closeBehavior;
+	accepting;
+	constructor(options) {
+		const validated = snapshotNodeOptions(options, [
+			"launcher",
+			"launchOptions",
+			"concurrency",
+			"maxQueueSize"
+		], "PuppeteerRenderRuntime");
+		assertNodeMethod(validated.launcher, "launch", "BrowserLauncher");
+		const launchOptions = validated.launchOptions === void 0 ? void 0 : snapshotOpenNodeOptions(validated.launchOptions, "Puppeteer launchOptions");
+		this.launcher = validated.launcher;
+		this.launchOptions = {
+			headless: "shell",
+			...launchOptions
+		};
+		this.concurrency = validated.concurrency ?? DEFAULT_CONCURRENCY;
+		this.maxQueueSize = validated.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+		this.contextOptions = {
+			proxyServer: DENY_NETWORK_PROXY,
+			proxyBypassList: ["<-loopback>"],
+			downloadBehavior: { policy: "deny" }
+		};
+		this.pendingJobs = [];
+		this.activeScopes = /* @__PURE__ */ new Set();
+		this.idleResolvers = [];
+		this.activeJobs = 0;
+		this.browserPromise = void 0;
+		this.currentBrowser = void 0;
+		this.launchController = void 0;
+		this.launchWaiters = /* @__PURE__ */ new Set();
+		this.launchPending = false;
+		this.launchAbandoned = false;
+		this.launchError = void 0;
+		this.forceCloseBrowser = void 0;
+		this.forceClosePromise = void 0;
+		this.closePromise = void 0;
+		this.closeBehavior = void 0;
+		this.accepting = true;
+		validatePositiveInteger$1(this.concurrency, "concurrency");
+		validateNonNegativeInteger$1(this.maxQueueSize, "maxQueueSize");
+	}
+	run(job, operation) {
+		if (!this.accepting) return Promise.reject(new OperationShutdownError$1("render_admission"));
+		if (this.activeJobs >= this.concurrency && this.pendingJobs.length >= this.maxQueueSize) return Promise.reject(new NodeRenderError(NodeRenderErrorCode.QueueFull, `Render queue is full (max ${String(this.maxQueueSize)} pending)`, {
+			stage: "admission",
+			retryable: true
+		}));
+		return new Promise((resolve, reject) => {
+			const scope = new OperationScope(operation, "render");
+			let pending;
+			const abortWhileQueued = () => {
+				const index = this.pendingJobs.indexOf(pending);
+				if (index >= 0) {
+					this.pendingJobs.splice(index, 1);
+					pending.reject(operationReason(requireSignal$1(scope.context)));
+				}
+			};
+			pending = {
+				start: () => {
+					scope.context.signal?.removeEventListener("abort", abortWhileQueued);
+					this.activeScopes.add(scope);
+					this.startUnderlying(job, scope, resolve, reject);
+				},
+				reject: (error) => {
+					scope.context.signal?.removeEventListener("abort", abortWhileQueued);
+					scope.cleanup();
+					reject(error);
+				}
+			};
+			if (scope.context.signal?.aborted === true) {
+				pending.reject(operationReason(requireSignal$1(scope.context)));
+				return;
+			}
+			if (this.activeJobs < this.concurrency) {
+				this.activeJobs += 1;
+				pending.start();
+				return;
+			}
+			scope.context.signal?.addEventListener("abort", abortWhileQueued, { once: true });
+			this.pendingJobs.push(pending);
+		});
+	}
+	warmup(operation) {
+		return this.run(async () => void 0, operation);
+	}
+	close(operation, behavior = "cancel") {
+		if (this.closePromise !== void 0) return this.closePromise;
+		const closeScope = new OperationScope(operation, "browser_close");
+		this.accepting = false;
+		this.closeBehavior = behavior;
+		if (behavior === "cancel") {
+			const shutdown = new OperationShutdownError$1("render");
+			for (const pending of this.pendingJobs.splice(0)) pending.reject(shutdown);
+			for (const scope of this.activeScopes) scope.abortForShutdown("render");
+			this.abandonLaunch(shutdown);
+		}
+		this.closePromise = this.finishClose(closeScope.context).finally(() => {
+			closeScope.cleanup();
+		});
+		return this.closePromise;
+	}
+	status() {
+		return Object.freeze({
+			accepting: this.accepting,
+			active: this.activeJobs,
+			queued: this.pendingJobs.length,
+			retainedBytes: 0
+		});
+	}
+	startUnderlying(job, scope, resolve, reject) {
+		const underlying = this.executeUnderlying(job, scope);
+		scope.race(underlying).then(resolve, reject);
+		underlying.then(() => {
+			this.finishUnderlying(scope);
+		}, () => {
+			this.finishUnderlying(scope);
+		});
+	}
+	async executeUnderlying(job, scope) {
+		let browser;
+		let context;
+		let contextClosePromise;
+		let contextCleanupPromise;
+		let outcome;
+		const closeContext = () => {
+			if (context === void 0) return Promise.resolve();
+			contextClosePromise ??= Promise.resolve().then(() => context.close());
+			return contextClosePromise;
+		};
+		const cleanupContext = () => {
+			contextCleanupPromise ??= cleanupWithDeadline(closeContext(), async () => {
+				await this.forceCloseBrowserOnce(browser);
+			});
+			return contextCleanupPromise;
+		};
+		const requestContextClose = () => {
+			if (context !== void 0) cleanupContext().catch(() => void 0);
+		};
+		scope.context.signal?.addEventListener("abort", requestContextClose, { once: true });
+		try {
+			browser = await this.getBrowser(scope);
+			throwIfContextEnded(scope.context);
+			try {
+				context = await browser.createBrowserContext(this.contextOptions);
+			} catch (error) {
+				if (isBrowserDisconnected(error)) throw error;
+				throw new NodeRenderError(NodeRenderErrorCode.ContextFailed, "Browser context creation failed", {
+					stage: "context_create",
+					retryable: true,
+					cause: error
+				});
+			}
+			throwIfContextEnded(scope.context);
+			outcome = {
+				ok: true,
+				value: await Promise.resolve().then(() => job(context, scope.context))
+			};
+		} catch (error) {
+			if (scope.context.signal?.aborted === true) outcome = {
+				ok: false,
+				error: operationReason(requireSignal$1(scope.context))
+			};
+			else if (isBrowserDisconnected(error)) outcome = {
+				ok: false,
+				error: new NodeRenderError(NodeRenderErrorCode.BrowserDisconnected, "Chromium disconnected during rendering", {
+					stage: "browser",
+					retryable: true,
+					cause: error
+				})
+			};
+			else outcome = {
+				ok: false,
+				error: normalizeNodeRenderError(error, NodeRenderErrorCode.RenderFailed, "Browser rendering failed", "render", true)
+			};
+		}
+		scope.context.signal?.removeEventListener("abort", requestContextClose);
+		if (context !== void 0) try {
+			await cleanupContext();
+		} catch (cleanupError) {
+			if (outcome.ok || cleanupError instanceof NodeRenderError && cleanupError.stage === "browser_cleanup") outcome = {
+				ok: false,
+				error: cleanupError
+			};
+		}
+		if (outcome.ok) return outcome.value;
+		throw outcome.error;
+	}
+	finishUnderlying(scope) {
+		scope.cleanup();
+		this.activeScopes.delete(scope);
+		this.activeJobs -= 1;
+		const next = this.pendingJobs.shift();
+		if (next !== void 0 && this.closeBehavior !== "cancel") {
+			this.activeJobs += 1;
+			next.start();
+		} else if (next !== void 0) next.reject(new OperationShutdownError$1("render"));
+		if (this.activeJobs === 0 && this.pendingJobs.length === 0) for (const resolve of this.idleResolvers.splice(0)) resolve();
+	}
+	getBrowser(scope) {
+		if (this.browserPromise !== void 0) {
+			if (this.launchPending) {
+				this.launchWaiters.add(scope);
+				if (this.launchError !== void 0) scope.abort(this.launchError);
+			}
+			return this.browserPromise;
+		}
+		this.forceCloseBrowser = void 0;
+		this.forceClosePromise = void 0;
+		this.launchPending = true;
+		this.launchAbandoned = false;
+		this.launchError = void 0;
+		this.launchWaiters.add(scope);
+		const launchController = new AbortController();
+		this.launchController = launchController;
+		const deadlineMs = Date.now() + INTERNAL_LAUNCH_TIMEOUT_MS;
+		const launchOperation = {
+			signal: launchController.signal,
+			deadlineMs
+		};
+		const timeout = setTimeout(() => {
+			const error = new NodeRenderError(NodeRenderErrorCode.BrowserFailed, "Chromium launch deadline exceeded", {
+				stage: "browser_launch",
+				retryable: true
+			});
+			this.abandonLaunch(error);
+		}, INTERNAL_LAUNCH_TIMEOUT_MS);
+		const launched = Promise.resolve().then(() => this.launcher.launch(this.launchOptions, launchOperation));
+		let tracked;
+		tracked = Promise.resolve(launched).then(async (browser) => {
+			clearTimeout(timeout);
+			this.launchPending = false;
+			this.launchWaiters.clear();
+			if (this.launchAbandoned || !this.accepting) {
+				await this.forceCloseHandleOnce(browser);
+				if (this.browserPromise === tracked) this.browserPromise = void 0;
+				return browser;
+			}
+			this.currentBrowser = browser;
+			browser.on("disconnected", () => {
+				if (this.browserPromise === tracked) {
+					this.browserPromise = void 0;
+					this.currentBrowser = void 0;
+				}
+			});
+			return browser;
+		}).catch((error) => {
+			clearTimeout(timeout);
+			this.launchPending = false;
+			this.launchWaiters.clear();
+			if (this.browserPromise === tracked) this.browserPromise = void 0;
+			throw normalizeNodeRenderError(error, NodeRenderErrorCode.BrowserFailed, "Chromium launch failed", "browser_launch", true);
+		});
+		this.browserPromise = tracked;
+		return tracked;
+	}
+	async finishClose(operation) {
+		try {
+			await raceWithContext(this.waitForIdle(), operation);
+		} catch (error) {
+			this.closeBehavior = "cancel";
+			const shutdown = new OperationShutdownError$1("render");
+			for (const pending of this.pendingJobs.splice(0)) pending.reject(shutdown);
+			for (const scope of this.activeScopes) scope.abortForShutdown("render");
+			await this.forceCloseBrowserOnce();
+			throw error;
+		}
+		const browserPromise = this.browserPromise;
+		if (browserPromise === void 0) return;
+		let browser;
+		try {
+			browser = await raceWithContext(browserPromise, operation);
+		} catch (error) {
+			if (isOperationError(error) && error.code === OperationErrorCode$1.Shutdown) return;
+			await this.forceCloseBrowserOnce();
+			throw error;
+		}
+		if (!browser.connected) return;
+		try {
+			await raceWithContext(cleanupWithDeadline(browser.close(), () => this.forceCloseBrowserOnce(browser)), operation);
+		} catch (error) {
+			await this.forceCloseBrowserOnce(browser);
+			if (isOperationError(error)) throw error;
+			throw new NodeRenderError(NodeRenderErrorCode.CloseFailed, "Chromium close failed", {
+				stage: "browser_close",
+				retryable: true,
+				cause: error
+			});
+		}
+	}
+	waitForIdle() {
+		if (this.activeJobs === 0 && this.pendingJobs.length === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.idleResolvers.push(resolve);
+		});
+	}
+	forceCloseBrowserOnce(browser) {
+		if (this.launchPending) {
+			this.abandonLaunch(new OperationShutdownError$1("browser_close"));
+			return Promise.resolve();
+		}
+		if (browser !== void 0) return this.forceCloseHandleOnce(browser);
+		const browserPromise = this.browserPromise;
+		return browserPromise === void 0 ? Promise.resolve() : browserPromise.then((handle) => this.forceCloseHandleOnce(handle), () => void 0);
+	}
+	abandonLaunch(error) {
+		if (!this.launchPending) return;
+		this.launchAbandoned = true;
+		this.launchError = error;
+		this.launchController?.abort(error);
+		for (const waiter of this.launchWaiters) waiter.abort(error);
+	}
+	forceCloseHandleOnce(browser) {
+		if (this.currentBrowser === browser) {
+			this.currentBrowser = void 0;
+			this.browserPromise = void 0;
+		}
+		if (this.forceCloseBrowser !== browser || this.forceClosePromise === void 0) {
+			this.forceCloseBrowser = browser;
+			this.forceClosePromise = browser.forceClose().catch((error) => {
+				throw new NodeRenderError(NodeRenderErrorCode.CleanupFailed, "Browser cleanup failed", {
+					stage: "browser_cleanup",
+					retryable: true,
+					cause: error
+				});
+			});
+		}
+		return this.forceClosePromise;
+	}
+};
+async function importPuppeteerAndLaunch(options) {
+	const { launch } = await import("puppeteer");
+	return new PuppeteerBrowserHandle(await launch(options));
+}
+var PuppeteerBrowserLauncher = class {
+	launchBrowser;
+	constructor(launchBrowser = importPuppeteerAndLaunch) {
+		this.launchBrowser = launchBrowser;
+	}
+	async launch(options, operation) {
+		const deadlineMs = operation.deadlineMs ?? Date.now() + INTERNAL_LAUNCH_TIMEOUT_MS;
+		const timeout = Math.max(1, deadlineMs - Date.now());
+		try {
+			const launching = this.launchBrowser({
+				...options,
+				timeout: Math.min(options.timeout ?? timeout, timeout)
+			});
+			try {
+				return await raceWithContext(launching, operation);
+			} catch (error) {
+				await launching.then((handle) => handle.forceClose().catch(() => void 0), () => void 0);
+				throw error;
+			}
+		} catch (error) {
+			if (isMissingBrowserError(error)) throw new NodeRenderError(NodeRenderErrorCode.BrowserBinaryMissing, "Chromium executable is unavailable", {
+				stage: "browser_launch",
+				retryable: false,
+				cause: error
+			});
+			throw normalizeNodeRenderError(error, NodeRenderErrorCode.BrowserFailed, "Chromium launch failed", "browser_launch", true);
+		}
+	}
+};
+var PuppeteerBrowserHandle = class {
+	browser;
+	constructor(browser) {
+		this.browser = browser;
+	}
+	get connected() {
+		return this.browser.connected;
+	}
+	createBrowserContext(options) {
+		return this.browser.createBrowserContext(options);
+	}
+	close() {
+		return this.browser.close();
+	}
+	async forceClose() {
+		this.browser.process()?.kill("SIGKILL");
+		try {
+			await this.browser.disconnect();
+		} catch {}
+	}
+	on(event, handler) {
+		this.browser.on(event, handler);
+	}
+};
+function cleanupWithDeadline(cleanup, forceCleanup) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let closedGracefully = false;
+		const timeout = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			forceCleanup().then(() => {
+				if (closedGracefully) {
+					resolve();
+					return;
+				}
+				reject(new NodeRenderError(NodeRenderErrorCode.CleanupFailed, "Cleanup deadline exceeded", {
+					stage: "context_cleanup",
+					retryable: true
+				}));
+			}, reject);
+		}, INTERNAL_CLEANUP_TIMEOUT_MS);
+		cleanup.then(() => {
+			closedGracefully = true;
+			if (!settled) {
+				settled = true;
+				clearTimeout(timeout);
+				resolve();
+			}
+		}, (error) => {
+			if (!settled) {
+				settled = true;
+				clearTimeout(timeout);
+				forceCleanup().then(() => {
+					reject(new NodeRenderError(NodeRenderErrorCode.CleanupFailed, "Browser context cleanup failed", {
+						stage: "context_cleanup",
+						retryable: true,
+						cause: error
+					}));
+				}, reject);
+			}
+		});
+	});
+}
+function throwIfContextEnded(operation) {
+	if (operation.signal?.aborted === true) throw operationReason(operation.signal);
+	if (operation.deadlineMs !== void 0 && Date.now() >= operation.deadlineMs) throw new OperationDeadlineExceededError$1("render");
+}
+function requireSignal$1(operation) {
+	if (operation.signal === void 0) throw new OperationShutdownError$1("operation");
+	return operation.signal;
+}
+function isBrowserDisconnected(error) {
+	return error instanceof Error && (error.message.includes("disconnected") || error.message.includes("Target closed") || error.message.includes("Connection closed"));
+}
+function validatePositiveInteger$1(value, name) {
+	if (!Number.isInteger(value) || value <= 0) throw invalidNodeOptions(`${name} must be a positive integer`);
+}
+function validateNonNegativeInteger$1(value, name) {
+	if (!Number.isInteger(value) || value < 0) throw invalidNodeOptions(`${name} must be a non-negative integer`);
+}
+function isMissingBrowserError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.message.includes("Could not find Chrome") || error.message.includes("Browser was not found") || error.message.includes("executable doesn't exist");
+}
+//#endregion
+//#region src/status.ts
+const NodeConverterState = {
+	Open: "open",
+	Closing: "closing",
+	Closed: "closed",
+	CloseFailed: "close-failed"
+};
+//#endregion
+//#region src/upload-scheduler.ts
+var UploadScheduler = class {
+	concurrency;
+	maxQueueSize;
+	pending;
+	activeScopes;
+	idleResolvers;
+	active;
+	retainedBytes;
+	closePromise;
+	closeBehavior;
+	accepting;
+	constructor(options) {
+		this.concurrency = options.concurrency;
+		this.maxQueueSize = options.maxQueueSize;
+		this.pending = [];
+		this.activeScopes = /* @__PURE__ */ new Set();
+		this.idleResolvers = [];
+		this.active = 0;
+		this.retainedBytes = 0;
+		this.closePromise = void 0;
+		this.closeBehavior = void 0;
+		this.accepting = true;
+		validatePositiveInteger(this.concurrency, "upload.concurrency");
+		validateNonNegativeInteger(this.maxQueueSize, "upload.maxQueueSize");
+	}
+	schedule(uploader, image, operation) {
+		if (!this.accepting) return Promise.reject(new OperationShutdownError$1("upload_admission"));
+		if (this.active >= this.concurrency && this.pending.length >= this.maxQueueSize) return Promise.reject(queueError());
+		let scope;
+		try {
+			scope = new OperationScope(operation, "upload");
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		this.retainedBytes += image.data.byteLength;
+		return new Promise((resolve, reject) => {
+			let pending;
+			const abortWhileQueued = () => {
+				const index = this.pending.indexOf(pending);
+				if (index >= 0) {
+					this.pending.splice(index, 1);
+					pending.reject(operationReason(requireSignal(scope.context)));
+				}
+			};
+			pending = {
+				start: () => {
+					scope.context.signal?.removeEventListener("abort", abortWhileQueued);
+					this.activeScopes.add(scope);
+					this.startUnderlying(uploader, image, scope, resolve, reject);
+				},
+				reject: (error) => {
+					scope.context.signal?.removeEventListener("abort", abortWhileQueued);
+					scope.cleanup();
+					this.retainedBytes -= image.data.byteLength;
+					reject(error);
+				}
+			};
+			if (scope.context.signal?.aborted === true) {
+				pending.reject(operationReason(requireSignal(scope.context)));
+				return;
+			}
+			if (this.active < this.concurrency) {
+				this.active += 1;
+				pending.start();
+				return;
+			}
+			scope.context.signal?.addEventListener("abort", abortWhileQueued, { once: true });
+			this.pending.push(pending);
+		});
+	}
+	close(operation, behavior = "cancel") {
+		if (this.closePromise !== void 0) return this.closePromise;
+		const closeScope = new OperationScope(operation, "upload_close");
+		this.accepting = false;
+		this.closeBehavior = behavior;
+		if (behavior === "cancel") {
+			const shutdown = new OperationShutdownError$1("upload");
+			for (const pending of this.pending.splice(0)) pending.reject(shutdown);
+			for (const scope of this.activeScopes) scope.abortForShutdown("upload");
+		}
+		this.closePromise = raceWithContext(this.waitForIdle(), closeScope.context).catch((error) => {
+			this.closeBehavior = "cancel";
+			const shutdown = new OperationShutdownError$1("upload");
+			for (const pending of this.pending.splice(0)) pending.reject(shutdown);
+			for (const scope of this.activeScopes) scope.abortForShutdown("upload");
+			throw error;
+		}).finally(() => {
+			closeScope.cleanup();
+		});
+		return this.closePromise;
+	}
+	status() {
+		return Object.freeze({
+			accepting: this.accepting,
+			active: this.active,
+			queued: this.pending.length,
+			retainedBytes: this.retainedBytes
+		});
+	}
+	startUnderlying(uploader, image, scope, resolve, reject) {
+		Promise.resolve().then(() => uploader.upload(image, scope.context)).then((value) => {
+			resolve(value);
+			this.finishUnderlying(scope, image.data.byteLength);
+		}, (error) => {
+			reject(error);
+			this.finishUnderlying(scope, image.data.byteLength);
+		});
+	}
+	finishUnderlying(scope, byteLength) {
+		scope.cleanup();
+		this.activeScopes.delete(scope);
+		this.active -= 1;
+		this.retainedBytes -= byteLength;
+		const next = this.pending.shift();
+		if (next !== void 0 && this.closeBehavior !== "cancel") {
+			this.active += 1;
+			next.start();
+		} else if (next !== void 0) next.reject(new OperationShutdownError$1("upload"));
+		if (this.active === 0 && this.pending.length === 0) for (const resolve of this.idleResolvers.splice(0)) resolve();
+	}
+	waitForIdle() {
+		if (this.active === 0 && this.pending.length === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.idleResolvers.push(resolve);
+		});
+	}
+};
+var ScheduledSlackUploader = class {
+	scheduler;
+	uploader;
+	constructor(scheduler, uploader) {
+		this.scheduler = scheduler;
+		this.uploader = uploader;
+	}
+	upload(image, operation) {
+		return this.scheduler.schedule(this.uploader, image, operation);
+	}
+};
+function queueError() {
+	return new SlackUploadError("Slack upload queue is full", {
+		stage: SlackUploadStage.Admission,
+		code: "upload_queue_full",
+		retryable: true
+	});
+}
+function requireSignal(operation) {
+	if (operation.signal === void 0) throw new OperationShutdownError$1("upload");
+	return operation.signal;
+}
+function validatePositiveInteger(value, name) {
+	if (!Number.isInteger(value) || value <= 0) throw new RangeError(`${name} must be a positive integer`);
+}
+function validateNonNegativeInteger(value, name) {
+	if (!Number.isInteger(value) || value < 0) throw new RangeError(`${name} must be a non-negative integer`);
+}
+//#endregion
+//#region src/create-node-converter.ts
+const DEFAULT_CLOSE_TIMEOUT_MS = 5e3;
+const CORE_OPTION_KEYS = [
+	"capabilities",
+	"capabilityOverrides",
+	"overflow",
+	"strategy",
+	"enableMath",
+	"enableInlineMath",
+	"enableFrontmatter",
+	"mentionResolvers"
+];
+var ManagedNodeConverter = class {
+	converter;
+	runtime;
+	defaultUploader;
+	uploadScheduler;
+	warmupOperation;
+	activeScopes;
+	activeReceipts;
+	idleResolvers;
+	activeOperations;
+	closePromise;
+	state;
+	constructor(deps) {
+		this.converter = deps.converter;
+		this.runtime = deps.runtime;
+		this.defaultUploader = deps.defaultUploader;
+		this.uploadScheduler = deps.uploadScheduler;
+		this.warmupOperation = deps.warmupOperation;
+		this.activeScopes = /* @__PURE__ */ new Set();
+		this.activeReceipts = /* @__PURE__ */ new Map();
+		this.idleResolvers = [];
+		this.activeOperations = 0;
+		this.closePromise = void 0;
+		this.state = NodeConverterState.Open;
+	}
+	convert(markdown, options = {}) {
+		try {
+			const normalized = normalizeNodeConvertOptions(options);
+			return this.runTracked({
+				signal: normalized.signal,
+				timeoutMs: normalized.timeoutMs
+			}, (operation, receipts) => this.converter.convertWithContext(markdown, prepareConversionOptions(normalized, this.defaultUploader, this.uploadScheduler), operation, receipts));
+		} catch (error) {
+			return Promise.reject(normalizeConfigurationError(error));
+		}
+	}
+	convertToMessages(markdown, options = {}) {
+		try {
+			const normalized = normalizeNodeConvertOptions(options);
+			return this.runTracked({
+				signal: normalized.signal,
+				timeoutMs: normalized.timeoutMs
+			}, (operation, receipts) => this.converter.convertToMessagesWithContext(markdown, prepareConversionOptions(normalized, this.defaultUploader, this.uploadScheduler), operation, receipts));
+		} catch (error) {
+			return Promise.reject(normalizeConfigurationError(error));
+		}
+	}
+	warmup(options = {}) {
+		try {
+			return this.runTracked(options, (operation) => this.warmupOperation(operation));
+		} catch (error) {
+			return Promise.reject(normalizeConfigurationError(error));
+		}
+	}
+	close(options = {}) {
+		if (this.closePromise !== void 0) return this.closePromise;
+		let behavior;
+		let scope;
+		try {
+			validateCloseOptions(options);
+			behavior = options.behavior ?? "drain";
+			scope = createOperationScope({
+				signal: options.signal,
+				timeoutMs: options.timeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS
+			}, "close");
+		} catch (error) {
+			return Promise.reject(normalizeConfigurationError(error));
+		}
+		this.state = NodeConverterState.Closing;
+		if (behavior === "cancel") for (const active of this.activeScopes) active.abortForShutdown("conversion");
+		const closingReceipts = [...this.activeReceipts.values()];
+		this.closePromise = this.finishClose(scope, behavior, closingReceipts);
+		return this.closePromise;
+	}
+	status() {
+		return Object.freeze({
+			state: this.state,
+			activeOperations: this.activeOperations,
+			render: this.runtime.status(),
+			upload: this.uploadScheduler.status()
+		});
+	}
+	[Symbol.asyncDispose]() {
+		return this.close({
+			behavior: "cancel",
+			timeoutMs: DEFAULT_CLOSE_TIMEOUT_MS
+		});
+	}
+	runTracked(options, operation) {
+		if (this.state !== NodeConverterState.Open) return Promise.reject(new OperationShutdownError$1("conversion_admission"));
+		const scope = createOperationScope(options, "conversion");
+		const receipts = new RecordingReceiptCollector();
+		this.activeScopes.add(scope);
+		this.activeReceipts.set(scope, receipts);
+		this.activeOperations += 1;
+		const underlying = Promise.resolve().then(() => operation(scope.context, receipts));
+		underlying.then(() => {
+			receipts.settle();
+			this.finishTracked(scope);
+		}, () => {
+			receipts.settle();
+			this.finishTracked(scope);
+		});
+		return scope.race(underlying).catch((error) => {
+			throw lockReceiptSnapshot(attachReceipts(error, receipts.all(), receipts.settled()));
+		});
+	}
+	finishTracked(scope) {
+		scope.cleanup();
+		this.activeScopes.delete(scope);
+		this.activeReceipts.delete(scope);
+		this.activeOperations -= 1;
+		if (this.activeOperations === 0) for (const resolve of this.idleResolvers.splice(0)) resolve();
+	}
+	async finishClose(scope, behavior, closingReceipts) {
+		try {
+			await scope.race(this.waitForIdle());
+			await Promise.all([this.uploadScheduler.close(scope.context, behavior), this.runtime.close(scope.context, behavior)]);
+			this.state = NodeConverterState.Closed;
+		} catch (error) {
+			this.state = NodeConverterState.CloseFailed;
+			for (const active of this.activeScopes) active.abortForShutdown("conversion");
+			const cleanupContext = {
+				signal: void 0,
+				deadlineMs: Date.now() + DEFAULT_CLOSE_TIMEOUT_MS
+			};
+			Promise.allSettled([this.uploadScheduler.close(cleanupContext, "cancel"), this.runtime.close(cleanupContext, "cancel")]);
+			const receiptSnapshot = collectReceiptSnapshot(closingReceipts);
+			const settledReceipts = collectSettledReceipts(closingReceipts);
+			if (isOperationError(error) && error.code === OperationErrorCode$1.DeadlineExceeded) throw new NodeShutdownTimeoutError(this.status(), receiptSnapshot, settledReceipts);
+			throw attachReceipts(error, receiptSnapshot, settledReceipts);
+		} finally {
+			scope.cleanup();
+		}
+	}
+	waitForIdle() {
+		if (this.activeOperations === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.idleResolvers.push(resolve);
+		});
+	}
+};
+function createNodeConverter(options = {}) {
+	try {
+		validateNodeFactoryOptions(options);
+		const runtime = new PuppeteerRenderRuntime({
+			launcher: new PuppeteerBrowserLauncher(),
+			launchOptions: options.rendering?.launchOptions,
+			concurrency: options.rendering?.concurrency,
+			maxQueueSize: options.rendering?.maxQueueSize
+		});
+		const mermaidAssets = new LocalMermaidAssetLoader();
+		const katexAssets = new LocalKatexAssetLoader();
+		const builtInRenderers = [new MermaidRenderer({
+			...options.rendering?.mermaid,
+			runtime,
+			assets: mermaidAssets
+		}), new KatexRenderer({
+			...options.rendering?.math,
+			runtime,
+			assets: katexAssets
+		})];
+		const additionalRenderers = Object.freeze([...options.additionalRenderers ?? []]);
+		validateRendererIdentities(builtInRenderers, additionalRenderers);
+		const converter = createConverter({
+			...pickConversionDefaults(options),
+			enableMath: options.enableMath ?? true,
+			renderers: [...builtInRenderers, ...additionalRenderers]
+		});
+		const uploadScheduler = new UploadScheduler({
+			concurrency: options.upload?.concurrency ?? 2,
+			maxQueueSize: options.upload?.maxQueueSize ?? 16
+		});
+		return new ManagedNodeConverter({
+			converter,
+			runtime,
+			defaultUploader: options.uploader,
+			uploadScheduler,
+			warmupOperation: (operation) => runtime.run(async () => {
+				await Promise.all([
+					mermaidAssets.loadScript(),
+					katexAssets.loadScript(),
+					katexAssets.loadCss()
+				]);
+			}, operation)
+		});
+	} catch (error) {
+		if (isConfigurationError(error)) throw error;
+		throw new ConfigurationError$1(`Invalid slackmark-node configuration${error instanceof Error ? `: ${error.message}` : ""}`, {
+			code: "invalid_node_configuration",
+			stage: "configuration",
+			cause: error
+		});
+	}
+}
+function prepareConversionOptions(options, defaultUploader, scheduler) {
+	const { signal: _signal, timeoutMs: _timeoutMs, uploader: perCallUploader, ...conversionOptions } = options;
+	const uploader = perCallUploader ?? defaultUploader;
+	return {
+		...conversionOptions,
+		uploader: uploader === void 0 ? void 0 : new ScheduledSlackUploader(scheduler, uploader)
+	};
+}
+function pickConversionDefaults(options) {
+	return {
+		capabilities: options.capabilities,
+		capabilityOverrides: options.capabilityOverrides,
+		overflow: options.overflow,
+		strategy: options.strategy,
+		enableMath: options.enableMath,
+		enableInlineMath: options.enableInlineMath,
+		enableFrontmatter: options.enableFrontmatter,
+		mentionResolvers: options.mentionResolvers
+	};
+}
+function validateNodeFactoryOptions(options) {
+	validateKnownPlainObject(options, [
+		...CORE_OPTION_KEYS,
+		"rendering",
+		"upload",
+		"additionalRenderers",
+		"uploader"
+	], "options");
+	if (options.rendering !== void 0) {
+		validateKnownPlainObject(options.rendering, [
+			"concurrency",
+			"maxQueueSize",
+			"launchOptions",
+			"mermaid",
+			"math"
+		], "rendering");
+		if (options.rendering.mermaid !== void 0) validateKnownPlainObject(options.rendering.mermaid, [
+			"theme",
+			"backgroundColor",
+			"deviceScaleFactor",
+			"maxSourceChars",
+			"maxEdges",
+			"maxOutputBytes",
+			"maxWidth",
+			"maxHeight"
+		], "rendering.mermaid");
+		if (options.rendering.math !== void 0) validateKnownPlainObject(options.rendering.math, [
+			"backgroundColor",
+			"deviceScaleFactor",
+			"fontSizePx",
+			"paddingPx",
+			"maxExpand",
+			"maxSize",
+			"maxSourceChars",
+			"maxOutputBytes",
+			"maxWidth",
+			"maxHeight"
+		], "rendering.math");
+	}
+	if (options.upload !== void 0) validateKnownPlainObject(options.upload, ["concurrency", "maxQueueSize"], "upload");
+	resolveCapabilities(options.capabilities, options.capabilityOverrides);
+	if (options.enableMath !== void 0 && typeof options.enableMath !== "boolean") throw new ConfigurationError$1("enableMath must be boolean", {
+		code: "invalid_option",
+		stage: "configuration"
+	});
+	if (options.enableInlineMath !== void 0 && typeof options.enableInlineMath !== "boolean") throw new ConfigurationError$1("enableInlineMath must be boolean", {
+		code: "invalid_option",
+		stage: "configuration"
+	});
+	if (options.enableFrontmatter !== void 0 && typeof options.enableFrontmatter !== "boolean") throw new ConfigurationError$1("enableFrontmatter must be boolean", {
+		code: "invalid_option",
+		stage: "configuration"
+	});
+	if (options.overflow !== void 0 && options.overflow !== "degrade" && options.overflow !== "split") throw new ConfigurationError$1("overflow must be \"degrade\" or \"split\"", {
+		code: "invalid_option",
+		stage: "configuration"
+	});
+	if (options.strategy !== void 0 && options.strategy !== "rich-text-first" && options.strategy !== "markdown-block") throw new ConfigurationError$1("strategy must be \"rich-text-first\" or \"markdown-block\"", {
+		code: "invalid_option",
+		stage: "configuration"
+	});
+	validateMentionResolvers(options.mentionResolvers);
+	if (options.additionalRenderers !== void 0 && !Array.isArray(options.additionalRenderers)) throw new ConfigurationError$1("additionalRenderers must be an array", {
+		code: "invalid_renderer",
+		stage: "configuration"
+	});
+	validateUploader(options.uploader);
+}
+function validateMentionResolvers(value) {
+	if (value === void 0) return;
+	validateKnownPlainObject(value, ["resolveUser", "resolveChannel"], "mentionResolvers");
+	try {
+		const resolveUser = Reflect.get(value, "resolveUser");
+		const resolveChannel = Reflect.get(value, "resolveChannel");
+		if (resolveUser !== void 0 && typeof resolveUser !== "function" || resolveChannel !== void 0 && typeof resolveChannel !== "function") throw new TypeError("mention resolvers must be functions");
+	} catch (cause) {
+		throw new ConfigurationError$1("mentionResolvers is invalid", {
+			code: "invalid_option",
+			stage: "configuration",
+			cause
+		});
+	}
+}
+function normalizeNodeConvertOptions(options) {
+	const normalized = snapshotNodeOptions(options, [
+		...CORE_OPTION_KEYS,
+		"uploader",
+		"signal",
+		"timeoutMs"
+	], "conversion options");
+	validateUploader(normalized.uploader);
+	return normalized;
+}
+function validateCloseOptions(options) {
+	validateKnownPlainObject(options, [
+		"behavior",
+		"signal",
+		"timeoutMs"
+	], "close options");
+	if (options.behavior !== void 0 && options.behavior !== "drain" && options.behavior !== "cancel") throw new ConfigurationError$1("close.behavior must be \"drain\" or \"cancel\"", {
+		code: "invalid_close_behavior",
+		stage: "configuration"
+	});
+}
+function validateKnownPlainObject(value, allowed, label) {
+	if (!isPlainObject(value)) throw new ConfigurationError$1(`${label} must be a plain object`, {
+		code: "invalid_option",
+		stage: "configuration"
+	});
+	const allowedKeys = new Set(allowed);
+	for (const key of Object.keys(value)) if (!allowedKeys.has(key)) throw new ConfigurationError$1(`Unknown ${label} option: ${key}`, {
+		code: "invalid_option",
+		stage: "configuration"
+	});
+}
+function validateUploader(uploader) {
+	if (uploader === void 0) return;
+	try {
+		if (typeof uploader !== "object" && typeof uploader !== "function" || uploader === null || typeof Reflect.get(uploader, "upload") !== "function") throw new TypeError("upload must be a function");
+	} catch (cause) {
+		throw new ConfigurationError$1("uploader is invalid", {
+			code: "invalid_uploader",
+			stage: "configuration",
+			cause
+		});
+	}
+}
+function validateRendererIdentities(builtIns, additional) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const renderer of [...builtIns, ...additional]) {
+		let id;
+		let output;
+		let canRender;
+		let render;
+		try {
+			id = Reflect.get(renderer, "id");
+			output = Reflect.get(renderer, "output");
+			canRender = Reflect.get(renderer, "canRender");
+			render = Reflect.get(renderer, "render");
+		} catch (cause) {
+			throw new ConfigurationError$1("Renderer id could not be read", {
+				code: "invalid_renderer",
+				stage: "configuration",
+				cause
+			});
+		}
+		if (typeof id !== "string" || id.length === 0 || output !== "url" && output !== "bytes" && output !== "both" || typeof canRender !== "function" || typeof render !== "function") throw new ConfigurationError$1("Renderer descriptor is invalid", {
+			code: "invalid_renderer",
+			stage: "configuration"
+		});
+		if (ids.has(id)) throw new ConfigurationError$1(`Duplicate renderer id: ${id}`, {
+			code: "duplicate_renderer_id",
+			stage: "configuration"
+		});
+		ids.add(id);
+	}
+}
+function collectReceiptSnapshot(collectors) {
+	return Object.freeze(collectors.flatMap((collector) => collector.all()));
+}
+async function collectSettledReceipts(collectors) {
+	try {
+		const settled = await Promise.all(collectors.map((collector) => collector.settled()));
+		return Object.freeze(settled.flat());
+	} catch {
+		return collectReceiptSnapshot(collectors);
+	}
+}
+function normalizeConfigurationError(error) {
+	return isConfigurationError(error) ? error : new ConfigurationError$1("Node converter options could not be read", {
+		code: "invalid_option",
+		stage: "configuration",
+		cause: error
+	});
+}
+//#endregion
+export { ConfigurationError, NodeConverterState, NodeRenderError, NodeRenderErrorCode, NodeRenderStage, NodeShutdownTimeoutError, OperationAbortedError, OperationDeadlineExceededError, OperationError, OperationErrorCode, OperationShutdownError, createNodeConverter };
+
+//# sourceMappingURL=index.js.map