@zenbujs/core 0.0.5 → 0.0.8

package/dist/{build-source-C2puqEVr.mjs → build-source-d1J3shV8.mjs}

@@ -1,5 +1,5 @@
-import { t as loadConfig } from "./load-config-xMf2wxH8.mjs";
-import { t as hashDir } from "./mirror-sync-PDzxhf1w.mjs";
+import { t as loadConfig } from "./load-config-C4Oe2qZO.mjs";
+import { t as hashDir } from "./mirror-sync-pYU6f3-c.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
@@ -59,24 +59,41 @@ async function collectFiles(sourceDir, config) {
 	}
 	return [...seen].sort();
 }
-async function applyTransforms(input, transforms) {
-	let code = input.code;
-	let drop = false;
-	for (const transform of transforms) {
-		const result = await transform({
-			path: input.path,
-			code
-		});
-		if (!result) continue;
-		if (result.drop) {
-			drop = true;
-			break;
-		}
-		if (typeof result.code === "string") code = result.code;
+/**
+* Run every plugin's `transform` in declaration order. A `null` return drops
+* the file and short-circuits remaining plugins. A string replaces the
+* working contents and feeds the next plugin. `void` leaves contents alone.
+*/
+async function runTransform(filePath, initialContents, plugins, ctx) {
+	let contents = initialContents;
+	for (const plugin of plugins) {
+		if (!plugin.transform) continue;
+		const result = await plugin.transform({
+			path: filePath,
+			contents
+		}, ctx);
+		if (result === null) return {
+			contents,
+			drop: true
+		};
+		if (typeof result === "string") contents = result;
 	}
 	return {
-		code,
-		drop
+		contents,
+		drop: false
+	};
+}
+function makeEmit(outDir, recordWrite) {
+	return (relPath, contents) => {
+		if (typeof relPath !== "string" || relPath.length === 0) throw new Error(`emit: relPath must be a non-empty string, got ${typeof relPath}`);
+		if (path.isAbsolute(relPath)) throw new Error(`emit: relPath must be relative, got absolute path "${relPath}"`);
+		const normalized = path.posix.normalize(relPath.split(path.sep).join("/"));
+		if (normalized.startsWith("../") || normalized === "..") throw new Error(`emit: relPath must not escape outDir, got "${relPath}"`);
+		const dst = path.join(outDir, normalized);
+		fs.mkdirSync(path.dirname(dst), { recursive: true });
+		if (typeof contents === "string") fs.writeFileSync(dst, contents);
+		else fs.writeFileSync(dst, contents);
+		recordWrite(normalized);
 	};
 }
 async function runBuildSource(argv) {
@@ -101,40 +118,58 @@ async function runBuildSource(argv) {
 		console.error("zen build:source: no files matched the include/ignore globs");
 		process.exit(1);
 	}
+	const sourceSha = resolveSourceHead(projectDir);
+	const ctx = {
+		sourceDir,
+		outDir,
+		sourceSha,
+		configPath: resolved.configPath
+	};
 	let written = 0;
 	let dropped = 0;
+	let emitted = 0;
 	for (const rel of files) {
 		const src = path.join(sourceDir, rel);
 		const dst = path.join(outDir, rel);
 		const isText = isLikelyText(src);
-		if (config.transforms.length === 0 || !isText) {
+		if (config.plugins.length === 0 || !isText) {
 			await fsp.mkdir(path.dirname(dst), { recursive: true });
 			await fsp.copyFile(src, dst);
 			written += 1;
 			continue;
 		}
-		const { code: nextCode, drop } = await applyTransforms({
-			path: rel,
-			code: await fsp.readFile(src, "utf8")
-		}, config.transforms);
+		const { contents, drop } = await runTransform(rel, await fsp.readFile(src, "utf8"), config.plugins, ctx);
 		if (drop) {
 			dropped += 1;
 			continue;
 		}
 		await fsp.mkdir(path.dirname(dst), { recursive: true });
-		await fsp.writeFile(dst, nextCode);
+		await fsp.writeFile(dst, contents);
 		written += 1;
 	}
-	const sourceSha = resolveSourceHead(projectDir);
+	if (config.plugins.length > 0) {
+		const emitCtx = {
+			...ctx,
+			emit: makeEmit(outDir, () => {
+				emitted += 1;
+			})
+		};
+		for (const plugin of config.plugins) {
+			if (!plugin.done) continue;
+			await plugin.done(emitCtx);
+		}
+	}
 	const meta = {
 		sourceSha,
 		contentHash: await hashDir(outDir),
 		builtAt: (/* @__PURE__ */ new Date()).toISOString(),
 		files: written,
-		dropped
+		dropped,
+		emitted
 	};
 	await fsp.writeFile(path.join(outDir, ".sha"), JSON.stringify(meta, null, 2) + "\n");
-	console.log(`\n  ✓ ${written} file(s) written, ${dropped} dropped by transforms`);
+	const emittedSuffix = emitted > 0 ? `, ${emitted} emitted by plugins` : "";
+	console.log(`\n  ✓ ${written} file(s) written, ${dropped} dropped${emittedSuffix}`);
 	console.log(`    source HEAD: ${sourceSha === "uncommitted" ? sourceSha : sourceSha.slice(0, 7)}\n`);
 }
 const TEXT_EXTENSIONS = new Set([

package/dist/cli/bin.mjs

@@ -41,37 +41,37 @@ async function main() {
 	const rest = argv.slice(1);
 	switch (first) {
 		case "dev": {
-			const { runDev } = await import("../dev-Dazhu66l.mjs");
+			const { runDev } = await import("../dev-B2emj0HZ.mjs");
 			await runDev(rest);
 			return;
 		}
 		case "build:source": {
-			const { runBuildSource } = await import("../build-source-C2puqEVr.mjs");
+			const { runBuildSource } = await import("../build-source-d1J3shV8.mjs");
 			await runBuildSource(rest);
 			return;
 		}
 		case "build:electron": {
-			const { runBuildElectron } = await import("../build-electron-CNJ0dLND.mjs");
+			const { runBuildElectron } = await import("../build-electron-Dsbb1EMl.mjs");
 			await runBuildElectron(rest);
 			return;
 		}
 		case "publish:source": {
-			const { runPublishSource } = await import("../publish-source-Dill72NS.mjs");
+			const { runPublishSource } = await import("../publish-source-Dq2c0iOw.mjs");
 			await runPublishSource(rest);
 			return;
 		}
 		case "link": {
-			const { runLink } = await import("../link-c0_aLWQ3.mjs");
+			const { runLink } = await import("../link-glX89NV5.mjs").then((n) => n.n);
 			await runLink(rest);
 			return;
 		}
 		case "monorepo": {
-			const { runMonorepo } = await import("../monorepo-3avKJwzJ.mjs");
+			const { runMonorepo } = await import("../monorepo-Dct-kkbQ.mjs");
 			await runMonorepo(rest);
 			return;
 		}
 		case "db": {
-			const { runDb } = await import("../db-xjvahRFJ.mjs");
+			const { runDb } = await import("../db-Bc292RYo.mjs");
 			await runDb(rest);
 			return;
 		}

package/dist/cli/build.d.mts

@@ -1,2 +1,2 @@
-import { _ as resolveBuildConfig, c as ResolvedBuildConfig, d as Transform, f as TransformInput, i as BundleConfig, m as defineBuildConfig, n as stripIfDisabled, o as MirrorConfig, p as TransformOutput, r as BuildConfig, t as dropFiles } from "../transforms-CuTODvDx.mjs";
-export { type BuildConfig, type BundleConfig, type MirrorConfig, type ResolvedBuildConfig, type Transform, type TransformInput, type TransformOutput, defineBuildConfig, dropFiles, resolveBuildConfig, stripIfDisabled };
+import { g as resolveBuildConfig, i as BundleConfig, n as BuildContext, o as EmitContext, p as defineBuildConfig, r as BuildPlugin, s as MirrorConfig, t as BuildConfig, u as ResolvedBuildConfig } from "../build-config-Dzg2frpk.mjs";
+export { type BuildConfig, type BuildContext, type BuildPlugin, type BundleConfig, type EmitContext, type MirrorConfig, type ResolvedBuildConfig, defineBuildConfig, resolveBuildConfig };

package/dist/cli/build.mjs

@@ -1,3 +1,2 @@
-import { i as resolveBuildConfig, t as defineBuildConfig } from "../build-config-C3a-o3_B.mjs";
-import { n as stripIfDisabled, t as dropFiles } from "../transforms-htxfTwsY.mjs";
-export { defineBuildConfig, dropFiles, resolveBuildConfig, stripIfDisabled };
+import { i as resolveBuildConfig, t as defineBuildConfig } from "../build-config-pWdmLnrk.mjs";
+export { defineBuildConfig, resolveBuildConfig };

package/dist/cli/resolve-config.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as loadConfig } from "../load-config-xMf2wxH8.mjs";
+import { t as loadConfig } from "../load-config-C4Oe2qZO.mjs";
 import { register } from "tsx/esm/api";
 //#region src/cli/resolve-config.ts
 async function main() {

package/dist/{cli-C3R1LBMY.mjs → cli-kL6mPgBE.mjs}

@@ -1,6 +1,6 @@
 import { o as getZodDefault, t as NO_DEFAULT } from "./schema-Ca7SxXgS.mjs";
 import { _ as handleErrnoException, d as readJsonFile, f as readJsonlFile, g as layer$7, l as paths, n as makeRootCache, t as handleWrite, v as FileSystem, y as BadArgument } from "./write-DgIRjo23.mjs";
-import { loadSchema } from "./config-DXRCDUxG.mjs";
+import { loadSchema } from "./config-BK78JDRI.mjs";
 import fs from "node:fs";
 import * as NodePath from "node:path";
 import path from "node:path";
@@ -8030,7 +8030,7 @@ async function run(argv) {
 		process.exit(args.help ? 0 : 1);
 	}
 	if (args.command === "generate") {
-		const { findConfigFile, loadConfig } = await import("./config-DXRCDUxG.mjs");
+		const { findConfigFile, loadConfig } = await import("./config-BK78JDRI.mjs");
 		const resolved = await loadConfig(args.config ?? findConfigFile(process.cwd()));
 		await generateMigration({
 			schemaPath: resolved.schemaPath,

package/dist/config.d.mts

@@ -1,3 +1,3 @@
-import { a as Config, c as ResolvedBuildConfig, d as Transform, f as TransformInput, g as definePlugin, h as defineConfig, i as BundleConfig, l as ResolvedConfig, m as defineBuildConfig, n as stripIfDisabled, o as MirrorConfig, p as TransformOutput, r as BuildConfig, s as Plugin, t as dropFiles, u as ResolvedPlugin } from "./transforms-CuTODvDx.mjs";
-import { _ as subscribeConfig, c as getPlugin, l as getPlugins, n as ConfigSnapshot, o as getAppEntrypoint, r as PluginRecord, s as getConfig, u as getSplashPath } from "./runtime-pCeVzj--.mjs";
-export { type BuildConfig, type BundleConfig, type Config, type ConfigSnapshot, type MirrorConfig, type Plugin, type PluginRecord, type ResolvedBuildConfig, type ResolvedConfig, type ResolvedPlugin, type Transform, type TransformInput, type TransformOutput, defineBuildConfig, defineConfig, definePlugin, dropFiles, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, stripIfDisabled, subscribeConfig };
+import { a as Config, c as PackageManagerSpec, d as ResolvedConfig, f as ResolvedPlugin, h as definePlugin, i as BundleConfig, l as Plugin, m as defineConfig, n as BuildContext, o as EmitContext, p as defineBuildConfig, r as BuildPlugin, s as MirrorConfig, t as BuildConfig, u as ResolvedBuildConfig } from "./build-config-Dzg2frpk.mjs";
+import { c as getConfig, d as getSplashPath, g as subscribeConfig, l as getPlugin, n as ConfigSnapshot, r as PluginRecord, s as getAppEntrypoint, u as getPlugins } from "./runtime-BQWntcOb.mjs";
+export { type BuildConfig, type BuildContext, type BuildPlugin, type BundleConfig, type Config, type ConfigSnapshot, type EmitContext, type MirrorConfig, type PackageManagerSpec, type Plugin, type PluginRecord, type ResolvedBuildConfig, type ResolvedConfig, type ResolvedPlugin, defineBuildConfig, defineConfig, definePlugin, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, subscribeConfig };

package/dist/config.mjs

@@ -1,4 +1,3 @@
 import { getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, subscribeConfig } from "./runtime.mjs";
-import { n as defineConfig, r as definePlugin, t as defineBuildConfig } from "./build-config-C3a-o3_B.mjs";
-import { n as stripIfDisabled, t as dropFiles } from "./transforms-htxfTwsY.mjs";
-export { defineBuildConfig, defineConfig, definePlugin, dropFiles, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, stripIfDisabled, subscribeConfig };
+import { n as defineConfig, r as definePlugin, t as defineBuildConfig } from "./build-config-pWdmLnrk.mjs";
+export { defineBuildConfig, defineConfig, definePlugin, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, subscribeConfig };

package/dist/{db-xjvahRFJ.mjs → db-Bc292RYo.mjs}

@@ -469,7 +469,7 @@ function parseGenerateArgs(argv) {
 }
 async function runGenerate(argv) {
 	const flags = parseGenerateArgs(argv);
-	const { generateMigration } = await import("./cli-C3R1LBMY.mjs");
+	const { generateMigration } = await import("./cli-kL6mPgBE.mjs");
 	if (flags.schema || flags.migrationsOut) {
 		if (!flags.schema || !flags.migrationsOut) {
 			console.error("zen db generate: --schema and --migrations must be passed together.");
@@ -495,7 +495,7 @@ async function runGenerate(argv) {
 		console.error("                 --schema <path> --migrations <path> directly.");
 		process.exit(1);
 	}
-	const { loadConfig } = await import("./load-config-xMf2wxH8.mjs").then((n) => n.n);
+	const { loadConfig } = await import("./load-config-C4Oe2qZO.mjs").then((n) => n.n);
 	const { resolved } = await loadConfig(projectDir);
 	const cwd = path.resolve(process.cwd());
 	let bestMatch = null;

package/dist/db.d.mts

@@ -1,4 +1,4 @@
-import { S as createSchema, _ as InferSchema$1, a as dbStringify, b as blob, f as CollectionRefBrand$1, g as InferRoot$1, i as dbParse, n as connectReplica, o as ClientProxy, p as CollectionRefValue$1, s as CollectionNode$1, v as Schema$1, x as collection, y as SchemaShape$1 } from "./index-M_lSNBrq.mjs";
+import { S as createSchema, _ as InferSchema$1, a as dbStringify, b as blob, f as CollectionRefBrand$1, g as InferRoot$1, i as dbParse, n as connectReplica, o as ClientProxy, p as CollectionRefValue$1, s as CollectionNode$1, v as Schema$1, x as collection, y as SchemaShape$1 } from "./index-DeDxePAa.mjs";
 import { z as z$1 } from "zod";
 
 //#region src/db.d.ts

package/dist/dev-B2emj0HZ.mjs

@@ -0,0 +1,301 @@
+import { t as linkProject } from "./link-glX89NV5.mjs";
+import { existsSync, statSync } from "node:fs";
+import path, { resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { subscribe } from "@parcel/watcher";
+//#region src/cli/lib/link-watcher.ts
+const RELINK_DEBOUNCE_MS = 120;
+const COMMON_IGNORES = [
+	"**/node_modules",
+	"**/.git",
+	"**/.zenbu",
+	"**/.next",
+	"**/dist",
+	"**/build",
+	"**/.turbo",
+	"**/.cache"
+];
+/**
+* Start a file watcher that re-runs `zen link` whenever any source the
+* link command consumes changes. Used by `zen dev` so users don't have to
+* remember to rerun `zen link` after adding a service file or editing
+* `zenbu.config.ts`.
+*
+* Failure modes:
+*   - Initial link throws (bad config): we still start the watcher so the
+*     user can recover by editing the file. The error is reported once;
+*     subsequent failed relinks during typing stay silent on purpose.
+*   - Relink throws (broken syntax mid-edit): swallowed silently. The next
+*     successful relink will catch up.
+*
+* The watcher rebuilds its subscription set after every successful relink:
+* the resolved plugin set drives which directories are watched, and that
+* set itself can change when the user edits `zenbu.config.ts` to add or
+* remove a plugin entry.
+*/
+async function startLinkWatcher(projectDir, opts = {}) {
+	let subscriptions = [];
+	let closed = false;
+	let relinkScheduled = false;
+	let relinkInFlight = false;
+	let relinkPending = false;
+	let lastWatchKey = null;
+	let initial = null;
+	try {
+		initial = await linkProject(projectDir, {
+			registryOverride: opts.registryOverride ?? null,
+			quiet: true
+		});
+		if (opts.verbose) console.error(`[zen dev] initial link ok`);
+	} catch (err) {
+		console.error(`[zen dev] initial link failed (will retry on file change): ${err instanceof Error ? err.message : err}`);
+	}
+	const compileFromResult = (result) => {
+		if (!result) return [{
+			rootDir: projectDir,
+			exactPaths: new Set([
+				"zenbu.config.ts",
+				"zenbu.config.mts",
+				"zenbu.config.js",
+				"zenbu.config.mjs"
+			].map((n) => path.join(projectDir, n))),
+			globMatchers: []
+		}];
+		return compileTargets(result);
+	};
+	const subscribeAll = async (targets) => {
+		await teardownAll();
+		if (closed) return;
+		for (const target of targets) try {
+			const sub = await subscribe(target.rootDir, (err, events) => {
+				if (err) return;
+				if (!eventsAreRelevant(events, target)) return;
+				scheduleRelink();
+			}, { ignore: COMMON_IGNORES });
+			if (closed) {
+				await sub.unsubscribe().catch(() => {});
+				return;
+			}
+			subscriptions.push(sub);
+		} catch (err) {
+			if (opts.verbose) console.error(`[zen dev] watcher subscribe failed for ${target.rootDir}: ${err instanceof Error ? err.message : err}`);
+		}
+	};
+	const teardownAll = async () => {
+		const subs = subscriptions;
+		subscriptions = [];
+		await Promise.all(subs.map((s) => s.unsubscribe().catch(() => {})));
+	};
+	const reconcileSubscriptions = async (result) => {
+		const targets = compileFromResult(result);
+		const key = watchKey(targets);
+		if (key === lastWatchKey) return;
+		lastWatchKey = key;
+		await subscribeAll(targets);
+	};
+	await reconcileSubscriptions(initial);
+	function scheduleRelink() {
+		if (closed) return;
+		if (relinkInFlight) {
+			relinkPending = true;
+			return;
+		}
+		if (relinkScheduled) return;
+		relinkScheduled = true;
+		setTimeout(() => {
+			relinkScheduled = false;
+			runRelink();
+		}, RELINK_DEBOUNCE_MS);
+	}
+	async function runRelink() {
+		if (closed) return;
+		relinkInFlight = true;
+		try {
+			const result = await linkProject(projectDir, {
+				registryOverride: opts.registryOverride ?? null,
+				quiet: true
+			});
+			if (opts.verbose) console.error(`[zen dev] relinked`);
+			await reconcileSubscriptions(result);
+		} catch {} finally {
+			relinkInFlight = false;
+			if (relinkPending && !closed) {
+				relinkPending = false;
+				scheduleRelink();
+			}
+		}
+	}
+	return { async close() {
+		closed = true;
+		await teardownAll();
+	} };
+}
+/**
+* Build the set of (directory, filter) pairs we need watchers for. The
+* filter side matters: we subscribe recursively to a dir but only treat
+* matching events as link-relevant.
+*
+* The set covers everything `linkProject` reads:
+*   - the `zenbu.config.ts` itself,
+*   - any `zenbu.plugin.ts` files imported from the config,
+*   - per-plugin schema/preload/events/migrations files,
+*   - per-plugin service glob expansions.
+*/
+function compileTargets(result) {
+	const exactPaths = new Set([result.resolvedConfigPath]);
+	for (const f of result.pluginSourceFiles) exactPaths.add(f);
+	const globMatchers = [];
+	const candidateDirs = /* @__PURE__ */ new Set();
+	candidateDirs.add(path.dirname(result.resolvedConfigPath));
+	for (const f of result.pluginSourceFiles) candidateDirs.add(path.dirname(f));
+	for (const plugin of result.resolved.plugins) addPluginPaths(plugin, exactPaths, globMatchers, candidateDirs);
+	return minimalCover([...candidateDirs]).map((rootDir) => ({
+		rootDir,
+		exactPaths,
+		globMatchers
+	}));
+}
+function addPluginPaths(plugin, exactPaths, globMatchers, candidateDirs) {
+	candidateDirs.add(plugin.dir);
+	for (const p of [
+		plugin.schemaPath,
+		plugin.preloadPath,
+		plugin.eventsPath,
+		plugin.migrationsPath
+	]) if (p) {
+		exactPaths.add(p);
+		candidateDirs.add(path.dirname(p));
+	}
+	for (const serviceGlobAbs of plugin.services) {
+		if (!serviceGlobAbs.includes("*")) {
+			exactPaths.add(serviceGlobAbs);
+			candidateDirs.add(path.dirname(serviceGlobAbs));
+			continue;
+		}
+		const dir = path.dirname(serviceGlobAbs);
+		const base = path.basename(serviceGlobAbs);
+		const re = new RegExp("^" + base.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
+		globMatchers.push({
+			dir,
+			re
+		});
+		candidateDirs.add(dir);
+	}
+}
+function eventsAreRelevant(events, target) {
+	for (const event of events) {
+		const abs = event.path;
+		if (target.exactPaths.has(abs)) return true;
+		for (const { dir, re } of target.globMatchers) if (path.dirname(abs) === dir && re.test(path.basename(abs))) return true;
+	}
+	return false;
+}
+function minimalCover(dirs) {
+	const unique = [...new Set(dirs.map((d) => path.resolve(d)))];
+	unique.sort((a, b) => a.length - b.length);
+	const kept = [];
+	for (const d of unique) if (!kept.some((k) => d === k || d.startsWith(k + path.sep))) kept.push(d);
+	return kept;
+}
+function watchKey(targets) {
+	const parts = [];
+	for (const t of targets) {
+		const exacts = [...t.exactPaths].sort().join("|");
+		const globs = t.globMatchers.map((m) => `${m.dir}::${m.re.source}`).sort().join("|");
+		parts.push(`${t.rootDir}<<${exacts}>>${globs}`);
+	}
+	return parts.sort().join("\n");
+}
+//#endregion
+//#region src/cli/commands/dev.ts
+/**
+* `zen dev` — launch the local app under Electron with the setup-gate as the
+* main entry. This is the entrypoint of `pnpm dev` in scaffolded apps. The
+* command is intentionally hookable: future versions can layer doctor checks,
+* environment validation, or a managed dev-server here without touching the
+* user's `package.json` scripts.
+*
+* Defaults to a foreground/blocking child so Ctrl+C in the terminal kills the
+* Electron process and `pnpm dev` exits cleanly. Pass `--detach` to spawn it
+* in the background instead (returns immediately, Electron lives until quit).
+*/
+function parseArgs(argv) {
+	let pathArg;
+	let detach = false;
+	let verbose = false;
+	let watch = true;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--detach") detach = true;
+		else if (arg === "--verbose" || arg === "-v") verbose = true;
+		else if (arg === "--no-watch") watch = false;
+		else if (!arg.startsWith("-") && pathArg == null) pathArg = arg;
+		else {
+			console.error(`zen dev: unknown flag "${arg}"`);
+			console.error(`valid: zen dev [path] [--detach] [--verbose] [--no-watch]`);
+			process.exit(1);
+		}
+	}
+	const projectDir = pathArg ? resolve(process.cwd(), pathArg) : process.cwd();
+	if (!existsSync(projectDir)) {
+		console.error(`zen dev: path "${pathArg}" does not exist`);
+		process.exit(1);
+	}
+	try {
+		if (!statSync(projectDir).isDirectory()) {
+			console.error(`zen dev: path "${pathArg}" is not a directory`);
+			process.exit(1);
+		}
+	} catch {
+		console.error(`zen dev: cannot stat "${pathArg}"`);
+		process.exit(1);
+	}
+	return {
+		projectDir,
+		detach,
+		verbose,
+		watch
+	};
+}
+function resolveLocalElectron(projectDir) {
+	const candidates = [path.join(projectDir, "node_modules", "electron", "dist", "Electron.app", "Contents", "MacOS", "Electron"), path.join(projectDir, "node_modules", ".bin", "electron")];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+	throw new Error(`Electron is not installed in ${projectDir}. Run \`pnpm install\` in the app.`);
+}
+function ensureSetupGate(projectDir) {
+	const setupGate = path.join(projectDir, "node_modules", "@zenbujs", "core", "dist", "setup-gate.mjs");
+	if (!existsSync(setupGate)) throw new Error(`@zenbujs/core setup-gate not found at ${setupGate}. Run \`pnpm install\` in the app.`);
+}
+async function runDev(argv) {
+	const { projectDir, detach, verbose, watch } = parseArgs(argv);
+	if (verbose) console.error("[zen dev] launching:", projectDir);
+	const electron = resolveLocalElectron(projectDir);
+	ensureSetupGate(projectDir);
+	let watcher = null;
+	if (watch && !detach) try {
+		watcher = await startLinkWatcher(projectDir, { verbose });
+	} catch (err) {
+		console.error(`[zen dev] link watcher disabled: ${err instanceof Error ? err.message : err}`);
+	}
+	const electronArgs = [projectDir, `--project=${projectDir}`];
+	if (detach) {
+		spawn(electron, electronArgs, {
+			cwd: projectDir,
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+		return;
+	}
+	const child = spawn(electron, electronArgs, {
+		cwd: projectDir,
+		stdio: "inherit"
+	});
+	process.on("SIGINT", () => child.kill("SIGINT"));
+	process.on("SIGTERM", () => child.kill("SIGTERM"));
+	child.on("exit", async (code, signal) => {
+		if (watcher) await watcher.close().catch(() => {});
+		process.exit(code ?? (signal ? 1 : 0));
+	});
+}
+//#endregion
+export { runDev };

package/dist/env-bootstrap.d.mts

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

package/dist/events.d.mts

@@ -0,0 +1,19 @@
+//#region src/events.d.ts
+/**
+ * Core's own events file. Mirrors the contract every plugin follows
+ * (`events: "./path/to/events.ts"` in zenbu.config / zenbu.plugin),
+ * exporting a single `Events` type that the link generator scans into
+ * the registry's `CoreEvents`.
+ *
+ * Each top-level key is a namespace; `rpc.emit.<namespace>.<event>(payload)`
+ * inside a service emits with the matching payload type.
+ */
+type Events = {
+  advice: {
+    reload: {
+      type: string;
+    };
+  };
+};
+//#endregion
+export { Events };

package/dist/events.mjs

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

package/dist/host-version-BIrF8tX7.mjs

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+//#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`.
+*
+* Imported by both:
+*   - `packages/core/src/launcher.ts` (tsdown inlines this into
+*     `dist/launcher.mjs`; the launcher cannot `import "@zenbujs/core"`)
+*   - `packages/core/src/services/updater.ts` (resolved through normal
+*     `@zenbujs/core/...` resolution at runtime)
+*
+* The file lives at the bundle root (`<APP_PATH>/host.json`, where
+* `APP_PATH = app.getAppPath()`), separate from `app-config.json` so
+* its single purpose stays obvious.
+*/
+const HOST_VERSION_FILENAME = "host.json";
+/**
+* Read `<appPath>/host.json` and return its `version` field. Throws an
+* informative error if the file is missing, unreadable, malformed, or
+* the `version` field is missing/empty. Callers in dev mode should
+* check for the file's existence first (or use `tryReadHostVersion`).
+*/
+function readHostVersion(appPath) {
+	const filePath = path.join(appPath, HOST_VERSION_FILENAME);
+	let raw;
+	try {
+		raw = fs.readFileSync(filePath, "utf8");
+	} catch (err) {
+		const e = err;
+		if (e.code === "ENOENT") throw new Error(`[host-version] missing ${filePath}. Was this .app built with a recent \`zen build:electron\`? The build step is responsible for writing host.json.`);
+		throw new Error(`[host-version] failed to read ${filePath}: ${e.message ?? String(e)}`);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (err) {
+		throw new Error(`[host-version] ${filePath} is not valid JSON: ${err.message}`);
+	}
+	if (typeof parsed !== "object" || parsed === null || typeof parsed.version !== "string" || parsed.version.trim().length === 0) throw new Error(`[host-version] ${filePath} is missing a non-empty \`version\` string.`);
+	return {
+		version: parsed.version.trim(),
+		path: filePath
+	};
+}
+/** Non-throwing variant. Returns `null` when the file is absent or invalid. */
+function tryReadHostVersion(appPath) {
+	try {
+		return readHostVersion(appPath);
+	} catch {
+		return null;
+	}
+}
+/** Inverse of `readHostVersion` — used by `zen build:electron`. */
+function writeHostVersion(appPath, version) {
+	const filePath = path.join(appPath, HOST_VERSION_FILENAME);
+	const body = { version };
+	fs.writeFileSync(filePath, JSON.stringify(body, null, 2) + "\n");
+	return filePath;
+}
+//#endregion
+export { tryReadHostVersion as n, writeHostVersion as r, HOST_VERSION_FILENAME as t };