@zenbujs/core 0.0.3 → 0.0.5

package/dist/db.mjs

@@ -1,5 +1,5 @@
-import { i as createSchema, n as blob, r as collection } from "./schema-CIg4GzHQ.mjs";
-import { i as dbStringify, r as dbParse, t as connectReplica } from "./transport-BMSzG2-F.mjs";
+import { i as createSchema, n as blob, r as collection } from "./schema-Ca7SxXgS.mjs";
+import { i as dbStringify, r as dbParse, t as connectReplica } from "./transport-F2hv_OEm.mjs";
 import { z as z$1 } from "zod";
 //#region src/db.ts
 /**

package/dist/env-bootstrap.d.mts

@@ -1,2 +1,2 @@
-import { t as bootstrapEnv } from "./env-bootstrap-BtVME-CU.mjs";
+import { t as bootstrapEnv } from "./env-bootstrap-DW2hVhSO.mjs";
 export { bootstrapEnv };

package/dist/env-bootstrap.mjs

@@ -1,2 +1,53 @@
-import { t as bootstrapEnv } from "./env-bootstrap-rj7I-59x.mjs";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+//#region src/env-bootstrap.ts
+const internalDir = path.join(os.homedir(), ".zenbu", ".internal");
+const pathsJson = path.join(internalDir, "paths.json");
+function userCacheRoot() {
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Caches");
+	if (process.platform === "win32") return process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+	return process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+}
+function computePaths() {
+	const cacheRoot = path.join(userCacheRoot(), "Zenbu");
+	const binDir = path.join(cacheRoot, "bin");
+	return {
+		cacheRoot,
+		binDir,
+		bunInstall: path.join(cacheRoot, "bun"),
+		bunPath: path.join(binDir, "bun"),
+		pnpmHome: path.join(cacheRoot, "pnpm"),
+		pnpmPath: path.join(binDir, "pnpm"),
+		gitPath: path.join(binDir, "git"),
+		writtenAt: Date.now()
+	};
+}
+function bootstrapEnv() {
+	const paths = computePaths();
+	try {
+		fs.mkdirSync(paths.binDir, { recursive: true });
+	} catch {}
+	const toolchainReady = fs.existsSync(paths.bunPath) && fs.existsSync(paths.pnpmPath);
+	if (toolchainReady) {
+		process.env.BUN_INSTALL ??= paths.bunInstall;
+		process.env.PNPM_HOME ??= paths.pnpmHome;
+	}
+	const pathParts = toolchainReady ? [paths.binDir, process.env.PATH ?? ""] : [process.env.PATH ?? ""];
+	const seen = /* @__PURE__ */ new Set();
+	process.env.PATH = pathParts.flatMap((part) => part.split(path.delimiter)).filter((part) => {
+		if (!part || seen.has(part)) return false;
+		seen.add(part);
+		return true;
+	}).join(path.delimiter);
+	try {
+		fs.mkdirSync(internalDir, { recursive: true });
+		fs.writeFileSync(pathsJson, JSON.stringify(paths, null, 2));
+	} catch {}
+	return {
+		paths,
+		needsToolchainDownload: !toolchainReady
+	};
+}
+//#endregion
 export { bootstrapEnv };

package/dist/index-ClXLQ1fw.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { t as bootstrapEnv } from "./env-bootstrap-BtVME-CU.mjs";
-import { t as setupGate } from "./setup-gate-BqOzm7zp.mjs";
-import { a as runtime, i as optional, n as Service, o as serviceWithDeps, r as ServiceRuntime, t as CleanupReason } from "./runtime-CjqDr8Yf.mjs";
-import { n as SchemaRoot, o as schema, t as CoreSchema } from "./schema-DMoSkwUx.mjs";
-import { i as CoreServiceRouter, n as CoreEvents, r as CorePreloads, t as CoreDbSections } from "./registry-Dh_e7HU1.mjs";
+import { a as ServiceRuntime, d as optional, g as serviceWithDeps, h as runtime, i as Service, t as CleanupReason } from "./runtime-pCeVzj--.mjs";
+import { t as bootstrapEnv } from "./env-bootstrap-DW2hVhSO.mjs";
+import { t as setupGate } from "./setup-gate-Dcy8gGPJ.mjs";
+import { n as SchemaRoot, o as schema, t as CoreSchema } from "./schema-Dl85YjXW.mjs";
+import { i as CoreServiceRouter, n as CoreEvents, r as CorePreloads, t as CoreDbSections } from "./registry-eX6e2oql.mjs";
 export { CleanupReason, CoreDbSections, CoreEvents, CorePreloads, CoreSchema, SchemaRoot as CoreSchemaRoot, CoreServiceRouter, Service, ServiceRuntime, bootstrapEnv, schema as coreSchema, optional, runtime, serviceWithDeps, setupGate };

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { t as bootstrapEnv } from "./env-bootstrap-rj7I-59x.mjs";
-import { t as setupGate } from "./setup-gate-BcoqWu8S.mjs";
-import { a as serviceWithDeps, i as runtime, n as ServiceRuntime, r as optional, t as Service } from "./runtime-DUFKDIe4.mjs";
-import { t as schema } from "./schema-dGK6qkfR.mjs";
+import { bootstrapEnv } from "./env-bootstrap.mjs";
+import { setupGate } from "./setup-gate.mjs";
+import { Service, ServiceRuntime, optional, runtime, serviceWithDeps } from "./runtime.mjs";
+import { schema } from "./schema.mjs";
 export { Service, ServiceRuntime, bootstrapEnv, schema as coreSchema, optional, runtime, serviceWithDeps, setupGate };

