@zenbujs/core 0.0.8 → 0.0.12

package/dist/launcher.mjs

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { BaseWindow, WebContentsView, app } from "electron";
+import { BaseWindow, WebContentsView, app, nativeTheme } from "electron";
 import fs, { existsSync } from "node:fs";
 import fsp from "node:fs/promises";
 import os from "node:os";
@@ -18808,9 +18808,10 @@ async function writeDepsSig(appsDir, sig) {
 //#region src/shared/host-version.ts
 /**
 * Single source of truth for reading the .app's "host version" — the
-* concrete semver string the developer authored on
-* `defineBuildConfig({ hostVersion: "..." })` and that
-* `zen build:electron` baked into `<bundle>/host.json`.
+* concrete semver string `zen build:electron` baked into
+* `<bundle>/host.json` from the developer's `package.json#version` at
+* build time. Frozen into the .app so subsequent `git pull`s of the
+* source can't change it.
 *
 * Imported by both:
 *   - `packages/core/src/launcher.ts` (tsdown inlines this into
@@ -20393,6 +20394,51 @@ async function resolveTargetSha(input) {
 	};
 }
 //#endregion
+//#region src/shared/zenbu-bg-parse.ts
+const META_TAG_RE = /<meta\b([^>]*?)\/?>/gi;
+const ATTR_RE = /([\w-]+)\s*=\s*["']([^"']+)["']/g;
+/**
+* Parse all `<meta name="zenbu-bg">` tags from `html`. Mirrors the W3C
+* `<meta name="theme-color">` pattern: multiple tags carry a `media`
+* attribute (typically `(prefers-color-scheme: light|dark)`), and an
+* unmediated tag acts as the fallback.
+*
+*   <meta name="zenbu-bg" content="#fafafa" media="(prefers-color-scheme: light)">
+*   <meta name="zenbu-bg" content="#09090b" media="(prefers-color-scheme: dark)">
+*   <meta name="zenbu-bg" content="#27272a">  <!-- default -->
+*/
+function parseZenbuBgEntries(html) {
+	const out = [];
+	for (const tag of html.matchAll(META_TAG_RE)) {
+		const body = tag[1] ?? "";
+		const attrs = {};
+		for (const a of body.matchAll(ATTR_RE)) attrs[a[1].toLowerCase()] = a[2];
+		if (attrs.name === "zenbu-bg" && attrs.content) out.push({
+			color: attrs.content,
+			media: attrs.media ?? null
+		});
+	}
+	return out;
+}
+/**
+* Pick the right entry given the current dark-mode preference. Search
+* order:
+*   1. First entry whose `media` matches `(prefers-color-scheme: <dark|light>)`.
+*   2. First entry without a `media` attribute (the unconditional default).
+*   3. The first entry, regardless of `media`.
+*
+* Returns `null` only when `entries` is empty.
+*/
+function pickZenbuBgEntry(entries, dark) {
+	for (const e of entries) {
+		if (!e.media) continue;
+		if (dark && /prefers-color-scheme:\s*dark/i.test(e.media)) return e.color;
+		if (!dark && /prefers-color-scheme:\s*light/i.test(e.media)) return e.color;
+	}
+	for (const e of entries) if (!e.media) return e.color;
+	return entries[0]?.color ?? null;
+}
+//#endregion
 //#region src/launcher.ts
 /**
 * Zenbu launcher shim.
@@ -20419,6 +20465,9 @@ async function resolveTargetSha(input) {
 * at runtime), and `isomorphic-git` (bundled into this file by tsdown — see
 * `packages/core/tsdown.config.ts` `neverBundle: ["electron"]`).
 */
+/**
+* fixme this is nonsense
+*/
 const _logDir = path.join(os.homedir(), ".zenbu", ".internal");
 fs.mkdirSync(_logDir, { recursive: true });
 const _logStream = fs.createWriteStream(path.join(_logDir, "launcher.log"), { flags: "a" });
@@ -20462,8 +20511,8 @@ const APP_PATH = app.getAppPath();
 const RESOURCES_PATH = path.dirname(APP_PATH);
 function readBgColor(htmlPath, fallback) {
 	try {
-		const match = fs.readFileSync(htmlPath, "utf8").match(/<meta\s+name=["']zenbu-bg["']\s+content=["']([^"']+)["']/i);
-		if (match?.[1]) return match[1];
+		const picked = pickZenbuBgEntry(parseZenbuBgEntries(fs.readFileSync(htmlPath, "utf8")), nativeTheme.shouldUseDarkColors);
+		if (picked) return picked;
 	} catch {}
 	return fallback;
 }
@@ -20507,6 +20556,15 @@ async function maybeOpenInstallingWindow(cfg) {
 	};
 	layout();
 	win.on("resize", layout);
+	const onThemeChange = () => {
+		try {
+			win.setBackgroundColor(readBgColor(htmlPath, "#F4F4F4"));
+		} catch {}
+	};
+	nativeTheme.on("updated", onThemeChange);
+	win.on("closed", () => {
+		nativeTheme.removeListener("updated", onThemeChange);
+	});
 	let ready = false;
 	const pending = [];
 	view.webContents.once("did-finish-load", () => {

package/dist/link-Bt3LB_NW.mjs

@@ -0,0 +1,586 @@
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { i as loadPluginManifest, n as loadConfig, r as loadPluginFromPath, t as findConfigPath } from "./load-config-C2XloBaQ.mjs";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cli/commands/link.ts
+var link_exports = /* @__PURE__ */ __exportAll({
+	linkProject: () => linkProject,
+	linkSinglePlugin: () => linkSinglePlugin,
+	runLink: () => runLink
+});
+const DOTZENBU_TYPES = path.join(".zenbu", "types");
+const SERVICE_BASE_LITERAL = [
+	`  | "evaluate"`,
+	`  | "shutdown"`,
+	`  | "constructor"`,
+	`  | "effect"`,
+	`  | "__cleanupAllEffects"`,
+	`  | "__effectCleanups"`,
+	`  | "ctx"`
+].join("\n");
+const EXTRACT_RPC_DECL = [
+	"type ExtractRpcMethods<T> = {",
+	"  [K in Exclude<keyof T, ServiceBase | `_${string}`> as T[K] extends (",
+	"    ...args: any[]",
+	"  ) => any",
+	"    ? K",
+	"    : never]: T[K]",
+	"}"
+].join("\n");
+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 [];
+	}
+}
+const SERVICE_CLASS_KEY_RE = /export\s+class\s+(\w+)\s+extends\s+Service\.create\s*\(\s*\{[\s\S]*?\bkey\s*:\s*["']([^"']+)["']/;
+function discoverServices(baseDir, serviceGlobs) {
+	const entries = [];
+	for (const glob of serviceGlobs) for (const filePath of expandGlob(baseDir, glob)) {
+		const match = fs.readFileSync(filePath, "utf8").match(SERVICE_CLASS_KEY_RE);
+		if (match) entries.push({
+			className: match[1],
+			key: match[2],
+			filePath
+		});
+	}
+	return entries;
+}
+function discoverOwnSurface(plugin) {
+	const serviceGlobs = plugin.services.map((abs) => path.relative(plugin.dir, abs).split(path.sep).join("/"));
+	return {
+		services: discoverServices(plugin.dir, serviceGlobs),
+		schemaPath: plugin.schemaPath,
+		eventsPath: plugin.eventsPath,
+		preloadPath: plugin.preloadPath
+	};
+}
+function relImport(from, to) {
+	let r = path.relative(from, to).split(path.sep).join("/");
+	if (!r.startsWith(".")) r = "./" + r;
+	return r.replace(/\.ts$/, "");
+}
+function quoteKey(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
+}
+function sanitizeIdent(name) {
+	return name.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function writeIfChanged(target, body, opts) {
+	fs.mkdirSync(path.dirname(target), { recursive: true });
+	let prev = null;
+	try {
+		prev = fs.readFileSync(target, "utf8");
+	} catch {}
+	if (prev === body) return false;
+	fs.writeFileSync(target, body);
+	if (!opts.quiet) console.log(`  Wrote ${target}`);
+	return true;
+}
+/** jsonc-lite: strips // and /* * / comments and trailing commas. */
+function readJsonLoose(raw) {
+	const stripped = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1").replace(/,\s*([\]}])/g, "$1");
+	return JSON.parse(stripped);
+}
+function generateServicesFile(surfaceDir, surface) {
+	const imports = [];
+	const usedNames = /* @__PURE__ */ new Map();
+	const lines = [];
+	const uniqueName = (base) => {
+		const count = usedNames.get(base) ?? 0;
+		usedNames.set(base, count + 1);
+		return count === 0 ? base : `${base}_${count}`;
+	};
+	for (const svc of surface.services) {
+		const alias = uniqueName(svc.className);
+		imports.push(`import type { ${svc.className}${alias !== svc.className ? ` as ${alias}` : ""} } from "${relImport(surfaceDir, svc.filePath)}"`);
+		lines.push(`  ${quoteKey(svc.key)}: ExtractRpcMethods<${alias}>;`);
+	}
+	return [
+		"// Generated by: zen link",
+		"// DO NOT EDIT. Pointer-only file: imports resolve directly to source on disk.",
+		"",
+		...imports,
+		"",
+		`type ServiceBase =\n${SERVICE_BASE_LITERAL}`,
+		"",
+		EXTRACT_RPC_DECL,
+		"",
+		"export type SelfServiceMap = {",
+		...lines,
+		"}",
+		""
+	].join("\n");
+}
+function generateDbFile(surfaceDir, surface) {
+	if (!surface.schemaPath) return [
+		"// Generated by: zen link",
+		"",
+		"export type SelfDbSection = {}",
+		""
+	].join("\n");
+	return [
+		"// Generated by: zen link",
+		"",
+		`import type { InferSchemaRoot } from "@zenbujs/core/db"`,
+		`import type schema from "${relImport(surfaceDir, surface.schemaPath)}"`,
+		"",
+		"export type SelfDbSection = InferSchemaRoot<typeof schema>",
+		""
+	].join("\n");
+}
+function generateEventsFile(surfaceDir, surface) {
+	if (!surface.eventsPath) return [
+		"// Generated by: zen link",
+		"",
+		"export type SelfEvents = {}",
+		""
+	].join("\n");
+	return [
+		"// Generated by: zen link",
+		"",
+		`import type { Events } from "${relImport(surfaceDir, surface.eventsPath)}"`,
+		"",
+		"export type SelfEvents = Events",
+		""
+	].join("\n");
+}
+function generatePreloadsFile(surfaceDir, surface) {
+	if (!surface.preloadPath) return [
+		"// Generated by: zen link",
+		"",
+		"export type SelfPreload = unknown",
+		""
+	].join("\n");
+	return [
+		"// Generated by: zen link",
+		"",
+		`import type { default as preload } from "${relImport(surfaceDir, surface.preloadPath)}"`,
+		"",
+		"export type SelfPreload = Awaited<ReturnType<typeof preload>>",
+		""
+	].join("\n");
+}
+function generateIndexFile() {
+	return [
+		"// Generated by: zen link",
+		"",
+		`import type { SelfServiceMap } from "./services"`,
+		`import type { SelfDbSection } from "./db-sections"`,
+		`import type { SelfEvents } from "./events"`,
+		`import type { SelfPreload } from "./preloads"`,
+		"",
+		"export type Own = {",
+		"  services: SelfServiceMap",
+		"  db: SelfDbSection",
+		"  events: SelfEvents",
+		"  preloads: SelfPreload",
+		"}",
+		""
+	].join("\n");
+}
+function writeSurface(surfaceDir, surface, opts) {
+	fs.mkdirSync(surfaceDir, { recursive: true });
+	writeIfChanged(path.join(surfaceDir, "services.ts"), generateServicesFile(surfaceDir, surface), opts);
+	writeIfChanged(path.join(surfaceDir, "db-sections.ts"), generateDbFile(surfaceDir, surface), opts);
+	writeIfChanged(path.join(surfaceDir, "events.ts"), generateEventsFile(surfaceDir, surface), opts);
+	writeIfChanged(path.join(surfaceDir, "preloads.ts"), generatePreloadsFile(surfaceDir, surface), opts);
+	writeIfChanged(path.join(surfaceDir, "index.ts"), generateIndexFile(), opts);
+}
+function generateCompositeFile(args) {
+	const lines = [
+		"// Generated by: zen link",
+		"// DO NOT EDIT. Composite augmentation (own + deps) for this plugin.",
+		"",
+		`import type {} from "@zenbujs/core/registry"`,
+		`import type { CoreServiceRouter, CoreEvents, CoreDbSections } from "@zenbujs/core/registry-generated"`
+	];
+	if (args.selfName && args.selfOwnImport) lines.push(`import type { Own as Self_${sanitizeIdent(args.selfName)} } from "${args.selfOwnImport}"`);
+	for (const d of args.deps) lines.push(`import type { Own as Dep_${sanitizeIdent(d.name)} } from "${d.ownImport}"`);
+	lines.push("");
+	const rpcEntries = [];
+	const evtEntries = [];
+	const dbEntries = [];
+	if (args.selfName && args.selfOwnImport) {
+		const k = quoteKey(args.selfName);
+		const a = sanitizeIdent(args.selfName);
+		rpcEntries.push(`      ${k}: Self_${a}["services"];`);
+		evtEntries.push(`      ${k}: Self_${a}["events"];`);
+		dbEntries.push(`      ${k}: Self_${a}["db"];`);
+	}
+	for (const d of args.deps) {
+		const k = quoteKey(d.name);
+		const a = sanitizeIdent(d.name);
+		rpcEntries.push(`      ${k}: Dep_${a}["services"];`);
+		evtEntries.push(`      ${k}: Dep_${a}["events"];`);
+		dbEntries.push(`      ${k}: Dep_${a}["db"];`);
+	}
+	lines.push(`declare module "@zenbujs/core/registry" {`);
+	lines.push(`  interface ZenbuRegister {`);
+	lines.push(`    rpc: CoreServiceRouter & {`);
+	if (rpcEntries.length === 0) lines.push(`      // (no plugins)`);
+	lines.push(...rpcEntries);
+	lines.push(`    };`);
+	lines.push(`    events: CoreEvents & {`);
+	if (evtEntries.length === 0) lines.push(`      // (no plugins)`);
+	lines.push(...evtEntries);
+	lines.push(`    };`);
+	lines.push(`    db: CoreDbSections & {`);
+	if (dbEntries.length === 0) lines.push(`      // (no plugins)`);
+	lines.push(...dbEntries);
+	lines.push(`    };`);
+	lines.push(`  }`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push("export {}");
+	lines.push("");
+	return lines.join("\n");
+}
+const REGISTER_INCLUDE = "./.zenbu/types/zenbu-register.ts";
+function bootstrapTsconfigJson(pluginDir, opts) {
+	const tsconfigPath = path.join(pluginDir, "tsconfig.json");
+	if (!fs.existsSync(tsconfigPath)) return;
+	const raw = fs.readFileSync(tsconfigPath, "utf8");
+	let parsed;
+	try {
+		parsed = readJsonLoose(raw);
+	} catch {
+		return;
+	}
+	const includeArr = Array.isArray(parsed.include) ? [...parsed.include] : [];
+	if (includeArr.includes(REGISTER_INCLUDE)) return;
+	includeArr.push(REGISTER_INCLUDE);
+	parsed.include = includeArr;
+	const next = JSON.stringify(parsed, null, 2) + "\n";
+	if (next === raw) return;
+	fs.writeFileSync(tsconfigPath, next);
+	if (!opts.quiet) console.log(`  Updated ${tsconfigPath}`);
+}
+const GITIGNORE_MARKER = "# zen link: generated types";
+const GITIGNORE_RULE = ".zenbu/types/";
+const GITIGNORE_BROAD_RULES = new Set([
+	".zenbu",
+	".zenbu/",
+	"/.zenbu",
+	"/.zenbu/",
+	".zenbu/*",
+	".zenbu/**",
+	".zenbu/**/*",
+	".zenbu/types",
+	".zenbu/types/",
+	".zenbu/types/**",
+	".zenbu/types/**/*"
+]);
+function bootstrapGitignore(pluginDir, opts) {
+	const gitignorePath = path.join(pluginDir, ".gitignore");
+	let raw = "";
+	try {
+		raw = fs.readFileSync(gitignorePath, "utf8");
+	} catch {
+		return;
+	}
+	const lines = raw.split(/\r?\n/);
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		if (GITIGNORE_BROAD_RULES.has(trimmed)) return;
+		if (trimmed === GITIGNORE_RULE) return;
+	}
+	const append = `${raw.endsWith("\n") ? "" : "\n"}\n${GITIGNORE_MARKER}\n${GITIGNORE_RULE}\n`;
+	fs.writeFileSync(gitignorePath, raw + append);
+	if (!opts.quiet) console.log(`  Updated ${gitignorePath}`);
+}
+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) => `    ${quoteKey(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 schema_core from "@zenbujs/core/schema"`);
+		lines.push(`import type { InferSchemaRoot } from "@zenbujs/core/db"`);
+	}
+	lines.push("");
+	lines.push(`type ServiceBase =\n${SERVICE_BASE_LITERAL}`);
+	lines.push("");
+	lines.push(EXTRACT_RPC_DECL);
+	lines.push("");
+	lines.push("export type CoreServiceRouter = {");
+	lines.push("  core: {");
+	if (routerEntries.length > 0) lines.push(routerEntries);
+	lines.push("  };");
+	lines.push("}");
+	lines.push("");
+	lines.push(`export type CoreEvents = { core: ${args.hasEvents ? "Events_core" : "{}"} }`);
+	lines.push("");
+	lines.push("export type CoreDbSections = {");
+	if (args.hasSchema) lines.push("  core: InferSchemaRoot<typeof schema_core>;");
+	lines.push("}");
+	lines.push("");
+	lines.push("export type CorePreloads = {}");
+	lines.push("");
+	return lines.join("\n");
+}
+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: CoreDbSections",
+		"  }",
+		"}",
+		"",
+		"export {}",
+		""
+	].join("\n");
+}
+function writeCoreSurfaceFiles(args) {
+	writeIfChanged(args.surfaceOut, generateCoreSurfaceFile({
+		services: args.services,
+		hasEvents: args.hasEvents,
+		hasSchema: args.hasSchema
+	}), args.opts);
+	writeIfChanged(args.augmentOut, generateCoreAugmentFile(), args.opts);
+}
+function parseLinkArgs(argv) {
+	let manifestArg = null;
+	let typesConfigArg = null;
+	let surfaceOutArg = null;
+	let augmentOutArg = null;
+	let pluginMode = false;
+	let pluginDirArg = null;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		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 === "--plugin") {
+			pluginMode = true;
+			const next = argv[i + 1];
+			if (next && !next.startsWith("-")) {
+				pluginDirArg = next;
+				i++;
+			}
+		} else if (arg.startsWith("--plugin=")) {
+			pluginMode = true;
+			pluginDirArg = arg.slice(9);
+		} else if (!arg.startsWith("-") && !manifestArg) manifestArg = arg;
+	}
+	return {
+		manifestArg,
+		typesConfigArg,
+		surfaceOutArg,
+		augmentOutArg,
+		pluginMode,
+		pluginDirArg
+	};
+}
+/**
+* Per-plugin link pipeline. Used by both `linkProject` (host context) and
+* `linkSinglePlugin` (standalone). Writes the plugin's own surface, each
+* declared dep surface, the composite augmentation, and bootstraps
+* `tsconfig.json` / `.gitignore`. Stale `deps/<name>/` dirs that aren't in
+* the current `dependsOn` set are pruned.
+*/
+async function processOnePlugin(plugin, writeOpts, log) {
+	const surface = discoverOwnSurface(plugin);
+	log(`Linking own surface "${plugin.name}" at ${plugin.dir}`);
+	log(`  ${surface.services.length} service(s)`);
+	if (surface.schemaPath) log(`  schema: ${surface.schemaPath}`);
+	if (surface.eventsPath) log(`  events: ${surface.eventsPath}`);
+	if (surface.preloadPath) log(`  preload: ${surface.preloadPath}`);
+	writeSurface(path.join(plugin.dir, DOTZENBU_TYPES, "own"), surface, writeOpts);
+	const deps = [];
+	for (const dep of plugin.dependsOn ?? []) {
+		const upstream = await loadPluginFromPath({
+			fromPath: dep.fromPath,
+			name: dep.name
+		});
+		const surfaceDir = path.join(plugin.dir, DOTZENBU_TYPES, "deps", dep.name);
+		const upstreamSurface = discoverOwnSurface(upstream);
+		log(`Linking dep "${dep.name}" into "${plugin.name}" (${upstream.dir})`);
+		writeSurface(surfaceDir, upstreamSurface, writeOpts);
+		deps.push({
+			depName: dep.name,
+			ownImportFromComposite: relImport(path.join(plugin.dir, DOTZENBU_TYPES), path.join(surfaceDir, "index.ts"))
+		});
+	}
+	const wantedDepNames = new Set(deps.map((d) => d.depName));
+	const depsRoot = path.join(plugin.dir, DOTZENBU_TYPES, "deps");
+	if (fs.existsSync(depsRoot)) for (const entry of fs.readdirSync(depsRoot)) {
+		if (wantedDepNames.has(entry)) continue;
+		const stale = path.join(depsRoot, entry);
+		try {
+			fs.rmSync(stale, {
+				recursive: true,
+				force: true
+			});
+			if (!writeOpts.quiet) console.log(`  Pruned ${stale}`);
+		} catch {}
+	}
+	const compositePath = path.join(plugin.dir, DOTZENBU_TYPES, "zenbu-register.ts");
+	const selfOwnImport = relImport(path.dirname(compositePath), path.join(plugin.dir, DOTZENBU_TYPES, "own", "index.ts"));
+	writeIfChanged(compositePath, generateCompositeFile({
+		selfName: plugin.name,
+		selfOwnImport,
+		deps: deps.map((d) => ({
+			name: d.depName,
+			ownImport: d.ownImportFromComposite
+		}))
+	}), writeOpts);
+	bootstrapTsconfigJson(plugin.dir, writeOpts);
+	bootstrapGitignore(plugin.dir, writeOpts);
+}
+async function linkProject(projectDir, opts = {}) {
+	const writeOpts = { quiet: !!opts.quiet };
+	const log = opts.quiet ? () => {} : (msg) => console.log(msg);
+	const { resolved, pluginSourceFiles } = await loadConfig(projectDir);
+	const inlinePlugins = resolved.plugins.filter((p) => p.dir === resolved.projectDir);
+	if (inlinePlugins.length > 1) throw new Error(`zen link: ${resolved.configPath} declares ${inlinePlugins.length} inline plugins (${inlinePlugins.map((p) => `"${p.name}"`).join(", ")}). Move all but one into separate zenbu.plugin.ts files so each owns its own .zenbu/types/ dir.`);
+	for (const plugin of resolved.plugins) await processOnePlugin(plugin, writeOpts, log);
+	if (inlinePlugins.length === 0) {
+		bootstrapTsconfigJson(resolved.projectDir, writeOpts);
+		bootstrapGitignore(resolved.projectDir, writeOpts);
+	}
+	return {
+		registryDir: path.join(resolved.projectDir, DOTZENBU_TYPES),
+		resolvedConfigPath: resolved.configPath,
+		pluginSourceFiles,
+		resolved
+	};
+}
+/**
+* Standalone plugin link. Used by `zen link --plugin <dir>` when there's no
+* host context — for example, right after `create-zenbu-app --plugin`
+* scaffolds a plugin folder that hasn't been wired into any host yet.
+*
+* The plugin's `zenbu.plugin.ts` is loaded directly (no `zenbu.config.ts`
+* required), and we run the same per-plugin pipeline `linkProject` uses.
+*/
+async function linkSinglePlugin(pluginDir, opts = {}) {
+	const writeOpts = { quiet: !!opts.quiet };
+	const log = opts.quiet ? () => {} : (msg) => console.log(msg);
+	const candidates = [
+		"zenbu.plugin.ts",
+		"zenbu.plugin.mts",
+		"zenbu.plugin.js",
+		"zenbu.plugin.mjs"
+	];
+	let manifestPath = null;
+	for (const name of candidates) {
+		const candidate = path.join(pluginDir, name);
+		if (fs.existsSync(candidate)) {
+			manifestPath = candidate;
+			break;
+		}
+	}
+	if (!manifestPath) throw new Error(`zen link --plugin: no zenbu.plugin.ts found in ${pluginDir}. Expected one of: ${candidates.join(", ")}.`);
+	await processOnePlugin(await loadPluginManifest(manifestPath), writeOpts, log);
+}
+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;
+	}
+}
+async function runLink(argv) {
+	const args = parseLinkArgs(argv);
+	if (args.typesConfigArg) {
+		const typeConfigPath = path.resolve(args.typesConfigArg);
+		const rootManifest = JSON.parse(fs.readFileSync(typeConfigPath, "utf8"));
+		const baseDir = path.dirname(typeConfigPath);
+		const surfaceOut = args.surfaceOutArg ? path.resolve(args.surfaceOutArg) : path.join(baseDir, "src", "registry-generated.ts");
+		const augmentOut = args.augmentOutArg ? path.resolve(args.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,
+				opts: { quiet: false }
+			});
+			console.log("Done.");
+		} catch (err) {
+			console.error(err instanceof Error ? err.message : err);
+			process.exit(1);
+		}
+		return;
+	}
+	if (args.pluginMode) {
+		const pluginDir = path.resolve(args.pluginDirArg ?? process.cwd());
+		try {
+			await linkSinglePlugin(pluginDir);
+			console.log("Done.");
+		} catch (err) {
+			console.error(err instanceof Error ? err.message : err);
+			process.exit(1);
+		}
+		return;
+	}
+	const projectDir = args.manifestArg ? path.resolve(args.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 {
+		findConfigPath(projectDir);
+		await linkProject(projectDir);
+		console.log("Done.");
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : err);
+		process.exit(1);
+	}
+}
+//#endregion
+export { link_exports as n, linkProject as t };