emdash 0.33.0 → 0.35.0

package/dist/bundle-vn56sLos.mjs

@@ -0,0 +1,663 @@
+import { c as __exportAll } from "./runner-C1T11CfC.mjs";
+import { t as imageSize } from "./dist-D_6CKR8z.mjs";
+import { i as isDeprecatedCapability, n as capabilitiesToDeclaredAccess, t as CAPABILITY_RENAMES } from "./types-CP1CflWf.mjs";
+import { z } from "zod";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+import { access, copyFile, mkdir, readFile, readdir, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { basename, extname, join, resolve } from "node:path";
+import { createWriteStream } from "node:fs";
+import { defineCommand } from "citty";
+import consola from "consola";
+import { pipeline } from "node:stream/promises";
+import { packTar } from "modern-tar/fs";
+
+//#region src/cli/commands/bundle-utils.ts
+/**
+* Bundle utility functions
+*
+* Shared logic extracted from the bundle command so it can be tested
+* without the CLI harness and tsdown dependency.
+*/
+const MAX_BUNDLE_SIZE = 256 * 1024;
+const MAX_FILE_SIZE = 128 * 1024;
+const MAX_FILE_COUNT = 20;
+const MAX_SCREENSHOTS = 5;
+const MAX_SCREENSHOT_WIDTH = 1920;
+const MAX_SCREENSHOT_HEIGHT = 1080;
+const ICON_SIZE = 256;
+const MCP_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+/**
+* Matches Node.js built-in imports in bundled output:
+* - require("node:xxx") / require("xxx")
+* - import("node:xxx") / import("xxx")
+* - import X from "node:xxx" / import { X } from "node:xxx"
+* - import * as X from "node:xxx"
+* - export { X } from "node:xxx"
+* Captures the base module name (e.g. "fs" from "node:fs/promises").
+*/
+const NODE_BUILTIN_IMPORT_RE = /(?:import|export|require)\s*(?:\(|[^(]*?\bfrom\s+)["'](?:node:)?([a-z_]+)(?:\/[^"']*)?\s*["']\)?/g;
+const LEADING_DOT_SLASH_RE = /^\.\//;
+const DIST_PREFIX_RE = /^dist\//;
+const MJS_EXT_RE = /\.m?js$/;
+const TS_TO_TSX_RE = /\.ts$/;
+/** Node.js built-in modules that shouldn't appear in sandbox code */
+const NODE_BUILTINS = new Set([
+	"assert",
+	"buffer",
+	"child_process",
+	"cluster",
+	"crypto",
+	"dgram",
+	"dns",
+	"domain",
+	"events",
+	"fs",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"module",
+	"net",
+	"os",
+	"path",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"repl",
+	"stream",
+	"string_decoder",
+	"sys",
+	"timers",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib"
+]);
+async function fileExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Convert an absolute build artifact path into a portable ESM import specifier. */
+function toFileImportSpecifier(path) {
+	return pathToFileURL(path).href;
+}
+/**
+* Read image dimensions from a buffer.
+* Returns [width, height] or null if the format is unrecognized.
+*/
+function readImageDimensions(buf) {
+	try {
+		const result = imageSize(buf);
+		if (result.width != null && result.height != null) return [result.width, result.height];
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Extract manifest metadata from a ResolvedPlugin.
+* Strips functions (hooks, route handlers) and keeps only serializable metadata.
+*/
+function extractManifest(plugin) {
+	const hooks = [];
+	for (const [name, resolved] of Object.entries(plugin.hooks)) {
+		if (!resolved) continue;
+		if (resolved.exclusive || resolved.priority !== 100 || resolved.timeout !== 5e3) {
+			const entry = { name };
+			if (resolved.exclusive) entry.exclusive = true;
+			if (resolved.priority !== 100) entry.priority = resolved.priority;
+			if (resolved.timeout !== 5e3) entry.timeout = resolved.timeout;
+			hooks.push(entry);
+		} else hooks.push(name);
+	}
+	const routes = Object.entries(plugin.routes).map(([name, route]) => {
+		if (route.public === void 0 && route.permission === void 0 && route.cacheControl === void 0) return name;
+		const entry = { name };
+		if (route.public !== void 0) entry.public = route.public;
+		if (route.permission !== void 0) entry.permission = route.permission;
+		if (route.cacheControl !== void 0) entry.cacheControl = route.cacheControl;
+		return entry;
+	});
+	const tools = Object.entries(plugin.mcp?.tools ?? {}).map(([name, tool]) => {
+		if (!MCP_TOOL_NAME_PATTERN.test(name)) throw new Error(`Invalid MCP tool name "${name}"`);
+		const route = plugin.routes[tool.route];
+		if (!route?.permission || route.public) throw new Error(`MCP tool "${name}" must reference a private route with a permission`);
+		return {
+			name,
+			description: tool.description,
+			route: tool.route,
+			permission: route.permission,
+			destructive: tool.destructive ?? false,
+			inputSchema: z.toJSONSchema(tool.input, { target: "draft-7" }),
+			...tool.output ? { outputSchema: z.toJSONSchema(tool.output, { target: "draft-7" }) } : {}
+		};
+	});
+	return {
+		id: plugin.id,
+		version: plugin.version,
+		declaredAccess: capabilitiesToDeclaredAccess(plugin.capabilities, plugin.allowedHosts),
+		capabilities: plugin.capabilities,
+		allowedHosts: plugin.allowedHosts,
+		storage: plugin.storage,
+		hooks,
+		routes,
+		...tools.length > 0 ? { mcp: { tools } } : {},
+		admin: {
+			settingsSchema: plugin.admin.settingsSchema,
+			pages: plugin.admin.pages,
+			widgets: plugin.admin.widgets
+		}
+	};
+}
+/**
+* Scan bundled code for Node.js built-in imports.
+* Matches require("node:xxx"), require("xxx"), import("node:xxx") — the patterns
+* that appear in bundled ESM/CJS output (not source-level named imports).
+* Returns deduplicated array of built-in module names found.
+*/
+function findNodeBuiltinImports(code) {
+	const found = [];
+	NODE_BUILTIN_IMPORT_RE.lastIndex = 0;
+	let match;
+	while ((match = NODE_BUILTIN_IMPORT_RE.exec(code)) !== null) {
+		const mod = match[1];
+		if (NODE_BUILTINS.has(mod)) found.push(mod);
+	}
+	return [...new Set(found)];
+}
+/**
+* Find a build output file by base name, checking common extensions.
+* tsdown may output .mjs, .js, or .cjs depending on format and config.
+*/
+async function findBuildOutput(dir, baseName) {
+	for (const ext of [
+		".mjs",
+		".js",
+		".cjs"
+	]) {
+		const candidate = join(dir, `${baseName}${ext}`);
+		if (await fileExists(candidate)) return candidate;
+	}
+}
+/**
+* Resolve a dist/built path back to its source .ts/.tsx equivalent.
+* E.g., "./dist/index.mjs" → "src/index.ts"
+*/
+async function resolveSourceEntry(pluginDir, distPath) {
+	const cleaned = distPath.replace(LEADING_DOT_SLASH_RE, "");
+	const srcPath = cleaned.replace(DIST_PREFIX_RE, "src/").replace(MJS_EXT_RE, ".ts");
+	const srcFull = resolve(pluginDir, srcPath);
+	if (await fileExists(srcFull)) return srcFull;
+	const tsxFull = resolve(pluginDir, srcPath.replace(TS_TO_TSX_RE, ".tsx"));
+	if (await fileExists(tsxFull)) return tsxFull;
+	const direct = resolve(pluginDir, cleaned);
+	if (await fileExists(direct)) return direct;
+}
+const TS_SOURCE_EXPORT_RE = /\.(?:ts|tsx|mts|cts|jsx)$/;
+/**
+* Find package.json exports that point to source files instead of built output.
+* Returns an array of `{ exportPath, resolvedPath }` for each offending export.
+*/
+function findSourceExports(exports) {
+	const issues = [];
+	for (const [exportPath, exportValue] of Object.entries(exports)) {
+		const resolved = typeof exportValue === "string" ? exportValue : exportValue && typeof exportValue === "object" && "import" in exportValue ? exportValue.import : null;
+		if (resolved && TS_SOURCE_EXPORT_RE.test(resolved)) issues.push({
+			exportPath,
+			resolvedPath: resolved
+		});
+	}
+	return issues;
+}
+/**
+* Recursively walk a staging directory and return a flat list of all files
+* with sizes. Names are relative to `dir` so they match what would appear
+* as the tarball entry name.
+*/
+async function collectBundleEntries(dir) {
+	const entries = [];
+	await walkBundle(dir, "", entries);
+	return entries;
+}
+async function walkBundle(dir, prefix, into) {
+	const items = await readdir(dir, { withFileTypes: true });
+	for (const item of items) {
+		const fullPath = join(dir, item.name);
+		const relPath = prefix ? `${prefix}/${item.name}` : item.name;
+		if (item.isFile()) {
+			const s = await stat(fullPath);
+			into.push({
+				name: relPath,
+				bytes: s.size
+			});
+		} else if (item.isDirectory()) await walkBundle(fullPath, relPath, into);
+	}
+}
+/**
+* Sum the byte sizes of all entries.
+*/
+function totalBundleBytes(entries) {
+	let total = 0;
+	for (const e of entries) total += e.bytes;
+	return total;
+}
+/**
+* Check a bundle against the three size caps from RFC 0001:
+*   - total decompressed ≤ MAX_BUNDLE_SIZE
+*   - per-file decompressed ≤ MAX_FILE_SIZE
+*   - file count ≤ MAX_FILE_COUNT
+*
+* Returns a list of violation messages (empty if the bundle is within all
+* caps). Messages are deterministic per input — the total/count violations
+* come first, then oversized files in alphabetical order — so the same
+* bundle always produces the same error text.
+*/
+function validateBundleSize(entries) {
+	const violations = [];
+	const total = totalBundleBytes(entries);
+	if (total > MAX_BUNDLE_SIZE) violations.push(`Bundle size ${formatBytes(total)} exceeds maximum of ${formatBytes(MAX_BUNDLE_SIZE)}.`);
+	if (entries.length > MAX_FILE_COUNT) violations.push(`Bundle contains ${entries.length} files, exceeds maximum of ${MAX_FILE_COUNT}.`);
+	const oversized = entries.filter((e) => e.bytes > MAX_FILE_SIZE).toSorted((a, b) => a.name.localeCompare(b.name));
+	for (const e of oversized) violations.push(`File ${e.name} is ${formatBytes(e.bytes)}, exceeds per-file maximum of ${formatBytes(MAX_FILE_SIZE)}.`);
+	return violations;
+}
+/**
+* Render a byte count as a human-friendly string (e.g. "256.0 KB").
+*/
+function formatBytes(n) {
+	if (n < 1024) return `${n} B`;
+	if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+	return `${(n / 1024 / 1024).toFixed(2)} MB`;
+}
+/**
+* Create a gzipped tarball from a directory.
+*/
+async function createTarball(sourceDir, outputPath) {
+	const { createGzip } = await import("node:zlib");
+	await pipeline(packTar(sourceDir), createGzip({ level: 9 }), createWriteStream(outputPath));
+}
+
+//#endregion
+//#region src/cli/commands/bundle.ts
+/**
+* emdash plugin bundle
+*
+* Produces a publishable plugin tarball from a plugin source directory.
+*
+* Steps:
+* 1. Resolve plugin entrypoint (finds definePlugin() export)
+* 2. Bundle backend code with tsdown → backend.js (single ES module, tree-shaken)
+* 3. Bundle admin code if present → admin.js
+* 4. Extract manifest from definePlugin() → manifest.json
+* 5. Collect assets (README.md, icon.png, screenshots/)
+* 6. Validate bundle (manifest schema, size limits, no Node.js builtins)
+* 7. Create tarball ({id}-{version}.tar.gz)
+*/
+var bundle_exports = /* @__PURE__ */ __exportAll({ bundleCommand: () => bundleCommand });
+const TS_EXT_RE = /\.(tsx?|[mc]?js)$/;
+const SLASH_RE = /\//g;
+const LEADING_AT_RE = /^@/;
+const emdash_SCOPE_RE = /^@emdash-cms\//;
+const bundleCommand = defineCommand({
+	meta: {
+		name: "bundle",
+		description: "Bundle a plugin for marketplace distribution"
+	},
+	args: {
+		dir: {
+			type: "string",
+			description: "Plugin directory (default: current directory)",
+			default: process.cwd()
+		},
+		outDir: {
+			type: "string",
+			alias: "o",
+			description: "Output directory for the tarball (default: ./dist)",
+			default: "dist"
+		},
+		validateOnly: {
+			type: "boolean",
+			description: "Run validation only, skip tarball creation",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const pluginDir = resolve(args.dir);
+		const outDir = resolve(pluginDir, args.outDir);
+		const validateOnly = args.validateOnly;
+		consola.start(validateOnly ? "Validating plugin..." : "Bundling plugin...");
+		const pkgPath = join(pluginDir, "package.json");
+		if (!await fileExists(pkgPath)) {
+			consola.error("No package.json found in", pluginDir);
+			process.exit(1);
+		}
+		const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+		let backendEntry;
+		let adminEntry;
+		if (pkg.exports) {
+			const sandboxExport = pkg.exports["./sandbox"];
+			if (typeof sandboxExport === "string") backendEntry = await resolveSourceEntry(pluginDir, sandboxExport);
+			else if (sandboxExport && typeof sandboxExport === "object" && "import" in sandboxExport) backendEntry = await resolveSourceEntry(pluginDir, sandboxExport.import);
+			const adminExport = pkg.exports["./admin"];
+			if (typeof adminExport === "string") adminEntry = await resolveSourceEntry(pluginDir, adminExport);
+			else if (adminExport && typeof adminExport === "object" && "import" in adminExport) adminEntry = await resolveSourceEntry(pluginDir, adminExport.import);
+		}
+		if (!backendEntry) {
+			const defaultSandbox = join(pluginDir, "src/sandbox-entry.ts");
+			if (await fileExists(defaultSandbox)) backendEntry = defaultSandbox;
+		}
+		let mainEntry;
+		if (pkg.exports?.["."] !== void 0) {
+			const mainExport = pkg.exports["."];
+			if (typeof mainExport === "string") mainEntry = await resolveSourceEntry(pluginDir, mainExport);
+			else if (mainExport && typeof mainExport === "object" && "import" in mainExport) mainEntry = await resolveSourceEntry(pluginDir, mainExport.import);
+		}
+		if (!mainEntry && pkg.main) mainEntry = await resolveSourceEntry(pluginDir, pkg.main);
+		if (!mainEntry) {
+			const defaultMain = join(pluginDir, "src/index.ts");
+			if (await fileExists(defaultMain)) mainEntry = defaultMain;
+		}
+		if (!mainEntry) {
+			consola.error("Cannot find plugin entrypoint. Expected src/index.ts or main/exports in package.json");
+			process.exit(1);
+		}
+		consola.info(`Main entry: ${mainEntry}`);
+		if (backendEntry) consola.info(`Backend entry: ${backendEntry}`);
+		if (adminEntry) consola.info(`Admin entry: ${adminEntry}`);
+		consola.start("Extracting plugin manifest...");
+		const { build } = await import("tsdown");
+		const tmpDir = join(pluginDir, ".emdash-bundle-tmp");
+		try {
+			await rm(tmpDir, {
+				recursive: true,
+				force: true
+			});
+			await mkdir(tmpDir, { recursive: true });
+			const mainOutDir = join(tmpDir, "main");
+			await build({
+				config: false,
+				entry: [mainEntry],
+				format: "esm",
+				outDir: mainOutDir,
+				dts: false,
+				platform: "node",
+				external: ["emdash", emdash_SCOPE_RE]
+			});
+			const pluginNodeModules = join(pluginDir, "node_modules");
+			const tmpNodeModules = join(mainOutDir, "node_modules");
+			if (await fileExists(pluginNodeModules)) await symlink(pluginNodeModules, tmpNodeModules, "junction");
+			const mainOutputPath = await findBuildOutput(mainOutDir, basename(mainEntry).replace(TS_EXT_RE, ""));
+			if (!mainOutputPath) {
+				consola.error("Failed to build main entry — no output found in", mainOutDir);
+				process.exit(1);
+			}
+			const pluginModule = await import(toFileImportSpecifier(mainOutputPath));
+			let resolvedPlugin;
+			if (typeof pluginModule.createPlugin === "function") resolvedPlugin = pluginModule.createPlugin();
+			else if (typeof pluginModule.default === "function") resolvedPlugin = pluginModule.default();
+			else if (typeof pluginModule.default === "object" && pluginModule.default !== null) {
+				const defaultExport = pluginModule.default;
+				if ("id" in defaultExport && "version" in defaultExport) resolvedPlugin = defaultExport;
+			}
+			if (!resolvedPlugin) for (const [key, value] of Object.entries(pluginModule)) {
+				if (key === "default" || typeof value !== "function") continue;
+				try {
+					const result = value();
+					if (result && typeof result === "object" && "id" in result && "version" in result) {
+						resolvedPlugin = {
+							id: result.id,
+							version: result.version,
+							capabilities: result.capabilities ?? [],
+							allowedHosts: result.allowedHosts ?? [],
+							storage: result.storage ?? {},
+							hooks: {},
+							routes: {},
+							admin: {
+								pages: result.adminPages,
+								widgets: result.adminWidgets
+							}
+						};
+						if (backendEntry) {
+							const backendProbeDir = join(tmpDir, "backend-probe");
+							const probeShimDir = join(tmpDir, "probe-shims");
+							await mkdir(probeShimDir, { recursive: true });
+							await writeFile(join(probeShimDir, "emdash.mjs"), "export const definePlugin = (d) => d;\n");
+							await build({
+								config: false,
+								entry: [backendEntry],
+								format: "esm",
+								outDir: backendProbeDir,
+								dts: false,
+								platform: "neutral",
+								external: [],
+								alias: { emdash: join(probeShimDir, "emdash.mjs") },
+								treeshake: true
+							});
+							const backendProbePath = await findBuildOutput(backendProbeDir, basename(backendEntry).replace(TS_EXT_RE, ""));
+							if (backendProbePath) {
+								const standardDef = (await import(toFileImportSpecifier(backendProbePath))).default ?? {};
+								const hooks = standardDef.hooks;
+								const routes = standardDef.routes;
+								if (hooks) for (const hookName of Object.keys(hooks)) {
+									const hookEntry = hooks[hookName];
+									const isConfig = typeof hookEntry === "object" && hookEntry !== null && "handler" in hookEntry;
+									const config = isConfig ? hookEntry : {};
+									resolvedPlugin.hooks[hookName] = {
+										handler: isConfig ? hookEntry.handler : hookEntry,
+										priority: config.priority ?? 100,
+										timeout: config.timeout ?? 5e3,
+										dependencies: config.dependencies ?? [],
+										errorPolicy: config.errorPolicy ?? "abort",
+										exclusive: config.exclusive ?? false,
+										pluginId: result.id
+									};
+								}
+								if (routes) for (const [name, route] of Object.entries(routes)) {
+									const routeObj = route;
+									resolvedPlugin.routes[name] = {
+										handler: routeObj.handler,
+										public: routeObj.public,
+										cacheControl: routeObj.cacheControl
+									};
+								}
+							}
+						}
+						break;
+					}
+				} catch {}
+			}
+			if (!resolvedPlugin?.id || !resolvedPlugin?.version) {
+				consola.error("Could not extract plugin definition. Expected one of:\n  - createPlugin() export (native format)\n  - Descriptor factory function returning { id, version, ... } (standard format)");
+				process.exit(1);
+			}
+			const manifest = extractManifest(resolvedPlugin);
+			if (resolvedPlugin.admin?.entry) {
+				consola.error("Plugin declares adminEntry — React admin components require native/trusted mode. Use Block Kit for sandboxed admin pages, or remove adminEntry.");
+				process.exit(1);
+			}
+			if (resolvedPlugin.admin?.portableTextBlocks && resolvedPlugin.admin.portableTextBlocks.length > 0) {
+				consola.error("Plugin declares portableTextBlocks — these require native/trusted mode and cannot be bundled for the marketplace.");
+				process.exit(1);
+			}
+			consola.success(`Plugin: ${manifest.id}@${manifest.version}`);
+			consola.info(`  Capabilities: ${manifest.capabilities.length > 0 ? manifest.capabilities.join(", ") : "(none)"}`);
+			consola.info(`  Hooks: ${manifest.hooks.length > 0 ? manifest.hooks.map((h) => typeof h === "string" ? h : h.name).join(", ") : "(none)"}`);
+			consola.info(`  Routes: ${manifest.routes.length > 0 ? manifest.routes.map((r) => typeof r === "string" ? r : r.name).join(", ") : "(none)"}`);
+			const bundleDir = join(tmpDir, "bundle");
+			await mkdir(bundleDir, { recursive: true });
+			if (backendEntry) {
+				consola.start("Bundling backend...");
+				const shimDir = join(tmpDir, "shims");
+				await mkdir(shimDir, { recursive: true });
+				await writeFile(join(shimDir, "emdash.mjs"), "export const definePlugin = (d) => d;\n");
+				await build({
+					config: false,
+					entry: [backendEntry],
+					format: "esm",
+					outDir: join(tmpDir, "backend"),
+					dts: false,
+					platform: "neutral",
+					external: [],
+					alias: { emdash: join(shimDir, "emdash.mjs") },
+					minify: true,
+					treeshake: true
+				});
+				const backendBaseName = basename(backendEntry).replace(TS_EXT_RE, "");
+				const backendOutputPath = await findBuildOutput(join(tmpDir, "backend"), backendBaseName);
+				if (backendOutputPath) {
+					await copyFile(backendOutputPath, join(bundleDir, "backend.js"));
+					consola.success("Built backend.js");
+				} else {
+					consola.error("Backend build produced no output");
+					process.exit(1);
+				}
+			} else {
+				consola.warn("No sandbox entry found — bundle will have no backend.js");
+				consola.warn("  Add a \"sandbox-entry.ts\" in src/ or a \"./sandbox\" export in package.json");
+			}
+			if (adminEntry) {
+				consola.start("Bundling admin...");
+				await build({
+					config: false,
+					entry: [adminEntry],
+					format: "esm",
+					outDir: join(tmpDir, "admin"),
+					dts: false,
+					platform: "neutral",
+					external: [],
+					minify: true,
+					treeshake: true
+				});
+				const adminBaseName = basename(adminEntry).replace(TS_EXT_RE, "");
+				const adminOutputPath = await findBuildOutput(join(tmpDir, "admin"), adminBaseName);
+				if (adminOutputPath) {
+					await copyFile(adminOutputPath, join(bundleDir, "admin.js"));
+					consola.success("Built admin.js");
+				}
+			}
+			await writeFile(join(bundleDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+			consola.start("Collecting assets...");
+			const readmePath = join(pluginDir, "README.md");
+			if (await fileExists(readmePath)) {
+				await copyFile(readmePath, join(bundleDir, "README.md"));
+				consola.success("Included README.md");
+			}
+			const iconPath = join(pluginDir, "icon.png");
+			if (await fileExists(iconPath)) {
+				const dims = readImageDimensions(await readFile(iconPath));
+				if (!dims) consola.warn("icon.png is not a valid PNG — skipping");
+				else if (dims[0] !== ICON_SIZE || dims[1] !== ICON_SIZE) {
+					consola.warn(`icon.png is ${dims[0]}x${dims[1]}, expected ${ICON_SIZE}x${ICON_SIZE} — including anyway`);
+					await copyFile(iconPath, join(bundleDir, "icon.png"));
+				} else {
+					await copyFile(iconPath, join(bundleDir, "icon.png"));
+					consola.success("Included icon.png");
+				}
+			}
+			const screenshotsDir = join(pluginDir, "screenshots");
+			if (await fileExists(screenshotsDir)) {
+				const screenshotFiles = (await readdir(screenshotsDir)).filter((f) => {
+					const ext = extname(f).toLowerCase();
+					return ext === ".png" || ext === ".jpg" || ext === ".jpeg";
+				}).toSorted().slice(0, MAX_SCREENSHOTS);
+				if (screenshotFiles.length > 0) {
+					await mkdir(join(bundleDir, "screenshots"), { recursive: true });
+					for (const file of screenshotFiles) {
+						const filePath = join(screenshotsDir, file);
+						const dims = readImageDimensions(await readFile(filePath));
+						if (!dims) {
+							consola.warn(`screenshots/${file} — cannot read dimensions, skipping`);
+							continue;
+						}
+						if (dims[0] > MAX_SCREENSHOT_WIDTH || dims[1] > MAX_SCREENSHOT_HEIGHT) consola.warn(`screenshots/${file} is ${dims[0]}x${dims[1]}, max ${MAX_SCREENSHOT_WIDTH}x${MAX_SCREENSHOT_HEIGHT} — including anyway`);
+						await copyFile(filePath, join(bundleDir, "screenshots", file));
+					}
+					consola.success(`Included ${screenshotFiles.length} screenshot(s)`);
+				}
+			}
+			consola.start("Validating bundle...");
+			let hasErrors = false;
+			if (pkg.exports) for (const issue of findSourceExports(pkg.exports)) {
+				consola.error(`Export "${issue.exportPath}" points to source (${issue.resolvedPath}). Package exports must point to built files (e.g. dist/*.mjs). Add a build step and update the exports map.`);
+				hasErrors = true;
+			}
+			const backendPath = join(bundleDir, "backend.js");
+			if (await fileExists(backendPath)) {
+				const builtins = findNodeBuiltinImports(await readFile(backendPath, "utf-8"));
+				if (builtins.length > 0) {
+					consola.error(`backend.js imports Node.js built-in modules: ${builtins.join(", ")}`);
+					consola.error("Sandboxed plugins cannot use Node.js APIs");
+					hasErrors = true;
+				}
+			}
+			const declaresUnrestricted = manifest.capabilities.includes("network:request:unrestricted") || manifest.capabilities.includes("network:fetch:any");
+			const declaresHostRestricted = manifest.capabilities.includes("network:request") || manifest.capabilities.includes("network:fetch");
+			if (declaresUnrestricted) consola.warn("Plugin declares unrestricted network access (network:request:unrestricted) — it can make requests to any host");
+			else if (declaresHostRestricted && manifest.allowedHosts.length === 0) consola.warn("Plugin declares network:request capability but no allowedHosts — all requests will be blocked");
+			const deprecatedCaps = manifest.capabilities.filter(isDeprecatedCapability);
+			if (deprecatedCaps.length > 0) {
+				consola.warn("Plugin uses deprecated capability names. Rename them before publishing:");
+				for (const cap of deprecatedCaps) {
+					const replacement = CAPABILITY_RENAMES[cap];
+					consola.warn(`  ${cap} → ${replacement}`);
+				}
+			}
+			if (resolvedPlugin.admin?.portableTextBlocks && resolvedPlugin.admin.portableTextBlocks.length > 0) consola.warn("Plugin declares portableTextBlocks — these require trusted mode and will be ignored in sandboxed plugins");
+			if (resolvedPlugin.admin?.entry) consola.warn("Plugin declares admin.entry — custom React components require trusted mode. Use Block Kit for sandboxed admin pages");
+			if (resolvedPlugin.hooks["page:fragments"]) consola.warn("Plugin declares page:fragments hook — this is trusted-only and will not work in sandboxed mode");
+			const hasAdminPages = (manifest.admin?.pages?.length ?? 0) > 0;
+			const hasAdminWidgets = (manifest.admin?.widgets?.length ?? 0) > 0;
+			if (hasAdminPages || hasAdminWidgets) {
+				if (!manifest.routes.map((r) => typeof r === "string" ? r : r.name).includes("admin")) {
+					consola.error(`Plugin declares ${hasAdminPages ? "adminPages" : ""}${hasAdminPages && hasAdminWidgets ? " and " : ""}${hasAdminWidgets ? "adminWidgets" : ""} but the sandbox entry has no "admin" route. Add an admin route handler to serve Block Kit pages.`);
+					hasErrors = true;
+				}
+			}
+			const bundleEntries = await collectBundleEntries(bundleDir);
+			const sizeViolations = validateBundleSize(bundleEntries);
+			if (sizeViolations.length > 0) {
+				for (const v of sizeViolations) consola.error(v);
+				hasErrors = true;
+			} else consola.info(`Bundle size: ${formatBytes(totalBundleBytes(bundleEntries))} across ${bundleEntries.length} file${bundleEntries.length === 1 ? "" : "s"}`);
+			if (hasErrors) {
+				consola.error("Bundle validation failed");
+				process.exit(1);
+			}
+			consola.success("Validation passed");
+			if (validateOnly) return;
+			await mkdir(outDir, { recursive: true });
+			const tarballName = `${manifest.id.replace(SLASH_RE, "-").replace(LEADING_AT_RE, "")}-${manifest.version}.tar.gz`;
+			const tarballPath = join(outDir, tarballName);
+			consola.start("Creating tarball...");
+			await createTarball(bundleDir, tarballPath);
+			const tarballSizeKB = ((await stat(tarballPath)).size / 1024).toFixed(1);
+			const tarballBuf = await readFile(tarballPath);
+			const checksum = createHash("sha256").update(tarballBuf).digest("hex");
+			consola.success(`Created ${tarballName} (${tarballSizeKB}KB)`);
+			consola.info(`  SHA-256: ${checksum}`);
+			consola.info(`  Path: ${tarballPath}`);
+		} finally {
+			if (tmpDir.endsWith(".emdash-bundle-tmp")) await rm(tmpDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+});
+
+//#endregion
+export { bundle_exports as n, fileExists as r, bundleCommand as t };
+//# sourceMappingURL=bundle-vn56sLos.mjs.map