package/dist/{link-VOoGs-pY.mjs → link-c0_aLWQ3.mjs}

@@ -1,11 +1,17 @@
+import { t as loadConfig } from "./load-config-xMf2wxH8.mjs";
 import fs from "node:fs";
 import path from "node:path";
 //#region src/cli/commands/link.ts
-function findManifest(from) {
+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) {
-		const candidate = path.join(dir, "zenbu.plugin.json");
-		if (fs.existsSync(candidate)) return candidate;
+		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;
@@ -44,23 +50,12 @@ function readRegistryDirFromTsconfig(tsconfigPath) {
 	}
 }
 /**
-* 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.
+* 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) {
-	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;
-	}
+	return findProjectDir(from);
 }
 /**
 * Pick the directory `zen link` should write registry types into.
@@ -86,10 +81,10 @@ function resolveRegistryDir(opts) {
 	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>.`);
+	console.error(`         - run from inside an app dir (with a zenbu.config.ts),`);
+	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) {
@@ -307,7 +302,6 @@ function readExistingRegistry(registryDir) {
 	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];
@@ -319,31 +313,6 @@ function readExistingRegistry(registryDir) {
 				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)) {
@@ -387,32 +356,6 @@ function readExistingRegistry(registryDir) {
 			});
 		}
 	}
-	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,
@@ -438,10 +381,48 @@ function parseLinkArgs(argv) {
 		registryOverride
 	};
 }
-function linkOne(manifestPath, existing) {
-	const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+/**
+* 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) {
+	console.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);
+	console.log(`  Found ${serviceEntries.length} service(s)`);
+	const schemaEntry = plugin.schemaPath ? {
+		name: plugin.name,
+		schemaPath: plugin.schemaPath
+	} : null;
+	if (schemaEntry) console.log(`  Schema: ${schemaEntry.schemaPath}`);
+	const preloadEntry = plugin.preloadPath ? {
+		name: plugin.name,
+		preloadPath: plugin.preloadPath
+	} : null;
+	if (preloadEntry) console.log(`  Preload: ${preloadEntry.preloadPath}`);
+	const eventsEntry = plugin.eventsPath ? {
+		name: plugin.name,
+		eventsPath: plugin.eventsPath
+	} : null;
+	if (eventsEntry) console.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);
+}
+/**
+* Variant for the framework-internal `--types-config <path>` flow where the
+* input is a small JSON file (e.g. `packages/core/zenbu-types.config.json`).
+* Used by `pnpm link:types` inside core to bake its own services/registry
+* types without going through a `zenbu.config.ts`.
+*/
+function linkTypesConfig(jsonPath, existing) {
+	const manifest = JSON.parse(fs.readFileSync(jsonPath, "utf8"));
 	const pluginName = manifest.name;
-	const baseDir = path.dirname(manifestPath);
+	const baseDir = path.dirname(jsonPath);
 	console.log(`Linking types "${pluginName}" from ${baseDir}`);
 	const serviceEntries = discoverServices(baseDir, manifest.services ?? []);
 	console.log(`  Found ${serviceEntries.length} service(s)`);
@@ -491,11 +472,10 @@ function linkOne(manifestPath, existing) {
 * `"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);
+function writePluginTsconfigLocal(pluginDir, registryDir) {
 	const ownTsconfig = path.join(pluginDir, "tsconfig.json");
 	if (!fs.existsSync(ownTsconfig)) return;
-	if (fs.existsSync(path.join(pluginDir, "config.json"))) 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;
@@ -512,55 +492,44 @@ function writePluginTsconfigLocal(pluginManifestPath, registryDir) {
 	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.");
+	if (typesConfigArg) {
+		const typeConfigPath = path.resolve(typesConfigArg);
+		const registryDir = resolveRegistryDir({
+			manifestPath: typeConfigPath,
+			manifest: JSON.parse(fs.readFileSync(typeConfigPath, "utf8")),
+			registryOverride
+		});
+		console.log(`Registry: ${registryDir}`);
+		fs.mkdirSync(registryDir, { recursive: true });
+		const existing = readExistingRegistry(registryDir);
+		linkTypesConfig(typeConfigPath, existing);
+		writeRegistryFiles(registryDir, existing);
+		console.log("Done.");
+		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);
 	}
-	const rootConfigPath = typeConfigPath ?? manifestPath;
+	const { resolved } = await loadConfig(projectDir);
 	const registryDir = resolveRegistryDir({
-		manifestPath: rootConfigPath,
-		manifest: JSON.parse(fs.readFileSync(rootConfigPath, "utf8")),
+		manifestPath: resolved.configPath,
+		manifest: {},
 		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);
+	for (const plugin of resolved.plugins) linkResolvedPlugin(plugin, existing);
+	writeRegistryFiles(registryDir, existing);
+	for (const plugin of resolved.plugins) writePluginTsconfigLocal(plugin.dir, registryDir);
+	console.log("Done.");
+}
+function writeRegistryFiles(registryDir, existing) {
 	const writes = [
 		["services.ts", generateServicesFile(registryDir, existing.services)],
 		["db-sections.ts", generateDbSectionsFile(registryDir, existing.schemas)],
@@ -573,8 +542,6 @@ async function runLink(argv) {
 		fs.writeFileSync(target, body);
 		console.log(`  Wrote ${target}`);
 	}
-	for (const mp of manifestPaths) writePluginTsconfigLocal(mp, registryDir);
-	console.log("Done.");
 }
 //#endregion
 export { runLink };

package/dist/load-config-xMf2wxH8.mjs

@@ -0,0 +1,141 @@
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { i as resolveBuildConfig } from "./build-config-C3a-o3_B.mjs";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/cli/lib/load-config.ts
+var load_config_exports = /* @__PURE__ */ __exportAll({
+	findConfigPath: () => findConfigPath,
+	loadConfig: () => loadConfig
+});
+const localRequire = createRequire(import.meta.url);
+const CONFIG_NAMES = [
+	"zenbu.config.ts",
+	"zenbu.config.mts",
+	"zenbu.config.js",
+	"zenbu.config.mjs"
+];
+const PLUGIN_FILE_RE = /\.(?:ts|mts|js|mjs|cjs)$/;
+function findConfigPath(projectDir) {
+	for (const name of CONFIG_NAMES) {
+		const candidate = path.join(projectDir, name);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	throw new Error(`No zenbu config found at ${projectDir}. Expected one of: ${CONFIG_NAMES.join(", ")}`);
+}
+let tsxRegistered = null;
+function ensureTsxRegistered() {
+	if (tsxRegistered) return tsxRegistered;
+	tsxRegistered = (async () => {
+		try {
+			const tsxApi = localRequire("tsx/esm/api");
+			if (typeof tsxApi.register === "function") tsxApi.register();
+		} catch {}
+	})();
+	return tsxRegistered;
+}
+/**
+* Dynamically import a TS module with a cache-busting query string. Each call
+* forces tsx + Node's ESM loader to re-evaluate the file. Used to rebuild
+* the resolved config + plugin set every time the loader is invoked, so a
+* change to the source TS triggers a fresh `default` export.
+*
+* The returned object is whatever the module's default export is. Older
+* defineConfig-style files that exported the object directly (no `default`)
+* also work via the `mod.default ?? mod` fallback.
+*/
+async function importFresh(absPath) {
+	await ensureTsxRegistered();
+	const mod = await import(pathToFileURL(absPath).href + "?t=" + Date.now());
+	return mod.default ?? mod;
+}
+function assertPluginShape(p, source) {
+	if (!p || typeof p !== "object") throw new Error(`${source} did not export a Plugin object.`);
+	const obj = p;
+	if (typeof obj.name !== "string" || obj.name.length === 0) throw new Error(`${source}: plugin missing required string \`name\`.`);
+	if (!Array.isArray(obj.services)) throw new Error(`${source}: plugin \`services\` must be an array of glob strings.`);
+}
+function resolvePluginPaths(plugin, dir) {
+	const abs = (rel) => path.isAbsolute(rel) ? rel : path.resolve(dir, rel);
+	return {
+		name: plugin.name,
+		dir,
+		services: plugin.services.map((s) => path.isAbsolute(s) ? s : path.resolve(dir, s)),
+		schemaPath: plugin.schema ? abs(plugin.schema) : void 0,
+		migrationsPath: plugin.migrations ? abs(plugin.migrations) : void 0,
+		preloadPath: plugin.preload ? abs(plugin.preload) : void 0,
+		eventsPath: plugin.events ? abs(plugin.events) : void 0,
+		icons: plugin.icons
+	};
+}
+async function resolvePluginEntry(entry, configDir) {
+	if (typeof entry === "string") {
+		const absPath = path.isAbsolute(entry) ? entry : path.resolve(configDir, entry);
+		if (!PLUGIN_FILE_RE.test(absPath)) throw new Error(`Plugin entry "${entry}" must point at a .ts/.js file (got ${path.basename(absPath)}). JSON plugin manifests are not supported in the new config; convert to \`zenbu.plugin.ts\`.`);
+		if (!fs.existsSync(absPath)) throw new Error(`Plugin entry "${entry}" does not exist at ${absPath}.`);
+		const plugin = await importFresh(absPath);
+		assertPluginShape(plugin, absPath);
+		return {
+			resolved: resolvePluginPaths(plugin, path.dirname(absPath)),
+			sourceFile: absPath
+		};
+	}
+	assertPluginShape(entry, "(inline plugin)");
+	return {
+		resolved: resolvePluginPaths(entry, configDir),
+		sourceFile: null
+	};
+}
+/**
+* Read `<projectDir>/zenbu.config.ts`, resolve all plugin entries (inline +
+* path), make every relative path absolute, and fill in `build` defaults.
+*
+* Used both by the loader (to generate the plugin barrel; cache-busted on
+* every invocation) and by CLI commands (`build:source`, `build:electron`,
+* `link`, `db generate`, `publish:source`).
+*/
+async function loadConfig(projectDir) {
+	const configPath = findConfigPath(projectDir);
+	const config = await importFresh(configPath);
+	if (!config || typeof config !== "object") throw new Error(`${configPath} default export is not a Config object.`);
+	if (typeof config.db !== "string" || config.db.length === 0) throw new Error(`${configPath}: missing required \`db\` field (path to the database directory).`);
+	if (typeof config.uiEntrypoint !== "string" || config.uiEntrypoint.length === 0) throw new Error(`${configPath}: missing required \`uiEntrypoint\` field (directory holding index.html + splash.html).`);
+	if (!Array.isArray(config.plugins)) throw new Error(`${configPath}: \`plugins\` must be an array.`);
+	const configDir = path.dirname(configPath);
+	const dbPath = path.isAbsolute(config.db) ? config.db : path.resolve(configDir, config.db);
+	const uiEntrypointPath = path.isAbsolute(config.uiEntrypoint) ? config.uiEntrypoint : path.resolve(configDir, config.uiEntrypoint);
+	if (!(() => {
+		try {
+			return fs.statSync(uiEntrypointPath);
+		} catch {
+			return null;
+		}
+	})()?.isDirectory()) throw new Error(`${configPath}: uiEntrypoint must point at a directory; got ${config.uiEntrypoint}.`);
+	const splashPath = path.join(uiEntrypointPath, "splash.html");
+	if (!fs.existsSync(splashPath)) throw new Error(`${configPath}: uiEntrypoint directory ${config.uiEntrypoint} is missing required \`splash.html\`. The splash file is shown raw (no Vite) during the brief window between Electron startup and the app's first paint.`);
+	const plugins = [];
+	const pluginSourceFiles = [];
+	for (const entry of config.plugins) {
+		const { resolved, sourceFile } = await resolvePluginEntry(entry, configDir);
+		plugins.push(resolved);
+		if (sourceFile) pluginSourceFiles.push(sourceFile);
+	}
+	return {
+		resolved: {
+			configPath,
+			projectDir: configDir,
+			dbPath,
+			uiEntrypointPath,
+			splashPath,
+			plugins,
+			build: resolveBuildConfig(config.build ?? {
+				source: ".",
+				include: ["**/*"]
+			})
+		},
+		pluginSourceFiles
+	};
+}
+//#endregion
+export { load_config_exports as n, loadConfig as t };

package/dist/loaders/zenbu.d.mts

@@ -14,8 +14,25 @@ type TracePort = {
 };
 type InitializeData = {
   tracePort?: TracePort;
+  payload?: RegistryPayload;
+  pluginSourceFiles?: string[];
 };
 declare function initialize(data?: InitializeData): void;
+interface ResolvedPluginRecord {
+  name: string;
+  dir: string;
+  services: string[];
+  schemaPath?: string;
+  migrationsPath?: string;
+  preloadPath?: string;
+  eventsPath?: string;
+  icons?: Record<string, string>;
+}
+interface RegistryPayload {
+  plugins: ResolvedPluginRecord[];
+  appEntrypoint: string;
+  splashPath: string;
+}
 declare function resolve(specifier: string, context: LoaderContext, nextResolve: NextResolve): unknown;
 declare function load(url: string, context: LoaderContext, nextLoad: NextLoad): unknown;
 //#endregion