@zenbujs/core 0.0.1

package/dist/link-6roQ7Cn6.mjs

@@ -0,0 +1,580 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cli/commands/link.ts
+function findManifest(from) {
+	let dir = path.resolve(from);
+	while (true) {
+		const candidate = path.join(dir, "zenbu.plugin.json");
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+function findFileUp(from, name) {
+	let dir = path.resolve(from);
+	while (true) {
+		const candidate = path.join(dir, name);
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/** jsonc-lite: strips // and /* * / comments and trailing commas. */
+function readJsonLoose(filePath) {
+	const stripped = fs.readFileSync(filePath, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1").replace(/,\s*([\]}])/g, "$1");
+	return JSON.parse(stripped);
+}
+/**
+* Extract the `#registry/*` mapping from a tsconfig (typically a
+* gitignored `tsconfig.local.json`) and return the absolute directory it
+* resolves to. Returns null when the alias isn't declared.
+*/
+function readRegistryDirFromTsconfig(tsconfigPath) {
+	try {
+		const cfg = readJsonLoose(tsconfigPath);
+		const entry = cfg?.compilerOptions?.paths?.["#registry/*"];
+		if (!Array.isArray(entry) || typeof entry[0] !== "string") return null;
+		const trimmed = entry[0].replace(/\/\*$/, "");
+		const baseUrl = typeof cfg?.compilerOptions?.baseUrl === "string" ? path.resolve(path.dirname(tsconfigPath), cfg.compilerOptions.baseUrl) : path.dirname(tsconfigPath);
+		return path.resolve(baseUrl, trimmed);
+	} catch {
+		return null;
+	}
+}
+/**
+* An app root is the nearest ancestor (or self) that contains BOTH a
+* `zenbu.plugin.json` and a `config.json` whose `plugins` is an array.
+* That signature distinguishes the app from a bare plugin manifest.
+*/
+function findAppRoot(from) {
+	let dir = path.resolve(from);
+	while (true) {
+		const manifest = path.join(dir, "zenbu.plugin.json");
+		const config = path.join(dir, "config.json");
+		if (fs.existsSync(manifest) && fs.existsSync(config)) try {
+			const parsed = JSON.parse(fs.readFileSync(config, "utf8"));
+			if (Array.isArray(parsed?.plugins)) return dir;
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/**
+* Pick the directory `zen link` should write registry types into.
+* Resolution order:
+*   1. `--registry <dir>` flag / `ZENBU_REGISTRY_DIR` env (escape hatch)
+*   2. Nearest `tsconfig.local.json` ancestor's `#registry/*` mapping
+*      (canonical — this is the same path TS uses to resolve the alias)
+*   3. The manifest's `devAppPath` field (dev hint, fallback)
+*   4. Walk up to the host app root and use `<app>/types`
+*   5. Fail with a message that explains the available knobs
+*/
+function resolveRegistryDir(opts) {
+	if (opts.registryOverride) return path.resolve(opts.registryOverride);
+	if (process.env.ZENBU_REGISTRY_DIR) return path.resolve(process.env.ZENBU_REGISTRY_DIR);
+	const manifestDir = path.dirname(opts.manifestPath);
+	const tsconfigLocal = findFileUp(manifestDir, "tsconfig.local.json");
+	if (tsconfigLocal) {
+		const fromTs = readRegistryDirFromTsconfig(tsconfigLocal);
+		if (fromTs) return fromTs;
+	}
+	if (opts.manifest.devAppPath) return path.resolve(manifestDir, opts.manifest.devAppPath, "types");
+	const appRoot = findAppRoot(manifestDir);
+	if (appRoot) return path.join(appRoot, "types");
+	console.error(`zen link: could not determine target types directory for ${opts.manifestPath}.`);
+	console.error(`         Try one of:`);
+	console.error(`         • run from inside an app dir (with both zenbu.plugin.json and config.json),`);
+	console.error(`         • add a "devAppPath" field to ${path.basename(opts.manifestPath)} pointing at the host app,`);
+	console.error(`         • create a tsconfig.local.json with a "#registry/*" path mapping,`);
+	console.error(`         • or pass --registry <dir>.`);
+	process.exit(1);
+}
+function expandGlob(baseDir, pattern) {
+	if (!pattern.includes("*")) {
+		const full = path.resolve(baseDir, pattern);
+		return fs.existsSync(full) ? [full] : [];
+	}
+	const dir = path.resolve(baseDir, path.dirname(pattern));
+	const filePattern = path.basename(pattern);
+	const regex = new RegExp("^" + filePattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
+	try {
+		return fs.readdirSync(dir).filter((f) => regex.test(f)).map((f) => path.resolve(dir, f));
+	} catch {
+		return [];
+	}
+}
+function discoverServices(baseDir, serviceGlobs) {
+	const entries = [];
+	const classRe = /export\s+class\s+(\w+)\s+extends\s+(?:Service\b|serviceWithDeps\s*\()/;
+	const keyRe = /static\s+key\s*=\s*["']([^"']+)["']/;
+	for (const glob of serviceGlobs) for (const filePath of expandGlob(baseDir, glob)) {
+		const content = fs.readFileSync(filePath, "utf8");
+		const classMatch = content.match(classRe);
+		const keyMatch = content.match(keyRe);
+		if (classMatch && keyMatch) entries.push({
+			className: classMatch[1],
+			key: keyMatch[1],
+			filePath
+		});
+	}
+	return entries;
+}
+function relativeFromRegistry(registryDir, absPath) {
+	let rel = path.relative(registryDir, absPath);
+	if (!rel.startsWith(".")) rel = "./" + rel;
+	return rel.replace(/\.ts$/, "");
+}
+const SERVICE_BASE_LITERAL = [
+	`  | "evaluate"`,
+	`  | "shutdown"`,
+	`  | "constructor"`,
+	`  | "effect"`,
+	`  | "__cleanupAllEffects"`,
+	`  | "__effectCleanups"`,
+	`  | "ctx"`
+].join("\n");
+function generateServicesFile(registryDir, allServices) {
+	const imports = [];
+	const routerEntries = [];
+	const usedNames = /* @__PURE__ */ new Map();
+	function uniqueName(base) {
+		const count = usedNames.get(base) ?? 0;
+		usedNames.set(base, count + 1);
+		return count === 0 ? base : `${base}_${count}`;
+	}
+	for (const [, services] of allServices) for (const svc of services) {
+		const alias = uniqueName(svc.className);
+		const importPath = relativeFromRegistry(registryDir, svc.filePath);
+		imports.push(`import type { ${svc.className}${alias !== svc.className ? ` as ${alias}` : ""} } from "${importPath}"`);
+		const quotedKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(svc.key) ? svc.key : `"${svc.key}"`;
+		routerEntries.push(`  ${quotedKey}: ExtractRpcMethods<${alias}>`);
+	}
+	return [
+		"// Generated by: zen link",
+		"",
+		`import type { CoreServiceRouter } from "@zenbujs/core/registry"`,
+		...imports,
+		"",
+		`type ServiceBase =\n${SERVICE_BASE_LITERAL}`,
+		"",
+		"type ExtractRpcMethods<T> = {",
+		"  [K in Exclude<keyof T, ServiceBase | `_${string}`> as T[K] extends (",
+		"    ...args: any[]",
+		"  ) => any",
+		"    ? K",
+		"    : never]: T[K]",
+		"}",
+		"",
+		"export type PluginServiceRouter = {",
+		...routerEntries.map((e) => e + ";"),
+		"}",
+		"",
+		"export type ServiceRouter = CoreServiceRouter & PluginServiceRouter",
+		""
+	].join("\n");
+}
+function generatePreloadsFile(registryDir, allPreloads) {
+	const imports = [];
+	const entries = [];
+	const usedAliases = /* @__PURE__ */ new Map();
+	function uniqueAlias(base) {
+		const count = usedAliases.get(base) ?? 0;
+		usedAliases.set(base, count + 1);
+		return count === 0 ? base : `${base}${count}`;
+	}
+	for (const [, { name, preloadPath }] of allPreloads) {
+		const alias = uniqueAlias(`${name.replace(/(^|[-_])(\w)/g, (_m, _p, c) => _p ? c.toUpperCase() : c)}Preload`);
+		const importPath = relativeFromRegistry(registryDir, preloadPath);
+		imports.push(`import type { default as ${alias} } from "${importPath}"`);
+		const quotedName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
+		entries.push(`  ${quotedName}: Awaited<ReturnType<typeof ${alias}>>`);
+	}
+	return [
+		"// Generated by: zen link",
+		"",
+		`import type { CorePreloads } from "@zenbujs/core/registry"`,
+		...imports,
+		"",
+		"export type PluginPreloads = {",
+		...entries.map((e) => e + ";"),
+		"}",
+		"",
+		"export type Preloads = CorePreloads & PluginPreloads",
+		""
+	].join("\n");
+}
+function generateEventsFile(registryDir, allEvents) {
+	const imports = [];
+	const aliases = [];
+	const usedAliases = /* @__PURE__ */ new Map();
+	function uniqueAlias(base) {
+		const count = usedAliases.get(base) ?? 0;
+		usedAliases.set(base, count + 1);
+		return count === 0 ? base : `${base}${count}`;
+	}
+	for (const [, { name, eventsPath }] of allEvents) {
+		const alias = uniqueAlias(`Events_${name.replace(/(^|[-_])(\w)/g, (_m, _p, c) => _p ? c.toUpperCase() : c)}`);
+		const importPath = relativeFromRegistry(registryDir, eventsPath);
+		imports.push(`import type { Events as ${alias} } from "${importPath}"`);
+		aliases.push(alias);
+	}
+	const body = aliases.length === 0 ? "Record<string, never>" : aliases.join(" & ");
+	return [
+		"// Generated by: zen link",
+		"",
+		`import type { CoreEvents } from "@zenbujs/core/registry"`,
+		...imports,
+		"",
+		"/**",
+		" * Intersection of every plugin's `Events` type. Plugins extend this",
+		" * by declaring `events: \"./path/to/events.ts\"` in their",
+		" * zenbu.plugin.json and exporting `export type Events = { ... }` from",
+		" * that file. Each plugin chooses its own top-level namespace keys",
+		" * (e.g. `pty`, `bottomTerminal`); colliding keys with different payload",
+		" * shapes collapse to `never` at use sites — caught at compile time.",
+		" */",
+		`export type PluginEvents = CoreEvents & ${body}`,
+		""
+	].join("\n");
+}
+/**
+* Generate the module-augmentation that wires `DbRoot`, `ServiceRouter`,
+* and `PluginEvents` from the user's registry into `@zenbujs/core/react`'s
+* `ZenbuRegister` interface. With this in place the renderer hooks are
+* fully typed without a single generic at the call site.
+*/
+function generateRegisterFile() {
+	return [
+		"// Generated by: zen link",
+		"",
+		`import type { DbRoot } from "./db-sections"`,
+		`import type { ServiceRouter } from "./services"`,
+		`import type { PluginEvents } from "./events"`,
+		"",
+		`declare module "@zenbujs/core/registry" {`,
+		"  interface ZenbuRegister {",
+		"    db: DbRoot",
+		"    rpc: ServiceRouter",
+		"    events: PluginEvents",
+		"  }",
+		"}",
+		"",
+		"export {}",
+		""
+	].join("\n");
+}
+function generateDbSectionsFile(registryDir, allSchemas) {
+	const imports = [];
+	const sectionEntries = [];
+	const usedAliases = /* @__PURE__ */ new Map();
+	function uniqueAlias(base) {
+		const count = usedAliases.get(base) ?? 0;
+		usedAliases.set(base, count + 1);
+		return count === 0 ? base : `${base}${count}`;
+	}
+	for (const [, { name, schemaPath }] of allSchemas) {
+		const alias = uniqueAlias(name.replace(/(^|[-_])(\w)/g, (_m, _p, c) => c.toUpperCase()) + "Root");
+		const importPath = relativeFromRegistry(registryDir, schemaPath);
+		imports.push(`import type { SchemaRoot as ${alias} } from "${importPath}"`);
+		const quotedName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
+		sectionEntries.push(`  ${quotedName}: ${alias}`);
+	}
+	return [
+		"// Generated by: zen link",
+		"",
+		`import type { CoreDbSections } from "@zenbujs/core/registry"`,
+		...imports,
+		"",
+		"export type PluginDbSections = {",
+		...sectionEntries.map((e) => e + ";"),
+		"}",
+		"",
+		"export type DbSections = CoreDbSections & PluginDbSections",
+		"",
+		"export type DbRoot = { plugin: DbSections }",
+		""
+	].join("\n");
+}
+function readExistingRegistry(registryDir) {
+	const services = /* @__PURE__ */ new Map();
+	const schemas = /* @__PURE__ */ new Map();
+	const preloads = /* @__PURE__ */ new Map();
+	const events = /* @__PURE__ */ new Map();
+	const servicesPath = path.join(registryDir, "services.ts");
+	if (fs.existsSync(servicesPath)) {
+		const content = fs.readFileSync(servicesPath, "utf8");
+		const importRe = /import type \{ (\w+)(?:\s+as\s+(\w+))? \} from "([^"]+)"/g;
+		const routerRe = /^\s+(?:"([^"]+)"|(\w+)):\s+ExtractRpcMethods<(\w+)>/gm;
+		const importMap = /* @__PURE__ */ new Map();
+		for (const m of content.matchAll(importRe)) {
+			const className = m[1];
+			const alias = m[2] ?? m[1];
+			const relPath = m[3];
+			const absPath = path.resolve(registryDir, relPath) + ".ts";
+			importMap.set(alias, {
+				className,
+				filePath: absPath
+			});
+		}
+		for (const m of content.matchAll(routerRe)) {
+			const key = m[1] ?? m[2];
+			const alias = m[3];
+			const imp = importMap.get(alias);
+			if (!imp) continue;
+			let pluginName = null;
+			let dir = path.dirname(imp.filePath);
+			while (dir !== path.dirname(dir)) {
+				const candidate = path.join(dir, "zenbu.plugin.json");
+				if (fs.existsSync(candidate)) {
+					try {
+						pluginName = JSON.parse(fs.readFileSync(candidate, "utf8")).name;
+					} catch {}
+					break;
+				}
+				dir = path.dirname(dir);
+			}
+			if (!pluginName) continue;
+			if (!services.has(pluginName)) services.set(pluginName, []);
+			services.get(pluginName).push({
+				className: imp.className,
+				key,
+				filePath: imp.filePath
+			});
+		}
+	}
+	const dbPath = path.join(registryDir, "db-sections.ts");
+	if (fs.existsSync(dbPath)) {
+		const content = fs.readFileSync(dbPath, "utf8");
+		const importRe = /import type \{ SchemaRoot as (\w+) \} from "([^"]+)"/g;
+		const sectionRe = /^\s+(?:"([^"]+)"|(\w+)):\s+(\w+)/gm;
+		const importMap = /* @__PURE__ */ new Map();
+		for (const m of content.matchAll(importRe)) {
+			const alias = m[1];
+			const relPath = m[2];
+			importMap.set(alias, path.resolve(registryDir, relPath) + ".ts");
+		}
+		for (const m of content.matchAll(sectionRe)) {
+			const name = m[1] ?? m[2];
+			const alias = m[3];
+			const schemaPath = importMap.get(alias);
+			if (schemaPath) schemas.set(name, {
+				name,
+				schemaPath
+			});
+		}
+	}
+	const preloadsPath = path.join(registryDir, "preloads.ts");
+	if (fs.existsSync(preloadsPath)) {
+		const content = fs.readFileSync(preloadsPath, "utf8");
+		const importRe = /import type \{ default as (\w+) \} from "([^"]+)"/g;
+		const entryRe = /^\s+(?:"([^"]+)"|(\w+)):\s+Awaited<ReturnType<typeof (\w+)>>/gm;
+		const importMap = /* @__PURE__ */ new Map();
+		for (const m of content.matchAll(importRe)) {
+			const alias = m[1];
+			const relPath = m[2];
+			importMap.set(alias, path.resolve(registryDir, relPath) + ".ts");
+		}
+		for (const m of content.matchAll(entryRe)) {
+			const name = m[1] ?? m[2];
+			const alias = m[3];
+			const preloadPath = importMap.get(alias);
+			if (preloadPath) preloads.set(name, {
+				name,
+				preloadPath
+			});
+		}
+	}
+	const eventsRegistryPath = path.join(registryDir, "events.ts");
+	if (fs.existsSync(eventsRegistryPath)) {
+		const content = fs.readFileSync(eventsRegistryPath, "utf8");
+		for (const m of content.matchAll(/import type \{ Events as (\w+) \} from "([^"]+)"/g)) {
+			m[1];
+			const relPath = m[2];
+			const eventsPath = path.resolve(registryDir, relPath) + ".ts";
+			let pluginName = null;
+			let dir = path.dirname(eventsPath);
+			while (dir !== path.dirname(dir)) {
+				const candidate = path.join(dir, "zenbu.plugin.json");
+				if (fs.existsSync(candidate)) {
+					try {
+						pluginName = JSON.parse(fs.readFileSync(candidate, "utf8")).name;
+					} catch {}
+					break;
+				}
+				dir = path.dirname(dir);
+			}
+			if (!pluginName) continue;
+			events.set(pluginName, {
+				name: pluginName,
+				eventsPath
+			});
+		}
+	}
+	return {
+		services,
+		schemas,
+		preloads,
+		events
+	};
+}
+function parseLinkArgs(argv) {
+	let manifestArg = null;
+	let typesConfigArg = null;
+	let registryOverride = null;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--registry" && i + 1 < argv.length) registryOverride = argv[++i];
+		else if (arg.startsWith("--registry=")) registryOverride = arg.slice(11);
+		else if (arg === "--types-config" && i + 1 < argv.length) typesConfigArg = argv[++i];
+		else if (arg.startsWith("--types-config=")) typesConfigArg = arg.slice(15);
+		else if (!arg.startsWith("-") && !manifestArg) manifestArg = arg;
+	}
+	return {
+		manifestArg,
+		typesConfigArg,
+		registryOverride
+	};
+}
+function linkOne(manifestPath, existing) {
+	const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+	const pluginName = manifest.name;
+	const baseDir = path.dirname(manifestPath);
+	console.log(`Linking types "${pluginName}" from ${baseDir}`);
+	const serviceEntries = discoverServices(baseDir, manifest.services ?? []);
+	console.log(`  Found ${serviceEntries.length} service(s)`);
+	const schemaEntry = manifest.schema ? {
+		name: pluginName,
+		schemaPath: path.resolve(baseDir, manifest.schema)
+	} : null;
+	if (schemaEntry) console.log(`  Schema: ${schemaEntry.schemaPath}`);
+	const preloadEntry = manifest.preload ? {
+		name: pluginName,
+		preloadPath: path.resolve(baseDir, manifest.preload)
+	} : null;
+	if (preloadEntry) console.log(`  Preload: ${preloadEntry.preloadPath}`);
+	const eventsEntry = manifest.events ? {
+		name: pluginName,
+		eventsPath: path.resolve(baseDir, manifest.events)
+	} : null;
+	if (eventsEntry) console.log(`  Events: ${eventsEntry.eventsPath}`);
+	existing.services.set(pluginName, serviceEntries);
+	if (schemaEntry) existing.schemas.set(pluginName, schemaEntry);
+	if (preloadEntry) existing.preloads.set(pluginName, preloadEntry);
+	else existing.preloads.delete(pluginName);
+	if (eventsEntry) existing.events.set(pluginName, eventsEntry);
+	else existing.events.delete(pluginName);
+}
+/**
+* Per-install bootstrap for a plugin. The plugin ships a portable
+* `tsconfig.json` with no host-specific paths; this writes a sibling
+* `tsconfig.local.json` (gitignored) that wires `#registry/*` to the host
+* app's `types/` so the plugin can `import type {...} from "#registry/foo"`
+* the same way the host does. Idempotent.
+*
+* This is the only mechanism that knows where the host lives — it has to
+* be regenerated whenever the plugin moves between hosts.
+*/
+/**
+* Generate `<plugin>/tsconfig.local.json` — the BASE config that the
+* plugin's committed `tsconfig.json` extends. This file is gitignored and
+* regenerated by every `zen link` so the host-specific bits (the
+* `#registry/*` path mapping and the registry-augmentation include) move
+* with the plugin's host installation.
+*
+* Why this and not `tsconfig.json` itself: the IDE (VSCode/Cursor) walks
+* up looking for `tsconfig.json` and uses only that one. It never picks up
+* a sibling `tsconfig.local.json` on its own. So we keep `tsconfig.json`
+* as the IDE-discovered, plugin-author-edited entry point and have it
+* `"extends": "./tsconfig.local.json"`. The generated file then carries
+* `paths` + `include`, which TS merges into the IDE's resolved program.
+*/
+function writePluginTsconfigLocal(pluginManifestPath, registryDir) {
+	const pluginDir = path.dirname(pluginManifestPath);
+	const ownTsconfig = path.join(pluginDir, "tsconfig.json");
+	if (!fs.existsSync(ownTsconfig)) return;
+	if (fs.existsSync(path.join(pluginDir, "config.json"))) return;
+	const target = path.join(pluginDir, "tsconfig.local.json");
+	let registryRel = path.relative(pluginDir, registryDir);
+	if (!registryRel.startsWith(".")) registryRel = "./" + registryRel;
+	const body = {
+		compilerOptions: { paths: { "#registry/*": [`${registryRel}/*`] } },
+		include: ["src", `${registryRel}/zenbu-register.ts`]
+	};
+	const next = JSON.stringify(body, null, 2) + "\n";
+	let prev = null;
+	try {
+		prev = fs.readFileSync(target, "utf8");
+	} catch {}
+	if (prev === next) return;
+	fs.writeFileSync(target, next);
+	console.log(`  Wrote ${target}`);
+}
+/**
+* When the manifest being linked is the host app's own manifest (sitting
+* next to its `config.json`), expand the work list to also include every
+* plugin path declared in `config.json#plugins`. For any other manifest
+* (a plugin sitting inside or outside the app), only that single manifest
+* is returned — the caller decides not to touch sibling plugins.
+*/
+function expandAppManifests(manifestPath) {
+	const manifestDir = path.dirname(manifestPath);
+	const appRoot = findAppRoot(manifestDir);
+	if (appRoot !== manifestDir) return [manifestPath];
+	const configPath = path.join(appRoot, "config.json");
+	let pluginEntries = [];
+	try {
+		const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+		if (Array.isArray(config?.plugins)) pluginEntries = config.plugins;
+	} catch {}
+	const all = [manifestPath];
+	for (const entry of pluginEntries) {
+		const resolved = path.isAbsolute(entry) ? entry : path.resolve(appRoot, entry);
+		if (path.resolve(resolved) === path.resolve(manifestPath)) continue;
+		if (!fs.existsSync(resolved)) {
+			console.warn(`  ⚠ skipping ${entry} (not found at ${resolved})`);
+			continue;
+		}
+		all.push(resolved);
+	}
+	return all;
+}
+async function runLink(argv) {
+	const { manifestArg, typesConfigArg, registryOverride } = parseLinkArgs(argv);
+	const typeConfigPath = typesConfigArg ? path.resolve(typesConfigArg) : null;
+	const manifestPath = typeConfigPath ? null : manifestArg ? path.resolve(manifestArg) : findManifest(process.cwd());
+	if (!typeConfigPath && !manifestPath) {
+		console.error("zen link: could not find zenbu.plugin.json in current directory or any parent.");
+		console.error("          For internal framework types, pass --types-config <path>.");
+		process.exit(1);
+	}
+	const rootConfigPath = typeConfigPath ?? manifestPath;
+	const registryDir = resolveRegistryDir({
+		manifestPath: rootConfigPath,
+		manifest: JSON.parse(fs.readFileSync(rootConfigPath, "utf8")),
+		registryOverride
+	});
+	console.log(`Registry: ${registryDir}`);
+	const manifestPaths = typeConfigPath ? [typeConfigPath] : expandAppManifests(manifestPath);
+	fs.mkdirSync(registryDir, { recursive: true });
+	const existing = readExistingRegistry(registryDir);
+	for (const mp of manifestPaths) linkOne(mp, existing);
+	const writes = [
+		["services.ts", generateServicesFile(registryDir, existing.services)],
+		["db-sections.ts", generateDbSectionsFile(registryDir, existing.schemas)],
+		["preloads.ts", generatePreloadsFile(registryDir, existing.preloads)],
+		["events.ts", generateEventsFile(registryDir, existing.events)],
+		["zenbu-register.ts", generateRegisterFile()]
+	];
+	for (const [name, body] of writes) {
+		const target = path.join(registryDir, name);
+		fs.writeFileSync(target, body);
+		console.log(`  Wrote ${target}`);
+	}
+	for (const mp of manifestPaths) writePluginTsconfigLocal(mp, registryDir);
+	console.log("Done.");
+}
+//#endregion
+export { runLink };

package/dist/loaders/zenbu.d.mts

@@ -0,0 +1,22 @@
+//#region src/loaders/zenbu.d.ts
+type LoaderContext = {
+  hot?: {
+    watch?: (url: URL) => void;
+    invalidate?: () => void;
+  };
+};
+type NextResolve = (specifier: string, context: LoaderContext) => unknown;
+type NextLoad = (url: string, context: LoaderContext) => unknown;
+type TracePort = {
+  on: (event: "message", handler: (message: unknown) => void) => void;
+  postMessage: (message: unknown) => void;
+  unref?: () => void;
+};
+type InitializeData = {
+  tracePort?: TracePort;
+};
+declare function initialize(data?: InitializeData): void;
+declare function resolve(specifier: string, context: LoaderContext, nextResolve: NextResolve): unknown;
+declare function load(url: string, context: LoaderContext, nextLoad: NextLoad): unknown;
+//#endregion
+export { initialize, load, resolve };