@zenbujs/core 0.0.8 → 0.0.12

package/dist/link-glX89NV5.mjs

@@ -1,673 +0,0 @@
-import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
-import { t as loadConfig } from "./load-config-C4Oe2qZO.mjs";
-import fs from "node:fs";
-import path from "node:path";
-//#region src/cli/commands/link.ts
-var link_exports = /* @__PURE__ */ __exportAll({
-	linkProject: () => linkProject,
-	runLink: () => runLink
-});
-const CONFIG_NAMES = [
-	"zenbu.config.ts",
-	"zenbu.config.mts",
-	"zenbu.config.js",
-	"zenbu.config.mjs"
-];
-function findProjectDir(from) {
-	let dir = path.resolve(from);
-	while (true) {
-		for (const name of CONFIG_NAMES) if (fs.existsSync(path.join(dir, name))) return dir;
-		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 a
-* `zenbu.config.ts` (or its .mts/.js/.mjs variants). That single file
-* uniquely identifies a Zenbu project root.
-*/
-function findAppRoot(from) {
-	return findProjectDir(from);
-}
-/**
-* 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");
-	throw new Error(`zen link: could not determine target types directory for ${opts.manifestPath}.\n         Try one of:\n         - run from inside an app dir (with a zenbu.config.ts),\n         - add a "devAppPath" field to ${path.basename(opts.manifestPath)} pointing at the host app,\n         - create a tsconfig.local.json with a "#registry/*" path mapping,\n         - or pass --registry <dir>.`);
-}
-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 classKeyRe = /export\s+class\s+(\w+)\s+extends\s+Service\.create\s*\(\s*\{[\s\S]*?\bkey\s*:\s*["']([^"']+)["']/;
-	for (const glob of serviceGlobs) for (const filePath of expandGlob(baseDir, glob)) {
-		const match = fs.readFileSync(filePath, "utf8").match(classKeyRe);
-		if (match) entries.push({
-			className: match[1],
-			key: match[2],
-			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-generated"`,
-		...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-generated"`,
-		...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-generated"`,
-		...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 {} from "@zenbujs/core/registry"`,
-		`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-generated"`,
-		...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 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
-			});
-		}
-	}
-	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
-			});
-		}
-	}
-	return {
-		services,
-		schemas,
-		preloads,
-		events
-	};
-}
-function parseLinkArgs(argv) {
-	let manifestArg = null;
-	let typesConfigArg = null;
-	let registryOverride = null;
-	let surfaceOutArg = null;
-	let augmentOutArg = 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 === "--out" && i + 1 < argv.length) surfaceOutArg = argv[++i];
-		else if (arg.startsWith("--out=")) surfaceOutArg = arg.slice(6);
-		else if (arg === "--augment-out" && i + 1 < argv.length) augmentOutArg = argv[++i];
-		else if (arg.startsWith("--augment-out=")) augmentOutArg = arg.slice(14);
-		else if (!arg.startsWith("-") && !manifestArg) manifestArg = arg;
-	}
-	return {
-		manifestArg,
-		typesConfigArg,
-		registryOverride,
-		surfaceOutArg,
-		augmentOutArg
-	};
-}
-/**
-* Variant for path-based plugin sources (a `zenbu.plugin.ts` whose default
-* export is a `definePlugin({...})`). Resolved upstream by `loadConfig` so
-* we just consume the resolved record here.
-*/
-function linkResolvedPlugin(plugin, existing, opts) {
-	const log = opts.quiet ? () => {} : (msg) => console.log(msg);
-	log(`Linking types "${plugin.name}" from ${plugin.dir}`);
-	const serviceGlobs = plugin.services.map((abs) => path.relative(plugin.dir, abs).split(path.sep).join("/"));
-	const serviceEntries = discoverServices(plugin.dir, serviceGlobs);
-	log(`  Found ${serviceEntries.length} service(s)`);
-	const schemaEntry = plugin.schemaPath ? {
-		name: plugin.name,
-		schemaPath: plugin.schemaPath
-	} : null;
-	if (schemaEntry) log(`  Schema: ${schemaEntry.schemaPath}`);
-	const preloadEntry = plugin.preloadPath ? {
-		name: plugin.name,
-		preloadPath: plugin.preloadPath
-	} : null;
-	if (preloadEntry) log(`  Preload: ${preloadEntry.preloadPath}`);
-	const eventsEntry = plugin.eventsPath ? {
-		name: plugin.name,
-		eventsPath: plugin.eventsPath
-	} : null;
-	if (eventsEntry) log(`  Events: ${eventsEntry.eventsPath}`);
-	existing.services.set(plugin.name, serviceEntries);
-	if (schemaEntry) existing.schemas.set(plugin.name, schemaEntry);
-	if (preloadEntry) existing.preloads.set(plugin.name, preloadEntry);
-	else existing.preloads.delete(plugin.name);
-	if (eventsEntry) existing.events.set(plugin.name, eventsEntry);
-	else existing.events.delete(plugin.name);
-}
-/**
-* Generator: `<core>/src/registry-generated.ts` — the publishable
-* type surface that downstream apps' `zen link`-generated files
-* import from `@zenbujs/core/registry-generated`.
-*
-* Imports use public package exports (`@zenbujs/core/services`,
-* `/events`, `/schema`) so the file resolves in any consumer
-* regardless of how `@zenbujs/core` is installed.
-*/
-function generateCoreSurfaceFile(args) {
-	const sorted = [...args.services].sort((a, b) => a.className.localeCompare(b.className));
-	const importedNames = sorted.map((s) => `  ${s.className},`).join("\n");
-	const routerEntries = sorted.map((s) => {
-		return `  ${/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(s.key) ? s.key : `"${s.key}"`}: ExtractRpcMethods<${s.className}>;`;
-	}).join("\n");
-	const lines = [
-		"// Generated by: pnpm link:types",
-		"// DO NOT EDIT. Regenerated automatically (also wired into `prebuild`).",
-		""
-	];
-	if (sorted.length > 0) {
-		lines.push("import type {");
-		lines.push(importedNames);
-		lines.push(`} from "@zenbujs/core/services"`);
-	}
-	if (args.hasEvents) lines.push(`import type { Events as Events_core } from "@zenbujs/core/events"`);
-	if (args.hasSchema) lines.push(`import type { SchemaRoot as SchemaRoot_core } from "@zenbujs/core/schema"`);
-	lines.push("");
-	lines.push(`type ServiceBase =\n${SERVICE_BASE_LITERAL}`);
-	lines.push("");
-	lines.push("type ExtractRpcMethods<T> = {");
-	lines.push("  [K in Exclude<keyof T, ServiceBase | `_${string}`> as T[K] extends (");
-	lines.push("    ...args: any[]");
-	lines.push("  ) => any");
-	lines.push("    ? K");
-	lines.push("    : never]: T[K]");
-	lines.push("}");
-	lines.push("");
-	lines.push("export type CoreServiceRouter = {");
-	if (routerEntries.length > 0) lines.push(routerEntries);
-	lines.push("}");
-	lines.push("");
-	lines.push(`export type CoreEvents = ${args.hasEvents ? "Events_core" : "{}"}`);
-	lines.push("");
-	lines.push("export type CoreDbSections = {");
-	if (args.hasSchema) lines.push("  core: SchemaRoot_core;");
-	lines.push("}");
-	lines.push("");
-	lines.push("export type CorePreloads = {}");
-	lines.push("");
-	return lines.join("\n");
-}
-/**
-* Generator: `<core>/types/zenbu-register.ts` — local-only
-* augmentation that drives core's OWN typecheck. Pulls
-* `Core*` types from the relative path `../src/registry-generated`
-* (so it works without depending on package self-resolution) and
-* declares the `ZenbuRegister` augmentation. NOT in
-* `package.json#files`; never reaches downstream consumers (where
-* it would conflict with their own augmentation).
-*/
-function generateCoreAugmentFile() {
-	return [
-		"// Generated by: pnpm link:types",
-		"// DO NOT EDIT. Local-only augmentation (NOT shipped via package.json#files).",
-		"// Drives core's own typecheck so useRpc()/useEvents()/useDb() resolve",
-		"// to the registered surface inside packages/core/src/.",
-		"",
-		`import type {} from "@zenbujs/core/registry"`,
-		`import type {`,
-		`  CoreServiceRouter,`,
-		`  CoreEvents,`,
-		`  CoreDbSections,`,
-		`} from "../src/registry-generated"`,
-		"",
-		`declare module "@zenbujs/core/registry" {`,
-		"  interface ZenbuRegister {",
-		"    rpc: CoreServiceRouter",
-		"    events: CoreEvents",
-		"    db: { plugin: CoreDbSections }",
-		"  }",
-		"}",
-		"",
-		"export {}",
-		""
-	].join("\n");
-}
-/**
-* Two-file write for the `--types-config` flow: the publishable
-* surface (`registry-generated.ts`) plus the local-only
-* augmentation (`zenbu-register.ts`). Skips writes when content is
-* identical so downstream watchers (Vite, tsc --watch) don't see
-* spurious mtime bumps.
-*/
-function writeCoreSurfaceFiles(args) {
-	const surface = generateCoreSurfaceFile({
-		services: args.services,
-		hasEvents: args.hasEvents,
-		hasSchema: args.hasSchema
-	});
-	const augment = generateCoreAugmentFile();
-	for (const [target, body] of [[args.surfaceOut, surface], [args.augmentOut, augment]]) {
-		fs.mkdirSync(path.dirname(target), { recursive: true });
-		let prev = null;
-		try {
-			prev = fs.readFileSync(target, "utf8");
-		} catch {}
-		if (prev === body) continue;
-		fs.writeFileSync(target, body);
-		if (!args.quiet) console.log(`  Wrote ${target}`);
-	}
-}
-/**
-* 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(pluginDir, registryDir, opts) {
-	const ownTsconfig = path.join(pluginDir, "tsconfig.json");
-	if (!fs.existsSync(ownTsconfig)) return;
-	for (const name of CONFIG_NAMES) if (fs.existsSync(path.join(pluginDir, name))) 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);
-	if (!opts.quiet) console.log(`  Wrote ${target}`);
-}
-/**
-* Programmatic variant of `zen link` for the host-project flow. Throws on
-* any error instead of `process.exit`. Used by:
-*   - `runLink` (CLI entry)
-*   - `link-watcher.ts` (file watcher used by `zen dev`)
-*
-* `quiet: true` suppresses the per-step console output the CLI emits — the
-* watcher uses this so the dev terminal stays clean across rapid edits.
-*/
-async function linkProject(projectDir, opts = {}) {
-	const log = opts.quiet ? () => {} : (msg) => console.log(msg);
-	const { resolved, pluginSourceFiles } = await loadConfig(projectDir);
-	const registryDir = resolveRegistryDir({
-		manifestPath: resolved.configPath,
-		manifest: {},
-		registryOverride: opts.registryOverride ?? null
-	});
-	log(`Registry: ${registryDir}`);
-	fs.mkdirSync(registryDir, { recursive: true });
-	const existing = readExistingRegistry(registryDir);
-	for (const plugin of resolved.plugins) linkResolvedPlugin(plugin, existing, { quiet: !!opts.quiet });
-	writeRegistryFiles(registryDir, existing, { quiet: !!opts.quiet });
-	for (const plugin of resolved.plugins) writePluginTsconfigLocal(plugin.dir, registryDir, { quiet: !!opts.quiet });
-	return {
-		registryDir,
-		resolvedConfigPath: resolved.configPath,
-		pluginSourceFiles,
-		resolved
-	};
-}
-async function runLink(argv) {
-	const { manifestArg, typesConfigArg, registryOverride, surfaceOutArg, augmentOutArg } = parseLinkArgs(argv);
-	if (typesConfigArg) {
-		const typeConfigPath = path.resolve(typesConfigArg);
-		const rootManifest = JSON.parse(fs.readFileSync(typeConfigPath, "utf8"));
-		const baseDir = path.dirname(typeConfigPath);
-		const surfaceOut = surfaceOutArg ? path.resolve(surfaceOutArg) : path.join(baseDir, "src", "registry-generated.ts");
-		const augmentOut = augmentOutArg ? path.resolve(augmentOutArg) : path.join(baseDir, "types", "zenbu-register.ts");
-		try {
-			console.log(`Linking core types from ${baseDir}`);
-			const services = discoverServices(baseDir, rootManifest.services ?? []);
-			console.log(`  Found ${services.length} service(s)`);
-			const hasEvents = !!rootManifest.events;
-			const hasSchema = !!rootManifest.schema;
-			if (rootManifest.events) console.log(`  Events: ${path.resolve(baseDir, rootManifest.events)}`);
-			if (rootManifest.schema) console.log(`  Schema: ${path.resolve(baseDir, rootManifest.schema)}`);
-			writeCoreSurfaceFiles({
-				services,
-				hasEvents,
-				hasSchema,
-				surfaceOut,
-				augmentOut,
-				quiet: false
-			});
-			console.log("Done.");
-		} catch (err) {
-			console.error(err instanceof Error ? err.message : err);
-			process.exit(1);
-		}
-		return;
-	}
-	const projectDir = manifestArg ? path.resolve(manifestArg) : findProjectDir(process.cwd());
-	if (!projectDir) {
-		console.error("zen link: could not find zenbu.config.ts in current directory or any parent.");
-		console.error("          For internal framework types, pass --types-config <path>.");
-		process.exit(1);
-	}
-	try {
-		await linkProject(projectDir, { registryOverride });
-		console.log("Done.");
-	} catch (err) {
-		console.error(err instanceof Error ? err.message : err);
-		process.exit(1);
-	}
-}
-function writeRegistryFiles(registryDir, existing, opts) {
-	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);
-		let prev = null;
-		try {
-			prev = fs.readFileSync(target, "utf8");
-		} catch {}
-		if (prev === body) continue;
-		fs.writeFileSync(target, body);
-		if (!opts.quiet) console.log(`  Wrote ${target}`);
-	}
-}
-//#endregion
-export { link_exports as n, linkProject as t };