@agimon-ai/doompi 0.0.1-alpha.76 → 0.0.1-alpha.78

package/dist/compiler/index.cjs

@@ -0,0 +1,996 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_cache = require("./cache.cjs");
+const require_inputs = require("./inputs.cjs");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+let node_url = require("node:url");
+let _agimon_ai_doompi_core_module_resolution = require("@agimon-ai/doompi-core/module-resolution");
+let node_crypto = require("node:crypto");
+//#region src/compiler/index.ts
+/**
+* Compiles TypeScript extensions into plain ESM ahead of the session.
+*
+* Pi loads extensions through jiti, which transpiles TypeScript at import time.
+* That works, but it costs a transform per module on a cold cache and makes Node
+* complain about type stripping under node_modules on every launch. Resolution
+* already knows the full extension list, so each TypeScript graph is compiled
+* to native ESM here and Pi imports it without a runtime transform. Lazy imports
+* remain separate content-addressed chunks so their evaluation semantics survive
+* compilation.
+*
+* Direct module artifacts bundle ordinary JavaScript dependencies. Node built-ins and Pi's
+* shared runtime stay external; native or resource-bearing dependencies fail explicitly
+* unless their package-owned resources are pinned into the artifact.
+* Those imports are rewritten to absolute paths so a worktree-local artifact never relies
+* on its generated directory having its own `node_modules` tree. Immutable build objects
+* may be shared by linked worktrees, but materialized output stays worktree-local.
+*/
+const TYPESCRIPT_SUFFIXES = [
+	".ts",
+	".mts",
+	".cts"
+];
+const COMPILED_SUFFIX = ".mjs";
+const SET_CACHE_VERSION = "v15";
+const HASH_LENGTH = 16;
+const SET_DIRECTORY = "sets";
+const MANIFEST_SUFFIX = ".json";
+const VIRTUAL_SET_ENTRY = "\0doompi-extension-set";
+const EXTENSION_SOURCE_HELPER = "@agimon-ai/doompi-ui/extensionName";
+const SHARED_BUILD_VERSION = "v3-rolldown-1.2.5";
+const SHARED_PATH_TOKEN_PREFIX = "__DOOMPI_PATH_";
+const REPOSITORY_INPUT_PREFIX = "repo/";
+const EXTERNAL_INPUT_PREFIX = "external/";
+const DEFAULT_SET_OUTPUT_NAME = "doom-set";
+/** Serializes data embedded in generated JavaScript without leaving HTML or line-separator code boundaries. */
+function javascriptStringLiteral(value) {
+	return JSON.stringify(value).replaceAll("<", "\\u003c").replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+}
+/** Pi's former npm scope. The packages are the same, published under a new name. */
+const PI_SCOPE_RENAMES = {
+	"@mariozechner/pi-coding-agent": "@earendil-works/pi-coding-agent",
+	"@mariozechner/pi-tui": "@earendil-works/pi-tui",
+	"@mariozechner/pi-ai": "@earendil-works/pi-ai",
+	"@sinclair/typebox": "typebox"
+};
+function isTypeScriptEntry(entry) {
+	return TYPESCRIPT_SUFFIXES.some((suffix) => entry.endsWith(suffix));
+}
+function renameScope(specifier) {
+	for (const [before, after] of Object.entries(PI_SCOPE_RENAMES)) {
+		if (specifier === before) return after;
+		if (specifier.startsWith(`${before}/`)) return `${after}${specifier.slice(before.length)}`;
+	}
+	return specifier;
+}
+/**
+* Packages that must resolve to the copy this harness runs, never to a second
+* one bundled into an extension. Pi owns the TUI and the session state, so a
+* duplicate renders into a different screen and mutates a different store.
+*/
+const HOSTED_PACKAGES = /* @__PURE__ */ new Set([
+	"@earendil-works/pi-coding-agent",
+	"@earendil-works/pi-tui",
+	"@earendil-works/pi-ai"
+]);
+/**
+* Resolves packages Pi exposes to extensions as compatibility aliases.
+*
+* Extensions do not need to declare TypeBox themselves because Pi's loader
+* provides it as a virtual module. A dist bundle bypasses that loader, so it
+* resolves the same package against Pi's dependency tree and bundles it.
+*/
+function piExtensionDependencyEntry(specifier) {
+	const piEntry = (0, _agimon_ai_doompi_core_module_resolution.optionalPackageEntry)("@earendil-works/pi-coding-agent", require("url").pathToFileURL(__filename).href);
+	if (!piEntry) return void 0;
+	try {
+		return (0, node_module.createRequire)(piEntry).resolve(specifier);
+	} catch {
+		return;
+	}
+}
+/** Packages whose native binaries or runtime discovery cannot be rolled up. */
+const NATIVE_PACKAGES = /* @__PURE__ */ new Set([
+	"@parcel/watcher",
+	"@napi-rs/keyring",
+	"better-sqlite3",
+	"canvas",
+	"fsevents",
+	"isolated-vm",
+	"keytar",
+	"node-pty",
+	"onnxruntime-node",
+	"playwright",
+	"playwright-core",
+	"puppeteer",
+	"sharp",
+	"typescript"
+]);
+const TURSO_DATABASE_PACKAGE = "@tursodatabase/database";
+const TURSO_DATABASE_COMMON_PACKAGE = "@tursodatabase/database-common";
+/**
+* Dependency-heavy ESM runtimes that Pi set artifacts should retain in their installed graph.
+*
+* Folding these packages into the aggregate creates dozens of generated chunks
+* that Node must parse and link before any extension factory can register. Node
+* can load the installed graph directly while still sharing its module cache.
+*/
+const STARTUP_EXTERNAL_PACKAGES = /* @__PURE__ */ new Set([
+	"@agimon-ai/foundation-port-registry",
+	"@agimon-ai/foundation-process-registry",
+	"@agimon-ai/log-sink-mcp",
+	"@modelcontextprotocol/sdk",
+	"@narumitw/pi-tui-kit",
+	"@rmux/sdk",
+	"@tursodatabase/database",
+	"@tursodatabase/database-common",
+	"ajv",
+	"ajv-formats",
+	"gpt-tokenizer",
+	"highlight.js",
+	"hono",
+	"inversify",
+	"open",
+	"reflect-metadata",
+	"zod-to-json-schema",
+	"yaml",
+	"zod"
+]);
+const NODE_BUILTINS = new Set(node_module.builtinModules.flatMap((name) => [name, `node:${name}`]));
+/**
+* Direct modules may bundle ordinary JavaScript, but these packages carry runtime
+* files or native bindings that require explicitly pinned resources.
+*/
+const DIRECT_RESOURCE_PACKAGES = /* @__PURE__ */ new Set([
+	"@agimon-ai/doompi-runner-rmux-darwin-arm64",
+	"@agimon-ai/doompi-runner-rmux-darwin-x64",
+	"@agimon-ai/doompi-runner-rmux-linux-arm64",
+	"@agimon-ai/doompi-runner-rmux-linux-x64",
+	"@tursodatabase/database",
+	"@tursodatabase/database-common",
+	"onnxruntime-web",
+	"ruvector-onnx-embeddings-wasm",
+	"sherpa-onnx-node",
+	"sqlite-vec",
+	"open"
+]);
+/** Published runtimes that intentionally retain their native dependency graph outside direct artifacts. */
+const DIRECT_EXTERNAL_PACKAGES = /* @__PURE__ */ new Set(["@agimon-ai/style-system"]);
+/**
+* @rmux/sdk only looks up the caller-provided `rmux` executable by name and has
+* no package-owned executable or resource lookup. Its JavaScript graph is safe
+* to bundle; the RMUX binary remains an intentional host capability.
+*/
+function directModuleDependencyIsUnbundlable(root) {
+	return NATIVE_PACKAGES.has(root) || DIRECT_RESOURCE_PACKAGES.has(root) || root.startsWith("@tursodatabase/database-") || root.startsWith("sherpa-onnx-");
+}
+function directModuleDependencyError(root, importer) {
+	return /* @__PURE__ */ new Error(`Cannot compile direct extension module because dependency "${root}" has native bindings or package-owned resources that are not part of the compiled artifact${importer ? ` (imported by ${importer})` : ""}`);
+}
+function safeOutputName(value) {
+	return value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "") || DEFAULT_SET_OUTPUT_NAME;
+}
+function packageRootOf(specifier) {
+	const slash = specifier.startsWith("@") ? specifier.indexOf("/", specifier.indexOf("/") + 1) : specifier.indexOf("/");
+	return slash === -1 ? specifier : specifier.slice(0, slash);
+}
+function packageRootFromPath(target) {
+	let directory = node_path.default.dirname(target);
+	while (true) {
+		const manifestPath = node_path.default.join(directory, "package.json");
+		if (node_fs.default.existsSync(manifestPath)) try {
+			const manifest = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
+			if (isRecord(manifest) && typeof manifest.name === "string") return manifest.name;
+		} catch {
+			return;
+		}
+		const parent = node_path.default.dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+function canonicalPath(target) {
+	const absolute = node_path.default.resolve(target);
+	try {
+		return node_fs.default.realpathSync.native(absolute);
+	} catch {
+		return absolute;
+	}
+}
+function isInside(directory, target) {
+	const relative = node_path.default.relative(node_path.default.resolve(directory), node_path.default.resolve(target));
+	return relative === "" || !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
+}
+function packageManifestDirectory(target) {
+	let directory = node_path.default.dirname(canonicalPath(target));
+	while (true) {
+		const manifestPath = node_path.default.join(directory, "package.json");
+		try {
+			const manifest = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
+			if (isRecord(manifest) && typeof manifest.name === "string") return directory;
+		} catch {}
+		const parent = node_path.default.dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+function packageDependencyNames(manifest) {
+	return ["dependencies", "optionalDependencies"].flatMap((field) => {
+		const dependencies = manifest[field];
+		return isRecord(dependencies) ? Object.keys(dependencies) : [];
+	});
+}
+function resolvePackageDirectory(name, manifestPath) {
+	try {
+		return packageManifestDirectory((0, node_module.createRequire)(manifestPath).resolve(name));
+	} catch {
+		return;
+	}
+}
+function nativePackageDirectories(entries) {
+	const queue = entries.map(packageManifestDirectory).filter((value) => value !== void 0);
+	const visited = /* @__PURE__ */ new Set();
+	const found = [];
+	while (queue.length > 0) {
+		const directory = canonicalPath(queue.shift());
+		if (visited.has(directory)) continue;
+		visited.add(directory);
+		const manifestPath = node_path.default.join(directory, "package.json");
+		let manifest;
+		try {
+			const parsed = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
+			if (!isRecord(parsed)) continue;
+			manifest = parsed;
+		} catch {
+			continue;
+		}
+		if (manifest.name === "@agimon-ai/log-sink-mcp") found.push(directory);
+		if (manifest.name === TURSO_DATABASE_PACKAGE || manifest.name === "sqlite-vec" || manifest.name === "ruvector-onnx-embeddings-wasm" || manifest.name === "@napi-rs/keyring") {
+			found.push(directory);
+			continue;
+		}
+		for (const dependency of packageDependencyNames(manifest)) {
+			const resolved = resolvePackageDirectory(dependency, manifestPath);
+			if (resolved) queue.push(resolved);
+		}
+	}
+	return found;
+}
+function currentTursoPlatformPackage() {
+	let suffix = `${process.platform}-${process.arch}`;
+	if (process.platform === "linux") {
+		const report = process.report.getReport();
+		if (!isRecord(report) || !isRecord(report.header) || typeof report.header.glibcVersionRuntime !== "string") return;
+		suffix += "-gnu";
+	} else if (process.platform === "win32") suffix += "-msvc";
+	return `${TURSO_DATABASE_PACKAGE}-${suffix}`;
+}
+function tursoPlatformResource(packageDirectory) {
+	const packageName = currentTursoPlatformPackage();
+	if (!packageName) return void 0;
+	const manifest = JSON.parse(node_fs.default.readFileSync(node_path.default.join(packageDirectory, "package.json"), "utf8"));
+	if (!isRecord(manifest) || !isRecord(manifest.optionalDependencies) || typeof manifest.optionalDependencies[packageName] !== "string") return;
+	let entry;
+	try {
+		entry = (0, node_module.createRequire)(node_path.default.join(packageDirectory, "package.json")).resolve(packageName);
+	} catch {
+		return;
+	}
+	const nativeDirectory = packageManifestDirectory(entry);
+	if (!nativeDirectory) return void 0;
+	const relative = node_path.default.relative(nativeDirectory, canonicalPath(entry)).split(node_path.default.sep).join("/");
+	if (!relative || relative.startsWith("../") || node_path.default.isAbsolute(relative)) return void 0;
+	return {
+		packageName,
+		packageDirectory: nativeDirectory,
+		files: [{ path: "package.json" }, { path: relative }]
+	};
+}
+function currentSqliteVecPlatformPackage() {
+	if (process.platform === "linux" && currentTursoPlatformPackage() === void 0) return void 0;
+	const target = `${process.platform === "win32" ? "windows" : process.platform}-${process.arch}`;
+	if (![
+		"darwin-arm64",
+		"darwin-x64",
+		"linux-arm64",
+		"linux-x64",
+		"windows-x64"
+	].includes(target)) return void 0;
+	return `sqlite-vec-${target}`;
+}
+function sqliteVecPlatformResource(packageDirectory) {
+	const packageName = currentSqliteVecPlatformPackage();
+	if (!packageName) return void 0;
+	const manifest = JSON.parse(node_fs.default.readFileSync(node_path.default.join(packageDirectory, "package.json"), "utf8"));
+	if (!isRecord(manifest) || !isRecord(manifest.optionalDependencies) || typeof manifest.optionalDependencies[packageName] !== "string") return void 0;
+	const suffix = process.platform === "win32" ? "dll" : process.platform === "darwin" ? "dylib" : "so";
+	let entry;
+	try {
+		entry = (0, node_module.createRequire)(node_path.default.join(packageDirectory, "package.json")).resolve(`${packageName}/vec0.${suffix}`);
+	} catch {
+		return;
+	}
+	const nativeDirectory = packageManifestDirectory(entry);
+	if (!nativeDirectory) return void 0;
+	const relative = node_path.default.relative(nativeDirectory, canonicalPath(entry)).split(node_path.default.sep).join("/");
+	if (!relative || relative.startsWith("../") || node_path.default.isAbsolute(relative)) return void 0;
+	return {
+		packageName,
+		packageDirectory: nativeDirectory,
+		files: [{ path: "package.json" }, { path: relative }]
+	};
+}
+function vectorWasmResource(packageDirectory) {
+	const manifest = JSON.parse(node_fs.default.readFileSync(node_path.default.join(packageDirectory, "package.json"), "utf8"));
+	if (!isRecord(manifest) || !Array.isArray(manifest.files) || !manifest.files.every((file) => typeof file === "string") || !manifest.files.includes("ruvector_onnx_embeddings_wasm.js") || !manifest.files.includes("ruvector_onnx_embeddings_wasm_bg.wasm") || !manifest.files.includes("loader.js")) throw new Error("Unsupported embedding WASM resource manifest");
+	return {
+		packageName: "ruvector-onnx-embeddings-wasm",
+		packageDirectory,
+		files: ["package.json", ...manifest.files].map((file) => ({ path: file }))
+	};
+}
+function keyringResources(packageDirectory) {
+	const suffix = currentTursoPlatformPackage()?.slice(23);
+	const packageName = suffix && `@napi-rs/keyring${suffix}`;
+	const manifestPath = node_path.default.join(packageDirectory, "package.json");
+	const manifest = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
+	if (!packageName || !isRecord(manifest) || !isRecord(manifest.optionalDependencies) || typeof manifest.optionalDependencies[packageName] !== "string") throw new Error("Unsupported or missing native keyring binding");
+	const nativeDirectory = resolvePackageDirectory(packageName, manifestPath);
+	if (!nativeDirectory) throw new Error("Unsupported or missing native keyring binding");
+	const entry = (0, node_module.createRequire)(manifestPath).resolve(packageName);
+	return [{
+		packageName: "@napi-rs/keyring",
+		packageDirectory,
+		files: [
+			"package.json",
+			"index.js",
+			"keytar.js"
+		].map((file) => ({ path: file }))
+	}, {
+		packageName,
+		packageDirectory: nativeDirectory,
+		files: [{ path: "package.json" }, { path: node_path.default.relative(nativeDirectory, canonicalPath(entry)).split(node_path.default.sep).join("/") }]
+	}];
+}
+function resourcesWithPinnedNativePlatforms(entries, resources = []) {
+	const pinned = resources.map((resource) => ({
+		...resource,
+		packages: [...resource.packages]
+	}));
+	const packagesByName = new Map(pinned.flatMap((resource) => resource.packages.map((pkg) => [pkg.packageName, pkg])));
+	for (const directory of nativePackageDirectories(entries)) {
+		const manifest = JSON.parse(node_fs.default.readFileSync(node_path.default.join(directory, "package.json"), "utf8"));
+		if (manifest.name === "@agimon-ai/log-sink-mcp") {
+			if (!pinned.some((resource) => canonicalPath(resource.ownerDirectory) === canonicalPath(directory))) pinned.push({
+				ownerPackageName: manifest.name,
+				ownerDirectory: directory,
+				packages: []
+			});
+			continue;
+		}
+		if (manifest.name === "@napi-rs/keyring") {
+			for (const pkg of keyringResources(directory)) {
+				const existing = packagesByName.get(pkg.packageName);
+				if (existing) {
+					if (canonicalPath(existing.packageDirectory) !== canonicalPath(pkg.packageDirectory)) throw new Error(`Conflicting native package roots for ${pkg.packageName}`);
+					continue;
+				}
+				packagesByName.set(pkg.packageName, pkg);
+				pinned.push({
+					ownerPackageName: pkg.packageName,
+					ownerDirectory: pkg.packageDirectory,
+					packages: [pkg]
+				});
+			}
+			continue;
+		}
+		const sqliteVec = manifest.name === "sqlite-vec";
+		const platform = manifest.name === "ruvector-onnx-embeddings-wasm" ? vectorWasmResource(directory) : sqliteVec ? sqliteVecPlatformResource(directory) : tursoPlatformResource(directory);
+		if (!platform) throw new Error(`Unsupported or missing native ${sqliteVec ? "sqlite-vec" : "Turso"} binding for ${process.platform}-${process.arch}`);
+		const existing = packagesByName.get(platform.packageName);
+		if (existing) {
+			if (canonicalPath(existing.packageDirectory) !== canonicalPath(platform.packageDirectory)) throw new Error(`Conflicting native package roots for ${platform.packageName}`);
+			continue;
+		}
+		packagesByName.set(platform.packageName, platform);
+		pinned.push({
+			ownerPackageName: platform.packageName,
+			ownerDirectory: platform.packageDirectory,
+			packages: [platform]
+		});
+	}
+	return pinned;
+}
+function tursoPlatformIsPinned(resources) {
+	const packageName = currentTursoPlatformPackage();
+	return packageName !== void 0 && resources.some((resource) => resource.packages.some((pkg) => pkg.packageName === packageName));
+}
+function directModuleDependencyIsPinned(root, resources) {
+	if (root === "ruvector-onnx-embeddings-wasm" || root === "@napi-rs/keyring") return resources.some((resource) => resource.packages.some((pkg) => pkg.packageName === root));
+	if (root === "sqlite-vec") {
+		const packageName = currentSqliteVecPlatformPackage();
+		return packageName !== void 0 && resources.some((resource) => resource.packages.some((pkg) => pkg.packageName === packageName));
+	}
+	return (root === TURSO_DATABASE_PACKAGE || root === TURSO_DATABASE_COMMON_PACKAGE) && tursoPlatformIsPinned(resources);
+}
+function externalLogicalPath(sourcePath) {
+	const identity = (0, node_crypto.createHash)("sha256").update(sourcePath).digest("hex");
+	return `${EXTERNAL_INPUT_PREFIX}${identity}`;
+}
+function logicalInput(target, repositoryRoot) {
+	const absolute = canonicalPath(target);
+	if (isInside(repositoryRoot, absolute)) return {
+		logicalPath: `${REPOSITORY_INPUT_PREFIX}${node_path.default.relative(repositoryRoot, absolute).split(node_path.default.sep).join("/")}`,
+		target: absolute
+	};
+	return {
+		logicalPath: externalLogicalPath(absolute),
+		target: absolute,
+		sourcePath: absolute
+	};
+}
+function resolveLogicalInputPath(input, repositoryRoot) {
+	if (input.logicalPath.startsWith(REPOSITORY_INPUT_PREFIX) && input.sourcePath === void 0) {
+		const target = node_path.default.resolve(repositoryRoot, input.logicalPath.slice(5));
+		return isInside(repositoryRoot, target) ? target : void 0;
+	}
+	if (input.logicalPath.startsWith(EXTERNAL_INPUT_PREFIX) && input.sourcePath !== void 0 && input.logicalPath === externalLogicalPath(input.sourcePath)) return input.sourcePath;
+}
+function artifactsAreFresh(manifest, version, output) {
+	return manifest.version === version && manifest.output === output && node_fs.default.existsSync(output) && manifest.artifacts.every((artifact) => node_fs.default.existsSync(artifact));
+}
+function manifestIsFresh(manifest, entries) {
+	if (!artifactsAreFresh(manifest, SET_CACHE_VERSION, manifest.output)) return false;
+	if (JSON.stringify(manifest.entries) !== JSON.stringify(entries)) return false;
+	if (manifest.artifactInputs === void 0 || !require_inputs.inputsAreFresh(manifest.artifactInputs)) return false;
+	return require_inputs.inputsAreFresh(manifest.inputs);
+}
+function readCompiledExtensionManifest(manifestPath) {
+	try {
+		const parsed = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
+		return parsed && typeof parsed.output === "string" && Array.isArray(parsed.artifacts) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function readSetManifest(manifestPath) {
+	const parsed = readCompiledExtensionManifest(manifestPath);
+	return parsed && Array.isArray(parsed.entries) && Array.isArray(parsed.inputs) ? parsed : void 0;
+}
+function writeAtomic(target, contents, mode = 384) {
+	node_fs.default.mkdirSync(node_path.default.dirname(target), { recursive: true });
+	const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+	node_fs.default.writeFileSync(temporary, contents, { mode });
+	try {
+		node_fs.default.renameSync(temporary, target);
+		node_fs.default.chmodSync(target, mode);
+	} catch (error) {
+		node_fs.default.rmSync(temporary, { force: true });
+		throw error;
+	}
+}
+function splitOutputOptions(entryFileNames) {
+	return {
+		format: "esm",
+		sourcemap: false,
+		minify: true,
+		codeSplitting: true,
+		hashCharacters: "hex",
+		entryFileNames,
+		chunkFileNames: `chunks/[name].[hash:${HASH_LENGTH}]${COMPILED_SUFFIX}`,
+		assetFileNames: `assets/[name].[hash:${HASH_LENGTH}][extname]`
+	};
+}
+function artifactTarget(outputDirectory, artifact) {
+	const target = node_path.default.resolve(outputDirectory, artifact.fileName);
+	const relative = node_path.default.relative(outputDirectory, target);
+	if (relative.startsWith("..") || node_path.default.isAbsolute(relative)) throw new Error(`Rolldown emitted an artifact outside the output directory: ${artifact.fileName}`);
+	return target;
+}
+function artifactMatches(target, contents) {
+	try {
+		const current = node_fs.default.readFileSync(target);
+		const generated = typeof contents === "string" ? Buffer.from(contents) : Buffer.from(contents);
+		return current.equals(generated);
+	} catch {
+		return false;
+	}
+}
+/** Writes referenced chunks first so a visible entry always has a complete graph. */
+function writeCompiledGraph(generated, outputDirectory) {
+	const entry = generated.output.find((artifact) => artifact.type === "chunk" && artifact.isEntry);
+	if (!entry || entry.type !== "chunk") throw new Error("Rolldown produced no extension entry");
+	const root = node_path.default.resolve(outputDirectory);
+	const remaining = generated.output.filter((artifact) => artifact !== entry);
+	for (const artifact of [...remaining, entry]) {
+		const contents = artifact.type === "chunk" ? artifact.code : artifact.source;
+		const target = artifactTarget(root, artifact);
+		if (!artifactMatches(target, contents)) writeAtomic(target, contents);
+	}
+	return {
+		entry: artifactTarget(root, entry),
+		artifacts: generated.output.map((artifact) => artifactTarget(root, artifact)).sort()
+	};
+}
+function resourceInputPaths(resources = []) {
+	return resources.flatMap((resource) => resource.packages.map((pkg) => pkg.files.map((file) => node_path.default.resolve(pkg.packageDirectory, file.path))).flat());
+}
+function validateResourcePackageName(name) {
+	if (!/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u.test(name)) throw new Error(`Invalid resource package name: ${name}`);
+}
+function resourceArtifacts(resources = []) {
+	const artifacts = /* @__PURE__ */ new Map();
+	const owners = /* @__PURE__ */ new Set();
+	for (const resource of resources) {
+		validateResourcePackageName(resource.ownerPackageName);
+		const owner = canonicalPath(resource.ownerDirectory);
+		if (owners.has(owner)) throw new Error(`Duplicate resource owner: ${owner}`);
+		owners.add(owner);
+		for (const pkg of resource.packages) {
+			validateResourcePackageName(pkg.packageName);
+			for (const file of pkg.files) {
+				if (!file.path || file.path.includes("\\") || node_path.default.isAbsolute(file.path) || file.path.split("/").some((part) => !part || part === "./index" || part === "..")) throw new Error(`Invalid resource path: ${file.path}`);
+				if (file.mode !== void 0 && (!Number.isInteger(file.mode) || file.mode < 0 || file.mode > 511)) throw new Error(`Invalid resource mode: ${file.mode}`);
+				const source = canonicalPath(node_path.default.resolve(pkg.packageDirectory, file.path));
+				if (!isInside(canonicalPath(pkg.packageDirectory), source)) throw new Error(`Resource escapes package: ${file.path}`);
+				const stat = node_fs.default.statSync(source);
+				if (!stat.isFile()) throw new Error(`Resource is not a file: ${source}`);
+				const artifact = `node_modules/${pkg.packageName}/${file.path}`;
+				if (artifacts.has(artifact)) throw new Error(`Duplicate resource artifact: ${artifact}`);
+				artifacts.set(artifact, {
+					contents: node_fs.default.readFileSync(source),
+					mode: file.mode ?? stat.mode & 511
+				});
+			}
+		}
+	}
+	return artifacts;
+}
+/** Bind resource layout and permissions as well as input bytes to the cache identity. */
+function resourceCacheKey(resources = [], artifacts, repositoryRoot) {
+	if (resources.length === 0) return "";
+	const identity = (directory) => repositoryRoot ? logicalInput(directory, repositoryRoot).logicalPath : canonicalPath(directory);
+	return (0, node_crypto.createHash)("sha256").update(JSON.stringify({
+		resources: resources.map((resource) => ({
+			ownerPackageName: resource.ownerPackageName,
+			ownerDirectory: identity(resource.ownerDirectory),
+			packages: resource.packages.map((pkg) => ({
+				...pkg,
+				packageDirectory: identity(pkg.packageDirectory)
+			}))
+		})),
+		modes: [...artifacts].map(([name, asset]) => [name, asset.mode])
+	})).digest("hex");
+}
+function validateResourceOutputPaths(outputDirectory, artifacts) {
+	for (const artifact of artifacts.keys()) {
+		let target = canonicalPath(outputDirectory);
+		for (const segment of artifact.split("/")) {
+			target = node_path.default.join(target, segment);
+			try {
+				if (node_fs.default.lstatSync(target).isSymbolicLink()) throw new Error(`Resource output contains a symlink: ${artifact}`);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+		}
+	}
+}
+function resourceArtifactsAreFresh(outputDirectory, artifacts) {
+	for (const [artifact, asset] of artifacts) {
+		const target = node_path.default.join(outputDirectory, artifact);
+		try {
+			if (!isInside(canonicalPath(outputDirectory), canonicalPath(target)) || !artifactMatches(target, asset.contents) || (node_fs.default.statSync(target).mode & 511) !== asset.mode) return false;
+		} catch {
+			return false;
+		}
+	}
+	return true;
+}
+function resourceModuleUrl(id, outputDirectory, resources = []) {
+	const resource = resources.find((candidate) => isInside(canonicalPath(candidate.ownerDirectory), canonicalPath(id)));
+	if (!resource) return void 0;
+	const relative = node_path.default.relative(canonicalPath(resource.ownerDirectory), canonicalPath(id));
+	return (0, node_url.pathToFileURL)(node_path.default.join(outputDirectory, "node_modules", resource.ownerPackageName, relative)).href;
+}
+function sharedLookupKey(entries, outputName) {
+	return (0, node_crypto.createHash)("sha256").update(SHARED_BUILD_VERSION).update(process.version).update(process.platform).update(process.arch).update(outputName).update(JSON.stringify(entries.map((entry) => entry.logicalPath))).digest("hex");
+}
+function tokenizedInputs(inputs, repositoryRoot) {
+	const logical = [];
+	for (const target of inputs) logical.push(logicalInput(target, repositoryRoot));
+	logical.sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
+	const shared = [{
+		logicalPath: REPOSITORY_INPUT_PREFIX,
+		sha256: "",
+		token: `${SHARED_PATH_TOKEN_PREFIX}ROOT__`
+	}];
+	const byTarget = /* @__PURE__ */ new Map([[repositoryRoot, `${SHARED_PATH_TOKEN_PREFIX}ROOT__`]]);
+	const tokenByLogicalPath = /* @__PURE__ */ new Map();
+	logical.forEach((input, index) => {
+		const existing = tokenByLogicalPath.get(input.logicalPath);
+		const token = existing ?? `${SHARED_PATH_TOKEN_PREFIX}${String(index)}__`;
+		if (!existing) {
+			shared.push({
+				logicalPath: input.logicalPath,
+				sha256: require_cache.contentSha256(node_fs.default.readFileSync(input.target)),
+				token,
+				...input.sourcePath ? { sourcePath: input.sourcePath } : {}
+			});
+			tokenByLogicalPath.set(input.logicalPath, token);
+		}
+		byTarget.set(node_path.default.resolve(input.target), token);
+	});
+	for (const target of inputs) {
+		const input = logicalInput(target, repositoryRoot);
+		const token = tokenByLogicalPath.get(input.logicalPath);
+		if (token) byTarget.set(node_path.default.resolve(target), token);
+	}
+	return {
+		shared,
+		byTarget
+	};
+}
+function tokenizedArtifactContents(generated, tokens, outputDirectory) {
+	const artifacts = /* @__PURE__ */ new Map();
+	const outputToken = `${SHARED_PATH_TOKEN_PREFIX}OUTPUT__`;
+	const replacements = [...tokens.entries()].sort(([left], [right]) => right.length - left.length);
+	for (const artifact of generated.output) {
+		if (artifact.type === "asset") {
+			artifacts.set(artifact.fileName, typeof artifact.source === "string" ? artifact.source : artifact.source);
+			continue;
+		}
+		let source = artifact.code.replaceAll((0, node_url.pathToFileURL)(outputDirectory).href, `${outputToken}:url`).replaceAll(outputDirectory, outputToken);
+		for (const [target, token] of replacements) source = source.replaceAll((0, node_url.pathToFileURL)(target).href, `${token}:url`).replaceAll(pathToImportSpecifier(target), token).replaceAll(target, token);
+		artifacts.set(artifact.fileName, source);
+	}
+	return artifacts;
+}
+function writeLocalSetManifest(manifestPath, entries, output, artifacts, inputs) {
+	const fingerprintAll = (paths) => [...paths].map((target) => require_inputs.fingerprintInput(target)).filter((value) => value !== void 0).sort((left, right) => left.path.localeCompare(right.path));
+	const sortedArtifacts = [...artifacts].sort();
+	writeAtomic(manifestPath, `${JSON.stringify({
+		version: SET_CACHE_VERSION,
+		entries,
+		output,
+		artifacts: sortedArtifacts,
+		inputs: fingerprintAll([...inputs]),
+		artifactInputs: fingerprintAll([output, ...sortedArtifacts])
+	}, null, 2)}\n`);
+}
+function materializeSharedSet(build, outputDirectory, manifestPath, entries) {
+	const output = require_cache.materializeSharedBuild(build, outputDirectory);
+	const inputs = new Set(build.replacements.values());
+	writeLocalSetManifest(manifestPath, entries, output, build.manifest.artifacts.map((artifact) => node_path.default.join(outputDirectory, artifact.path)), inputs);
+	return output;
+}
+/** Stable lookup key for one exact Pi load order. */
+function extensionSetKey(entries) {
+	return (0, node_crypto.createHash)("sha256").update(SET_CACHE_VERSION).update(JSON.stringify(entries.map((entry) => node_path.default.resolve(entry)))).digest("hex").slice(0, HASH_LENGTH);
+}
+function extensionSetSource(entries) {
+	const helper = (0, _agimon_ai_doompi_core_module_resolution.optionalPackageEntry)(EXTENSION_SOURCE_HELPER, require("url").pathToFileURL(__filename).href);
+	if (!helper) throw new Error(`Cannot resolve ${EXTENSION_SOURCE_HELPER}`);
+	const loaders = entries.map((entry) => `() => import(${javascriptStringLiteral(pathToImportSpecifier(entry))})`);
+	const names = entries.map((entry) => javascriptStringLiteral(entry));
+	return [
+		`import { withExtensionSource } from ${javascriptStringLiteral(pathToImportSpecifier(helper))};`,
+		`const loaders = [${loaders.join(",")}];`,
+		`const names = [${names.join(",")}];`,
+		"function report(index, phase, startedAt, error) {",
+		"  const elapsed = (performance.now() - startedAt).toFixed(1);",
+		"  const detail = error instanceof Error ? \": \" + error.message : error === undefined ? \"\" : \": \" + String(error);",
+		"  process.stderr.write(\"[doompi:timing] \" + phase + \" \" + elapsed + \"ms \" + names[index] + detail + \"\\n\");",
+		"}",
+		"export default async function doompiExtensionSet(pi) {",
+		"  const timings = process.env.DOOMPI_TIMING === \"1\" || process.env.PI_TIMING === \"1\";",
+		"  const loaded = await Promise.all(loaders.map(async (load, index) => {",
+		"    const startedAt = performance.now();",
+		"    try {",
+		"      const extension = await load();",
+		"      if (timings) report(index, \"import\", startedAt);",
+		"      return extension;",
+		"    } catch (error) {",
+		"      report(index, \"import-error\", startedAt, error);",
+		"      return undefined;",
+		"    }",
+		"  }));",
+		"  for (let index = 0; index < loaded.length; index += 1) {",
+		"    const extension = loaded[index];",
+		"    if (!extension) continue;",
+		"    const startedAt = performance.now();",
+		"    try {",
+		"      const factory = extension.default;",
+		"      if (typeof factory !== 'function') throw new Error('does not export an extension factory');",
+		"      await factory(withExtensionSource(pi, names[index]));",
+		"      if (timings) report(index, \"factory\", startedAt);",
+		"    } catch (error) {",
+		"      report(index, \"factory-error\", startedAt, error);",
+		"    }",
+		"  }",
+		"}"
+	].join("\n");
+}
+function pathToImportSpecifier(target) {
+	return node_path.default.resolve(target).split(node_path.default.sep).join("/");
+}
+function setExternalResolver(inputs, kind, entry, resources = []) {
+	return {
+		name: "doom-set-external",
+		async resolveId(specifier, importer, options) {
+			if (specifier === VIRTUAL_SET_ENTRY) return null;
+			if (NODE_BUILTINS.has(specifier) || specifier.startsWith("node:")) return {
+				id: specifier,
+				external: true
+			};
+			if (node_path.default.isAbsolute(specifier)) {
+				if (!importer && entry && node_path.default.resolve(specifier) === node_path.default.resolve(entry)) return null;
+				const root = packageRootFromPath(specifier);
+				if (root && kind === "module" && DIRECT_EXTERNAL_PACKAGES.has(root)) {
+					inputs.add(specifier);
+					return {
+						id: specifier,
+						external: true
+					};
+				}
+				if (root && kind === "module" && directModuleDependencyIsUnbundlable(root) && !directModuleDependencyIsPinned(root, resources)) throw directModuleDependencyError(root, importer);
+				if (root === "@napi-rs/keyring" && kind === "module" && directModuleDependencyIsPinned(root, resources)) {
+					const directory = packageManifestDirectory(specifier);
+					if (!directory) throw directModuleDependencyError(root, importer);
+					return {
+						id: `${root}/${node_path.default.relative(directory, canonicalPath(specifier)).split(node_path.default.sep).join("/")}`,
+						external: true
+					};
+				}
+				if (root && (HOSTED_PACKAGES.has(root) || NATIVE_PACKAGES.has(root) || kind === "pi-set" && STARTUP_EXTERNAL_PACKAGES.has(root))) {
+					inputs.add(specifier);
+					return {
+						id: specifier,
+						external: true
+					};
+				}
+				return null;
+			}
+			if (specifier.startsWith("./index")) return null;
+			const renamed = renameScope(specifier);
+			const root = packageRootOf(renamed);
+			if (root && HOSTED_PACKAGES.has(root)) {
+				const hosted = (0, _agimon_ai_doompi_core_module_resolution.optionalPackageEntry)(renamed, require("url").pathToFileURL(__filename).href);
+				if (hosted) {
+					inputs.add(hosted);
+					return {
+						id: hosted,
+						external: true
+					};
+				}
+			}
+			if (root === "typebox") {
+				const typebox = piExtensionDependencyEntry(renamed);
+				if (typebox) {
+					inputs.add(typebox);
+					return {
+						id: typebox,
+						external: kind === "pi-set"
+					};
+				}
+			}
+			if (root && kind === "module" && DIRECT_EXTERNAL_PACKAGES.has(root)) {
+				const resolved = await this.resolve(renamed, importer, options);
+				if (resolved) {
+					inputs.add(resolved.id);
+					return {
+						id: resolved.id,
+						external: true
+					};
+				}
+			}
+			if (root && kind === "module" && directModuleDependencyIsUnbundlable(root) && !directModuleDependencyIsPinned(root, resources)) throw directModuleDependencyError(root, importer);
+			if (root === "@napi-rs/keyring" && kind === "module" && directModuleDependencyIsPinned(root, resources)) return {
+				id: renamed,
+				external: true
+			};
+			if (root && kind === "pi-set" && (NATIVE_PACKAGES.has(root) || STARTUP_EXTERNAL_PACKAGES.has(root))) {
+				const resolved = await this.resolve(renamed, importer, options);
+				if (resolved) {
+					inputs.add(resolved.id);
+					return {
+						id: resolved.id,
+						external: true
+					};
+				}
+			}
+			return null;
+		}
+	};
+}
+function inputCollector(inputs) {
+	return {
+		name: "doom-set-inputs",
+		load(id) {
+			if (node_path.default.isAbsolute(id) && node_fs.default.existsSync(id)) inputs.add(id);
+			return null;
+		}
+	};
+}
+/** An unresolved bare import would otherwise become a broken dist external. */
+function failUnresolvedImport(_level, log, handler) {
+	if (log.code === "UNRESOLVED_IMPORT") handler("error", log);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectImportMetaUrlRanges(value, ranges) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectImportMetaUrlRanges(item, ranges);
+		return;
+	}
+	if (!isRecord(value)) return;
+	const object = value.object;
+	const property = value.property;
+	if (value.type === "MemberExpression" && value.computed === false && typeof value.start === "number" && typeof value.end === "number" && isRecord(object) && object.type === "MetaProperty" && isRecord(object.meta) && object.meta.name === "import" && isRecord(object.property) && object.property.name === "meta" && isRecord(property) && property.name === "url") {
+		ranges.push({
+			start: value.start,
+			end: value.end
+		});
+		return;
+	}
+	for (const child of Object.values(value)) collectImportMetaUrlRanges(child, ranges);
+}
+/** Keeps package-owned resource lookup anchored to each original source file. */
+function preserveImportMetaUrl(outputDirectory, resources = []) {
+	return {
+		name: "doom-original-import-meta-url",
+		transform(source, id) {
+			if (!node_path.default.isAbsolute(id) || !source.includes("import.meta.url")) return null;
+			const packageRoot = packageRootFromPath(id);
+			if (packageRoot === TURSO_DATABASE_PACKAGE || packageRoot === TURSO_DATABASE_COMMON_PACKAGE) return null;
+			const extension = node_path.default.extname(id).toLowerCase();
+			const lang = extension === ".tsx" ? "tsx" : extension === ".jsx" ? "jsx" : isTypeScriptEntry(id) ? "ts" : "js";
+			const ranges = [];
+			collectImportMetaUrlRanges(this.parse(source, { lang }), ranges);
+			if (ranges.length === 0) return null;
+			const replacement = javascriptStringLiteral(resourceModuleUrl(id, outputDirectory, resources) ?? (0, node_url.pathToFileURL)(id).href);
+			let transformed = source;
+			for (const range of ranges.sort((left, right) => right.start - left.start)) transformed = `${transformed.slice(0, range.start)}${replacement}${transformed.slice(range.end)}`;
+			return transformed;
+		}
+	};
+}
+/** Location of the lightweight input-fingerprint record for one extension set. */
+function extensionSetManifestPath(entries, cacheDirectory, options = {}) {
+	const key = extensionSetKey(entries.map((entry) => node_path.default.resolve(entry)));
+	const outputDirectory = node_path.default.resolve(options.outputDirectory ?? node_path.default.join(cacheDirectory, SET_DIRECTORY));
+	const outputName = safeOutputName(options.outputName ?? DEFAULT_SET_OUTPUT_NAME);
+	const outputKey = (0, node_crypto.createHash)("sha256").update(outputDirectory).update(outputName).digest("hex").slice(0, HASH_LENGTH);
+	return node_path.default.join(cacheDirectory, SET_DIRECTORY, `${key}.${outputKey}${MANIFEST_SUFFIX}`);
+}
+/**
+* Compiles an ordered extension set into one native ESM entry.
+*
+* The generated entry starts every module load together, then invokes factories
+* sequentially in activation order. Its manifest records every loaded module,
+* so a dependency edit invalidates the cache without running the compiler.
+*/
+async function compileExtensionSet(entries, cacheDirectory, options = {}) {
+	return compileGraph(entries, cacheDirectory, options, "pi-set");
+}
+/** Exact compiler receipt used by sync to validate a direct module without importing it. */
+function extensionModuleManifestPath(entry, cacheDirectory, options = {}) {
+	const root = options.repositoryRoot ? canonicalPath(options.repositoryRoot) : void 0;
+	const resources = resourcesWithPinnedNativePlatforms([node_path.default.resolve(entry)], options.resources);
+	const resourceKey = resourceCacheKey(resources, resourceArtifacts(resources), root);
+	const base = `${extensionSetManifestPath([entry], cacheDirectory, options)}.module.json`;
+	return resourceKey ? `${base}.${resourceKey}.json` : base;
+}
+/** Preserve a module's exports instead of wrapping its default in a Pi factory.
+* External dependency and resource policies remain those of the shared compiler.
+*/
+async function compileExtensionModule(entry, cacheDirectory, options = {}) {
+	return compileGraph([entry], cacheDirectory, options, "module");
+}
+async function compileGraph(entries, cacheDirectory, options, kind) {
+	if (entries.length === 0) throw new Error("Cannot compile an empty extension set");
+	const normalized = entries.map((entry) => node_path.default.resolve(entry));
+	const setDirectory = node_path.default.join(cacheDirectory, SET_DIRECTORY);
+	node_fs.default.mkdirSync(setDirectory, { recursive: true });
+	const outputDirectory = node_path.default.resolve(options.outputDirectory ?? setDirectory);
+	const outputName = safeOutputName(options.outputName ?? DEFAULT_SET_OUTPUT_NAME);
+	node_fs.default.mkdirSync(outputDirectory, { recursive: true });
+	const repositoryRoot = options.repositoryRoot ? canonicalPath(options.repositoryRoot) : void 0;
+	const effectiveResources = kind === "module" ? resourcesWithPinnedNativePlatforms(normalized, options.resources) : [...options.resources ?? []];
+	const resources = resourceArtifacts(effectiveResources);
+	validateResourceOutputPaths(outputDirectory, resources);
+	const resourceKey = resourceCacheKey(effectiveResources, resources, repositoryRoot);
+	const setManifestPath = extensionSetManifestPath(normalized, cacheDirectory, options);
+	const manifestPath = kind === "module" ? extensionModuleManifestPath(normalized[0], cacheDirectory, options) : resourceKey ? `${setManifestPath}.${resourceKey}.json` : setManifestPath;
+	const previous = readSetManifest(manifestPath);
+	if (previous && manifestIsFresh(previous, normalized) && resourceArtifactsAreFresh(outputDirectory, resources)) return previous.output;
+	const resourceInputs = resourceInputPaths(effectiveResources);
+	const generate = async () => {
+		const inputs = /* @__PURE__ */ new Set([...normalized, ...resourceInputs]);
+		const source = extensionSetSource(normalized);
+		const { rolldown } = await import("rolldown");
+		const build = await rolldown({
+			input: kind === "module" ? normalized[0] : VIRTUAL_SET_ENTRY,
+			platform: "node",
+			plugins: [
+				{
+					name: "doom-set-entry",
+					resolveId(id) {
+						return id === VIRTUAL_SET_ENTRY ? id : null;
+					},
+					load(id) {
+						return id === VIRTUAL_SET_ENTRY ? source : null;
+					}
+				},
+				setExternalResolver(inputs, kind, normalized[0], effectiveResources),
+				preserveImportMetaUrl(outputDirectory, effectiveResources),
+				inputCollector(inputs)
+			],
+			onLog: failUnresolvedImport
+		});
+		try {
+			return {
+				generated: await build.generate(splitOutputOptions(`${outputName}.[hash:${HASH_LENGTH}]${COMPILED_SUFFIX}`)),
+				inputs
+			};
+		} finally {
+			await build.close();
+		}
+	};
+	if (repositoryRoot && options.sharedCacheDirectory) {
+		const setLookupKey = sharedLookupKey([...normalized, ...resourceInputs].map((entry) => logicalInput(entry, repositoryRoot)), outputName);
+		const lookupKey = kind === "module" || resourceKey ? (0, node_crypto.createHash)("sha256").update(kind).update(":").update(setLookupKey).update(resourceKey).digest("hex") : setLookupKey;
+		const resolveInput = (input) => resolveLogicalInputPath(input, repositoryRoot);
+		return require_cache.withSharedBuildLock(options.sharedCacheDirectory, lookupKey, async () => {
+			const cached = require_cache.findSharedBuild(options.sharedCacheDirectory, lookupKey, resolveInput);
+			if (cached) return materializeSharedSet(cached, outputDirectory, manifestPath, normalized);
+			const { generated, inputs } = await generate();
+			const tokenized = tokenizedInputs(inputs, repositoryRoot);
+			const artifacts = tokenizedArtifactContents(generated, tokenized.byTarget, outputDirectory);
+			for (const [artifactPath, asset] of resources) {
+				if (artifacts.has(artifactPath)) throw new Error(`Duplicate resource artifact: ${artifactPath}`);
+				artifacts.set(artifactPath, asset);
+			}
+			if ([...artifacts.values()].some((contents) => typeof contents === "string" && contents.includes(repositoryRoot))) throw new Error("Shared build graph still contains an absolute worktree path after tokenization");
+			const entry = generated.output.find((artifact) => artifact.type === "chunk" && artifact.isEntry);
+			if (!entry) throw new Error("Rolldown produced no shared extension entry");
+			require_cache.publishSharedBuild({
+				cacheDirectory: options.sharedCacheDirectory,
+				lookupKey,
+				entry: entry.fileName,
+				inputs: tokenized.shared,
+				artifacts
+			});
+			const published = require_cache.findSharedBuild(options.sharedCacheDirectory, lookupKey, resolveInput);
+			if (!published) throw new Error("Published shared build could not be verified");
+			return materializeSharedSet(published, outputDirectory, manifestPath, normalized);
+		});
+	}
+	const { generated, inputs } = await generate();
+	const compiled = writeCompiledGraph(generated, outputDirectory);
+	const resourceFiles = [];
+	for (const [artifact, asset] of resources) {
+		const target = node_path.default.resolve(canonicalPath(outputDirectory), artifact);
+		if (!isInside(canonicalPath(outputDirectory), canonicalPath(target))) throw new Error(`Resource escapes output: ${artifact}`);
+		node_fs.default.mkdirSync(node_path.default.dirname(target), {
+			recursive: true,
+			mode: 448
+		});
+		writeAtomic(target, asset.contents, asset.mode ?? 384);
+		resourceFiles.push(target);
+	}
+	writeLocalSetManifest(manifestPath, normalized, compiled.entry, [...compiled.artifacts, ...resourceFiles], inputs);
+	return compiled.entry;
+}
+//#endregion
+exports.compileExtensionModule = compileExtensionModule;
+exports.compileExtensionSet = compileExtensionSet;
+exports.extensionModuleManifestPath = extensionModuleManifestPath;
+exports.extensionSetKey = extensionSetKey;
+exports.extensionSetManifestPath = extensionSetManifestPath;
+exports.isTypeScriptEntry = isTypeScriptEntry;
+
+//# sourceMappingURL=index.cjs.map