@pixelzx/genesis 2026.5.5-3 → 2026.5.5-5

package/dist/web-media-PnHEx5HT.js

@@ -0,0 +1,715 @@
+import { r as lowercasePreservingWhitespace } from "./string-coerce-C1IzJjqi.js";
+import { m as resolveUserPath } from "./utils-DaGfogP-.js";
+import { _ as resolveStateDir } from "./paths-DmR9mjUX.js";
+import { a as shouldLogVerbose, r as logVerbose } from "./globals-C5IxqXPj.js";
+import { c as mimeTypeFromFilePath, l as normalizeMimeType, m as maxBytesForKind, n as extensionForMime, r as getFileExtension, s as kindFromMime, t as detectMime } from "./mime-dYER0fWW.js";
+import { c as optimizeImageToPng, i as convertHeicToJpeg, l as resizeToJpeg, o as hasAlphaChannel } from "./image-ops-DXau4yMa.js";
+import { d as readLocalFileSafely, s as openFileWithinRoot, t as SafeOpenError } from "./fs-safe-Dbuf-IZV.js";
+import { a as safeFileURLToPath, t as assertNoWindowsNetworkPath } from "./local-file-access-DgmtufHS.js";
+import { i as MediaReferenceError, n as assertLocalMediaAllowed, s as resolveInboundMediaReference, t as LocalMediaAccessError } from "./local-media-access-DG8GtihW.js";
+import { n as fetchRemoteMedia } from "./fetch-D3OWRWAX.js";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+//#region src/canvas-host/file-resolver.ts
+function normalizeUrlPath(rawPath) {
+	const decoded = decodeURIComponent(rawPath || "/");
+	const normalized = path.posix.normalize(decoded);
+	return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+async function resolveFileWithinRoot(rootReal, urlPath) {
+	const normalized = normalizeUrlPath(urlPath);
+	const rel = normalized.replace(/^\/+/, "");
+	if (rel.split("/").some((p) => p === "..")) return null;
+	const tryOpen = async (relative) => {
+		try {
+			return await openFileWithinRoot({
+				rootDir: rootReal,
+				relativePath: relative
+			});
+		} catch (err) {
+			if (err instanceof SafeOpenError) return null;
+			throw err;
+		}
+	};
+	if (normalized.endsWith("/")) return await tryOpen(path.posix.join(rel, "index.html"));
+	const candidate = path.join(rootReal, rel);
+	try {
+		const st = await fs.lstat(candidate);
+		if (st.isSymbolicLink()) return null;
+		if (st.isDirectory()) return await tryOpen(path.posix.join(rel, "index.html"));
+	} catch {}
+	return await tryOpen(rel);
+}
+//#endregion
+//#region src/canvas-host/a2ui.ts
+const A2UI_PATH = "/__genesis__/a2ui";
+const CANVAS_HOST_PATH = "/__genesis__/canvas";
+const CANVAS_WS_PATH = "/__genesis__/ws";
+let cachedA2uiRootReal;
+let resolvingA2uiRoot = null;
+let cachedA2uiResolvedAtMs = 0;
+const A2UI_ROOT_RETRY_NULL_AFTER_MS = 1e4;
+async function resolveA2uiRoot() {
+	const here = path.dirname(fileURLToPath(import.meta.url));
+	const entryDir = process.argv[1] ? path.dirname(path.resolve(process.argv[1])) : null;
+	const candidates = [
+		path.resolve(here, "a2ui"),
+		path.resolve(here, "canvas-host/a2ui"),
+		path.resolve(here, "../canvas-host/a2ui"),
+		...entryDir ? [
+			path.resolve(entryDir, "a2ui"),
+			path.resolve(entryDir, "canvas-host/a2ui"),
+			path.resolve(entryDir, "../canvas-host/a2ui")
+		] : [],
+		path.resolve(here, "../../src/canvas-host/a2ui"),
+		path.resolve(here, "../src/canvas-host/a2ui"),
+		path.resolve(process.cwd(), "src/canvas-host/a2ui"),
+		path.resolve(process.cwd(), "dist/canvas-host/a2ui")
+	];
+	if (process.execPath) candidates.unshift(path.resolve(path.dirname(process.execPath), "a2ui"));
+	for (const dir of candidates) try {
+		const indexPath = path.join(dir, "index.html");
+		const bundlePath = path.join(dir, "a2ui.bundle.js");
+		await fs.stat(indexPath);
+		await fs.stat(bundlePath);
+		return dir;
+	} catch {}
+	return null;
+}
+async function resolveA2uiRootReal() {
+	if (cachedA2uiRootReal !== void 0 && (cachedA2uiRootReal !== null || Date.now() - cachedA2uiResolvedAtMs < A2UI_ROOT_RETRY_NULL_AFTER_MS)) return cachedA2uiRootReal;
+	if (!resolvingA2uiRoot) resolvingA2uiRoot = (async () => {
+		const root = await resolveA2uiRoot();
+		cachedA2uiRootReal = root ? await fs.realpath(root) : null;
+		cachedA2uiResolvedAtMs = Date.now();
+		resolvingA2uiRoot = null;
+		return cachedA2uiRootReal;
+	})();
+	return resolvingA2uiRoot;
+}
+function injectCanvasLiveReload(html) {
+	const snippet = `
+<script>
+(() => {
+  // Cross-platform action bridge helper.
+  // Works on:
+  // - iOS: window.webkit.messageHandlers.genesisCanvasA2UIAction.postMessage(...)
+  // - Android: window.genesisCanvasA2UIAction.postMessage(...)
+  const handlerNames = ["genesisCanvasA2UIAction"];
+  function postToNode(payload) {
+    try {
+      const raw = typeof payload === "string" ? payload : JSON.stringify(payload);
+      for (const name of handlerNames) {
+        const iosHandler = globalThis.webkit?.messageHandlers?.[name];
+        if (iosHandler && typeof iosHandler.postMessage === "function") {
+          iosHandler.postMessage(raw);
+          return true;
+        }
+        const androidHandler = globalThis[name];
+        if (androidHandler && typeof androidHandler.postMessage === "function") {
+          // Important: call as a method on the interface object (binding matters on Android WebView).
+          androidHandler.postMessage(raw);
+          return true;
+        }
+      }
+    } catch {}
+    return false;
+  }
+  function sendUserAction(userAction) {
+    const id =
+      (userAction && typeof userAction.id === "string" && userAction.id.trim()) ||
+      (globalThis.crypto?.randomUUID?.() ?? String(Date.now()));
+    const action = { ...userAction, id };
+    return postToNode({ userAction: action });
+  }
+  globalThis.Genesis = globalThis.Genesis ?? {};
+  globalThis.Genesis.postMessage = postToNode;
+  globalThis.Genesis.sendUserAction = sendUserAction;
+  globalThis.genesisPostMessage = postToNode;
+  globalThis.genesisSendUserAction = sendUserAction;
+
+  try {
+    const cap = new URLSearchParams(location.search).get("oc_cap");
+    const proto = location.protocol === "https:" ? "wss" : "ws";
+    const capQuery = cap ? "?oc_cap=" + encodeURIComponent(cap) : "";
+    const ws = new WebSocket(proto + "://" + location.host + ${JSON.stringify(CANVAS_WS_PATH)} + capQuery);
+    ws.onmessage = (ev) => {
+      if (String(ev.data || "") === "reload") location.reload();
+    };
+  } catch {}
+})();
+<\/script>
+`.trim();
+	const idx = lowercasePreservingWhitespace(html).lastIndexOf("</body>");
+	if (idx >= 0) return `${html.slice(0, idx)}\n${snippet}\n${html.slice(idx)}`;
+	return `${html}\n${snippet}\n`;
+}
+async function handleA2uiHttpRequest(req, res) {
+	const urlRaw = req.url;
+	if (!urlRaw) return false;
+	const url = new URL(urlRaw, "http://localhost");
+	const basePath = url.pathname === "/__genesis__/a2ui" || url.pathname.startsWith(`/__genesis__/a2ui/`) ? A2UI_PATH : void 0;
+	if (!basePath) return false;
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		res.statusCode = 405;
+		res.setHeader("Content-Type", "text/plain; charset=utf-8");
+		res.end("Method Not Allowed");
+		return true;
+	}
+	const a2uiRootReal = await resolveA2uiRootReal();
+	if (!a2uiRootReal) {
+		res.statusCode = 503;
+		res.setHeader("Content-Type", "text/plain; charset=utf-8");
+		res.end("A2UI assets not found");
+		return true;
+	}
+	const result = await resolveFileWithinRoot(a2uiRootReal, url.pathname.slice(basePath.length) || "/");
+	if (!result) {
+		res.statusCode = 404;
+		res.setHeader("Content-Type", "text/plain; charset=utf-8");
+		res.end("not found");
+		return true;
+	}
+	try {
+		const lower = lowercasePreservingWhitespace(result.realPath);
+		const mime = lower.endsWith(".html") || lower.endsWith(".htm") ? "text/html" : await detectMime({ filePath: result.realPath }) ?? "application/octet-stream";
+		res.setHeader("Cache-Control", "no-store");
+		if (req.method === "HEAD") {
+			res.setHeader("Content-Type", mime === "text/html" ? "text/html; charset=utf-8" : mime);
+			res.end();
+			return true;
+		}
+		if (mime === "text/html") {
+			const buf = await result.handle.readFile({ encoding: "utf8" });
+			res.setHeader("Content-Type", "text/html; charset=utf-8");
+			res.end(injectCanvasLiveReload(buf));
+			return true;
+		}
+		res.setHeader("Content-Type", mime);
+		res.end(await result.handle.readFile());
+		return true;
+	} finally {
+		await result.handle.close().catch(() => {});
+	}
+}
+//#endregion
+//#region src/gateway/canvas-documents.ts
+const CANVAS_DOCUMENTS_DIR_NAME = "documents";
+function isPdfPathLike(value) {
+	return /\.pdf(?:[?#].*)?$/i.test(value.trim());
+}
+function buildPdfWrapper(url) {
+	const escaped = escapeHtml(url);
+	return `<!doctype html><html><body style="margin:0;background:#e5e7eb;"><object data="${escaped}" type="application/pdf" style="width:100%;height:100vh;border:0;"><iframe src="${escaped}" style="width:100%;height:100vh;border:0;"></iframe><p style="padding:16px;font:14px system-ui,sans-serif;">Unable to render PDF preview. <a href="${escaped}" target="_blank" rel="noopener noreferrer">Open PDF</a>.</p></object></body></html>`;
+}
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function normalizeLogicalPath(value) {
+	const parts = value.replaceAll("\\", "/").replace(/^\/+/, "").split("/").filter(Boolean);
+	if (parts.length === 0 || parts.some((part) => part === "." || part === "..")) throw new Error("canvas document logicalPath invalid");
+	return parts.join("/");
+}
+function canvasDocumentId() {
+	return `cv_${randomUUID().replaceAll("-", "")}`;
+}
+function normalizeCanvasDocumentId(value) {
+	const normalized = value.trim();
+	if (!normalized || normalized === "." || normalized === ".." || !/^[A-Za-z0-9._-]+$/.test(normalized)) throw new Error("canvas document id invalid");
+	return normalized;
+}
+function resolveCanvasRootDir(rootDir, stateDir = resolveStateDir()) {
+	const resolved = rootDir?.trim() ? resolveUserPath(rootDir) : path.join(stateDir, "canvas");
+	return path.resolve(resolved);
+}
+function resolveCanvasDocumentsDir(rootDir, stateDir = resolveStateDir()) {
+	return path.join(resolveCanvasRootDir(rootDir, stateDir), CANVAS_DOCUMENTS_DIR_NAME);
+}
+function resolveCanvasDocumentDir(documentId, options) {
+	return path.join(resolveCanvasDocumentsDir(options?.rootDir, options?.stateDir), documentId);
+}
+function buildCanvasDocumentEntryUrl(documentId, entrypoint) {
+	const encodedEntrypoint = normalizeLogicalPath(entrypoint).split("/").map((segment) => encodeURIComponent(segment)).join("/");
+	return `${CANVAS_HOST_PATH}/${CANVAS_DOCUMENTS_DIR_NAME}/${encodeURIComponent(documentId)}/${encodedEntrypoint}`;
+}
+function resolveCanvasHttpPathToLocalPath(requestPath, options) {
+	const trimmed = requestPath.trim();
+	const prefix = `${CANVAS_HOST_PATH}/${CANVAS_DOCUMENTS_DIR_NAME}/`;
+	if (!trimmed.startsWith(prefix)) return null;
+	const segments = trimmed.replace(/[?#].*$/, "").slice(prefix.length).split("/").map((segment) => {
+		try {
+			return decodeURIComponent(segment);
+		} catch {
+			return segment;
+		}
+	}).filter(Boolean);
+	if (segments.length < 2) return null;
+	const [rawDocumentId, ...entrySegments] = segments;
+	try {
+		const documentId = normalizeCanvasDocumentId(rawDocumentId);
+		const normalizedEntrypoint = normalizeLogicalPath(entrySegments.join("/"));
+		const documentsDir = path.resolve(resolveCanvasDocumentsDir(options?.rootDir, options?.stateDir));
+		const candidatePath = path.resolve(resolveCanvasDocumentDir(documentId, options), normalizedEntrypoint);
+		if (!(candidatePath === documentsDir || candidatePath.startsWith(`${documentsDir}${path.sep}`))) return null;
+		return candidatePath;
+	} catch {
+		return null;
+	}
+}
+async function writeManifest(rootDir, manifest) {
+	await fs.writeFile(path.join(rootDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+async function copyAssets(rootDir, assets, workspaceDir) {
+	const copied = [];
+	for (const asset of assets ?? []) {
+		const logicalPath = normalizeLogicalPath(asset.logicalPath);
+		const sourcePath = asset.sourcePath.startsWith("~") ? resolveUserPath(asset.sourcePath) : path.isAbsolute(asset.sourcePath) ? path.resolve(asset.sourcePath) : path.resolve(workspaceDir, asset.sourcePath);
+		const destination = path.join(rootDir, logicalPath);
+		await fs.mkdir(path.dirname(destination), { recursive: true });
+		await fs.copyFile(sourcePath, destination);
+		copied.push({
+			logicalPath,
+			...asset.contentType ? { contentType: asset.contentType } : {}
+		});
+	}
+	return copied;
+}
+async function materializeEntrypoint(rootDir, input, workspaceDir) {
+	const entrypoint = input.entrypoint;
+	if (!entrypoint) throw new Error("canvas document entrypoint required");
+	if (entrypoint.type === "html") {
+		const fileName = "index.html";
+		await fs.writeFile(path.join(rootDir, fileName), entrypoint.value, "utf8");
+		return {
+			localEntrypoint: fileName,
+			entryUrl: buildCanvasDocumentEntryUrl(path.basename(rootDir), fileName)
+		};
+	}
+	if (entrypoint.type === "url") {
+		if (input.kind === "document" && isPdfPathLike(entrypoint.value)) {
+			const fileName = "index.html";
+			await fs.writeFile(path.join(rootDir, fileName), buildPdfWrapper(entrypoint.value), "utf8");
+			return {
+				localEntrypoint: fileName,
+				externalUrl: entrypoint.value,
+				entryUrl: buildCanvasDocumentEntryUrl(path.basename(rootDir), fileName)
+			};
+		}
+		return {
+			externalUrl: entrypoint.value,
+			entryUrl: entrypoint.value
+		};
+	}
+	const resolvedPath = entrypoint.value.startsWith("~") ? resolveUserPath(entrypoint.value) : path.isAbsolute(entrypoint.value) ? path.resolve(entrypoint.value) : path.resolve(workspaceDir, entrypoint.value);
+	if (input.kind === "image" || input.kind === "video_asset") {
+		const copiedName = path.basename(resolvedPath);
+		await fs.copyFile(resolvedPath, path.join(rootDir, copiedName));
+		const wrapper = input.kind === "image" ? `<!doctype html><html><body style="margin:0;background:#0f172a;display:flex;align-items:center;justify-content:center;"><img src="${escapeHtml(copiedName)}" style="max-width:100%;max-height:100vh;object-fit:contain;" /></body></html>` : `<!doctype html><html><body style="margin:0;background:#0f172a;"><video src="${escapeHtml(copiedName)}" controls autoplay style="width:100%;height:100vh;object-fit:contain;background:#000;"></video></body></html>`;
+		await fs.writeFile(path.join(rootDir, "index.html"), wrapper, "utf8");
+		return {
+			localEntrypoint: "index.html",
+			entryUrl: buildCanvasDocumentEntryUrl(path.basename(rootDir), "index.html")
+		};
+	}
+	const fileName = path.basename(resolvedPath);
+	await fs.copyFile(resolvedPath, path.join(rootDir, fileName));
+	if (input.kind === "document" && isPdfPathLike(fileName)) {
+		await fs.writeFile(path.join(rootDir, "index.html"), buildPdfWrapper(fileName), "utf8");
+		return {
+			localEntrypoint: "index.html",
+			entryUrl: buildCanvasDocumentEntryUrl(path.basename(rootDir), "index.html")
+		};
+	}
+	return {
+		localEntrypoint: fileName,
+		entryUrl: buildCanvasDocumentEntryUrl(path.basename(rootDir), fileName)
+	};
+}
+async function createCanvasDocument(input, options) {
+	const workspaceDir = options?.workspaceDir ?? process.cwd();
+	const id = input.id?.trim() ? normalizeCanvasDocumentId(input.id) : canvasDocumentId();
+	const rootDir = resolveCanvasDocumentDir(id, {
+		stateDir: options?.stateDir,
+		rootDir: options?.canvasRootDir
+	});
+	await fs.rm(rootDir, {
+		recursive: true,
+		force: true
+	}).catch(() => void 0);
+	await fs.mkdir(rootDir, { recursive: true });
+	const assets = await copyAssets(rootDir, input.assets, workspaceDir);
+	const entry = await materializeEntrypoint(rootDir, input, workspaceDir);
+	const manifest = {
+		id,
+		kind: input.kind,
+		...input.title?.trim() ? { title: input.title.trim() } : {},
+		...typeof input.preferredHeight === "number" ? { preferredHeight: input.preferredHeight } : {},
+		...input.surface ? { surface: input.surface } : {},
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		entryUrl: entry.entryUrl,
+		...entry.localEntrypoint ? { localEntrypoint: entry.localEntrypoint } : {},
+		...entry.externalUrl ? { externalUrl: entry.externalUrl } : {},
+		assets
+	};
+	await writeManifest(rootDir, manifest);
+	return manifest;
+}
+//#endregion
+//#region src/media/web-media.ts
+async function resolveMediaStoreUriToPath(mediaUrl) {
+	if (!/^media:\/\//i.test(mediaUrl)) return null;
+	try {
+		return (await resolveInboundMediaReference(mediaUrl))?.physicalPath ?? null;
+	} catch (err) {
+		if (err instanceof MediaReferenceError) throw new LocalMediaAccessError(err.code, err.message, { cause: err });
+		throw err;
+	}
+}
+function resolveWebMediaOptions(params) {
+	if (typeof params.maxBytesOrOptions === "number" || params.maxBytesOrOptions === void 0) return {
+		maxBytes: params.maxBytesOrOptions,
+		optimizeImages: params.optimizeImages,
+		ssrfPolicy: params.options?.ssrfPolicy,
+		localRoots: params.options?.localRoots
+	};
+	return {
+		...params.maxBytesOrOptions,
+		optimizeImages: params.optimizeImages ? params.maxBytesOrOptions.optimizeImages ?? true : false
+	};
+}
+const HEIC_MIME_RE = /^image\/hei[cf]$/i;
+const HEIC_EXT_RE = /\.(heic|heif)$/i;
+const WINDOWS_DRIVE_RE = /^[A-Za-z]:[\\/]/;
+const HOST_READ_ALLOWED_DOCUMENT_MIMES = new Set([
+	"application/msword",
+	"application/pdf",
+	"application/vnd.ms-excel",
+	"application/vnd.ms-powerpoint",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	"text/csv",
+	"text/markdown"
+]);
+const HOST_READ_TEXT_PLAIN_ALIASES = new Set(["text/csv", "text/markdown"]);
+const MB = 1024 * 1024;
+function getTextStats(text) {
+	if (!text) return { printableRatio: 0 };
+	let printable = 0;
+	let control = 0;
+	for (const char of text) {
+		const code = char.codePointAt(0) ?? 0;
+		if (code === 9 || code === 10 || code === 13 || code === 32) {
+			printable += 1;
+			continue;
+		}
+		if (code < 32 || code >= 127 && code <= 159) {
+			control += 1;
+			continue;
+		}
+		printable += 1;
+	}
+	const total = printable + control;
+	if (total === 0) return { printableRatio: 0 };
+	return { printableRatio: printable / total };
+}
+function hasSingleByteTextShape(buffer) {
+	if (buffer.length === 0) return true;
+	let asciiText = 0;
+	let control = 0;
+	for (const byte of buffer) {
+		if (byte === 9 || byte === 10 || byte === 13 || byte >= 32 && byte <= 126) {
+			asciiText += 1;
+			continue;
+		}
+		if (byte < 32 || byte === 127) control += 1;
+	}
+	const total = buffer.length;
+	const highBytes = total - asciiText - control;
+	return control === 0 && asciiText / total >= .7 && highBytes / total <= .3;
+}
+function decodeHostReadText(buffer) {
+	if (buffer.length === 0) return "";
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+	} catch {
+		if (!hasSingleByteTextShape(buffer)) return;
+		return new TextDecoder("latin1").decode(buffer);
+	}
+}
+function isValidatedHostReadText(buffer) {
+	if (!buffer) return false;
+	if (buffer.length === 0) return true;
+	const text = decodeHostReadText(buffer);
+	if (text === void 0) return false;
+	const { printableRatio } = getTextStats(text);
+	return printableRatio > .95;
+}
+function formatMb(bytes, digits = 2) {
+	return (bytes / MB).toFixed(digits);
+}
+function formatCapLimit(label, cap, size) {
+	return `${label} exceeds ${formatMb(cap, 0)}MB limit (got ${formatMb(size)}MB)`;
+}
+function formatCapReduce(label, cap, size) {
+	return `${label} could not be reduced below ${formatMb(cap, 0)}MB (got ${formatMb(size)}MB)`;
+}
+function isHeicSource(opts) {
+	if (opts.contentType && HEIC_MIME_RE.test(opts.contentType.trim())) return true;
+	if (opts.fileName && HEIC_EXT_RE.test(opts.fileName.trim())) return true;
+	return false;
+}
+function assertHostReadMediaAllowed(params) {
+	const declaredMime = normalizeMimeType(mimeTypeFromFilePath(params.filePath));
+	const normalizedMime = normalizeMimeType(params.contentType);
+	if (declaredMime && HOST_READ_TEXT_PLAIN_ALIASES.has(declaredMime)) {
+		if (!params.sniffedContentType && params.buffer && isValidatedHostReadText(params.buffer)) return;
+		throw new LocalMediaAccessError("path-not-allowed", "hostReadCapability permits only validated plain-text CSV/Markdown documents for local reads");
+	}
+	const sniffedKind = kindFromMime(params.sniffedContentType);
+	if (sniffedKind === "image" || sniffedKind === "audio" || sniffedKind === "video") return;
+	const sniffedMime = normalizeMimeType(params.sniffedContentType);
+	if (sniffedKind === "document" && sniffedMime && HOST_READ_ALLOWED_DOCUMENT_MIMES.has(sniffedMime)) return;
+	if (sniffedMime === "application/x-cfb" && [
+		".doc",
+		".ppt",
+		".xls"
+	].includes(getFileExtension(params.filePath) ?? "")) return;
+	if (!sniffedMime && normalizedMime && HOST_READ_TEXT_PLAIN_ALIASES.has(normalizedMime) && params.buffer && isValidatedHostReadText(params.buffer)) return;
+	if (params.kind === "document" && normalizedMime && HOST_READ_ALLOWED_DOCUMENT_MIMES.has(normalizedMime)) throw new LocalMediaAccessError("path-not-allowed", `Host-local media sends require buffer-verified media/document types (got fallback ${normalizedMime}).`);
+	throw new LocalMediaAccessError("path-not-allowed", `Host-local media sends only allow buffer-verified images, audio, video, PDF, and Office documents (got ${sniffedMime ?? normalizedMime ?? "unknown"}).`);
+}
+function toJpegFileName(fileName) {
+	if (!fileName) return;
+	const trimmed = fileName.trim();
+	if (!trimmed) return fileName;
+	const parsed = path.parse(trimmed);
+	if (!parsed.ext || HEIC_EXT_RE.test(parsed.ext)) return path.format({
+		dir: parsed.dir,
+		name: parsed.name || trimmed,
+		ext: ".jpg"
+	});
+	return path.format({
+		dir: parsed.dir,
+		name: parsed.name,
+		ext: ".jpg"
+	});
+}
+function logOptimizedImage(params) {
+	if (!shouldLogVerbose()) return;
+	if (params.optimized.optimizedSize >= params.originalSize) return;
+	if (params.optimized.format === "png") {
+		logVerbose(`Optimized PNG (preserving alpha) from ${formatMb(params.originalSize)}MB to ${formatMb(params.optimized.optimizedSize)}MB (side<=${params.optimized.resizeSide}px)`);
+		return;
+	}
+	logVerbose(`Optimized media from ${formatMb(params.originalSize)}MB to ${formatMb(params.optimized.optimizedSize)}MB (side<=${params.optimized.resizeSide}px, q=${params.optimized.quality})`);
+}
+async function optimizeImageWithFallback(params) {
+	const { buffer, cap, meta } = params;
+	if ((meta?.contentType === "image/png" || meta?.fileName?.toLowerCase().endsWith(".png")) && await hasAlphaChannel(buffer)) {
+		const optimized = await optimizeImageToPng(buffer, cap);
+		if (optimized.buffer.length <= cap) return {
+			...optimized,
+			format: "png"
+		};
+		if (shouldLogVerbose()) logVerbose(`PNG with alpha still exceeds ${formatMb(cap, 0)}MB after optimization; falling back to JPEG`);
+	}
+	return {
+		...await optimizeImageToJpeg(buffer, cap, meta),
+		format: "jpeg"
+	};
+}
+async function loadWebMediaInternal(mediaUrl, options = {}) {
+	const { maxBytes, optimizeImages = true, ssrfPolicy, proxyUrl, fetchImpl, requestInit, trustExplicitProxyDns, workspaceDir, localRoots, sandboxValidated = false, readFile: readFileOverride, hostReadCapability = false } = options;
+	if (!/^\s*media:\/\//i.test(mediaUrl)) mediaUrl = mediaUrl.replace(/^\s*MEDIA\s*:\s*/i, "");
+	mediaUrl = await resolveMediaStoreUriToPath(mediaUrl) ?? mediaUrl;
+	if (mediaUrl.startsWith("file://")) try {
+		mediaUrl = safeFileURLToPath(mediaUrl);
+	} catch (err) {
+		throw new LocalMediaAccessError("invalid-file-url", err.message, { cause: err });
+	}
+	mediaUrl = resolveCanvasHttpPathToLocalPath(mediaUrl) ?? mediaUrl;
+	const optimizeAndClampImage = async (buffer, cap, meta) => {
+		const originalSize = buffer.length;
+		const optimized = await optimizeImageWithFallback({
+			buffer,
+			cap,
+			meta
+		});
+		logOptimizedImage({
+			originalSize,
+			optimized
+		});
+		if (optimized.buffer.length > cap) throw new Error(formatCapReduce("Media", cap, optimized.buffer.length));
+		const contentType = optimized.format === "png" ? "image/png" : "image/jpeg";
+		const fileName = optimized.format === "jpeg" && meta && isHeicSource(meta) ? toJpegFileName(meta.fileName) : meta?.fileName;
+		return {
+			buffer: optimized.buffer,
+			contentType,
+			kind: "image",
+			fileName
+		};
+	};
+	const clampAndFinalize = async (params) => {
+		const cap = maxBytes !== void 0 ? maxBytes : maxBytesForKind(params.kind ?? "document");
+		if (params.kind === "image") {
+			const isGif = params.contentType === "image/gif";
+			if (isGif || !optimizeImages) {
+				if (params.buffer.length > cap) throw new Error(formatCapLimit(isGif ? "GIF" : "Media", cap, params.buffer.length));
+				return {
+					buffer: params.buffer,
+					contentType: params.contentType,
+					kind: params.kind,
+					fileName: params.fileName
+				};
+			}
+			return { ...await optimizeAndClampImage(params.buffer, cap, {
+				contentType: params.contentType,
+				fileName: params.fileName
+			}) };
+		}
+		if (params.buffer.length > cap) throw new Error(formatCapLimit("Media", cap, params.buffer.length));
+		return {
+			buffer: params.buffer,
+			contentType: params.contentType ?? void 0,
+			kind: params.kind,
+			fileName: params.fileName
+		};
+	};
+	if (/^https?:\/\//i.test(mediaUrl)) {
+		const defaultFetchCap = maxBytesForKind("document");
+		const { buffer, contentType, fileName } = await fetchRemoteMedia({
+			url: mediaUrl,
+			fetchImpl,
+			requestInit,
+			maxBytes: maxBytes === void 0 ? defaultFetchCap : optimizeImages ? Math.max(maxBytes, defaultFetchCap) : maxBytes,
+			ssrfPolicy,
+			dispatcherPolicy: proxyUrl ? {
+				mode: "explicit-proxy",
+				proxyUrl,
+				allowPrivateProxy: true
+			} : void 0,
+			trustExplicitProxyDns
+		});
+		return await clampAndFinalize({
+			buffer,
+			contentType,
+			kind: kindFromMime(contentType),
+			fileName
+		});
+	}
+	if (mediaUrl.startsWith("~")) mediaUrl = resolveUserPath(mediaUrl);
+	if (workspaceDir && !path.isAbsolute(mediaUrl) && !WINDOWS_DRIVE_RE.test(mediaUrl)) mediaUrl = path.resolve(workspaceDir, mediaUrl);
+	try {
+		assertNoWindowsNetworkPath(mediaUrl, "Local media path");
+	} catch (err) {
+		throw new LocalMediaAccessError("network-path-not-allowed", err.message, { cause: err });
+	}
+	if ((sandboxValidated || localRoots === "any") && !readFileOverride) throw new LocalMediaAccessError("unsafe-bypass", "Refusing localRoots bypass without readFile override. Use sandboxValidated with readFile, or pass explicit localRoots.");
+	if (!(sandboxValidated || localRoots === "any")) await assertLocalMediaAllowed(mediaUrl, localRoots);
+	let data;
+	if (readFileOverride) data = await readFileOverride(mediaUrl);
+	else try {
+		data = (await readLocalFileSafely({ filePath: mediaUrl })).buffer;
+	} catch (err) {
+		if (err instanceof SafeOpenError) {
+			if (err.code === "not-found") throw new LocalMediaAccessError("not-found", `Local media file not found: ${mediaUrl}`, { cause: err });
+			if (err.code === "not-file") throw new LocalMediaAccessError("not-file", `Local media path is not a file: ${mediaUrl}`, { cause: err });
+			throw new LocalMediaAccessError("invalid-path", `Local media path is not safe to read: ${mediaUrl}`, { cause: err });
+		}
+		throw err;
+	}
+	const sniffedMime = await detectMime({ buffer: data });
+	const mime = await detectMime({
+		buffer: data,
+		filePath: mediaUrl
+	});
+	const kind = kindFromMime(mime);
+	if (hostReadCapability) assertHostReadMediaAllowed({
+		sniffedContentType: sniffedMime,
+		contentType: mime,
+		filePath: mediaUrl,
+		kind,
+		buffer: data
+	});
+	let fileName = path.basename(mediaUrl) || void 0;
+	if (fileName && !path.extname(fileName) && mime) {
+		const ext = extensionForMime(mime);
+		if (ext) fileName = `${fileName}${ext}`;
+	}
+	return await clampAndFinalize({
+		buffer: data,
+		contentType: mime,
+		kind,
+		fileName
+	});
+}
+async function loadWebMedia(mediaUrl, maxBytesOrOptions, options) {
+	return await loadWebMediaInternal(mediaUrl, resolveWebMediaOptions({
+		maxBytesOrOptions,
+		options,
+		optimizeImages: true
+	}));
+}
+async function loadWebMediaRaw(mediaUrl, maxBytesOrOptions, options) {
+	return await loadWebMediaInternal(mediaUrl, resolveWebMediaOptions({
+		maxBytesOrOptions,
+		options,
+		optimizeImages: false
+	}));
+}
+async function optimizeImageToJpeg(buffer, maxBytes, opts = {}) {
+	let source = buffer;
+	if (isHeicSource(opts)) try {
+		source = await convertHeicToJpeg(buffer);
+	} catch (err) {
+		throw new Error(`HEIC image conversion failed: ${String(err)}`, { cause: err });
+	}
+	const sides = [
+		2048,
+		1536,
+		1280,
+		1024,
+		800
+	];
+	const qualities = [
+		80,
+		70,
+		60,
+		50,
+		40
+	];
+	let smallest = null;
+	for (const side of sides) for (const quality of qualities) try {
+		const out = await resizeToJpeg({
+			buffer: source,
+			maxSide: side,
+			quality,
+			withoutEnlargement: true
+		});
+		const size = out.length;
+		if (!smallest || size < smallest.size) smallest = {
+			buffer: out,
+			size,
+			resizeSide: side,
+			quality
+		};
+		if (size <= maxBytes) return {
+			buffer: out,
+			optimizedSize: size,
+			resizeSide: side,
+			quality
+		};
+	} catch {}
+	if (smallest) return {
+		buffer: smallest.buffer,
+		optimizedSize: smallest.size,
+		resizeSide: smallest.resizeSide,
+		quality: smallest.quality
+	};
+	throw new Error("Failed to optimize image");
+}
+//#endregion
+export { A2UI_PATH as a, handleA2uiHttpRequest as c, resolveFileWithinRoot as d, createCanvasDocument as i, injectCanvasLiveReload as l, loadWebMediaRaw as n, CANVAS_HOST_PATH as o, optimizeImageToJpeg as r, CANVAS_WS_PATH as s, loadWebMedia as t, normalizeUrlPath as u };