@zenbujs/core 0.0.4 → 0.0.8

package/dist/{advice-config-BLXjqjGN.mjs → advice-config-DXSIo0sg.mjs}

@@ -1,7 +1,17 @@
-import { a as getPlugins, u as runtime } from "./runtime-C95iyVn6.mjs";
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { getPlugins, runtime } from "./runtime.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/services/advice-config.ts
+var advice_config_exports = /* @__PURE__ */ __exportAll({
+	getAdvice: () => getAdvice,
+	getAllAdviceTypes: () => getAllAdviceTypes,
+	getAllContentScriptPaths: () => getAllContentScriptPaths,
+	getAllTypes: () => getAllTypes,
+	getContentScripts: () => getContentScripts,
+	registerAdvice: () => registerAdvice,
+	registerContentScript: () => registerContentScript
+});
 /**
 * Find the plugin whose `dir` contains the file at `metaUrl`. The runtime
 * plugin registry (populated by the loader-emitted barrel) is the source
@@ -43,64 +53,65 @@ const RESOLVED_PREFIX = "\0@advice-prelude/";
 const APP_RENDERER_RELOADER_ID = "app";
 const adviceEntries = /* @__PURE__ */ new Map();
 const contentScripts = /* @__PURE__ */ new Map();
-function invalidatePrelude(scope) {
+function invalidatePrelude(type) {
 	try {
 		const reloader = runtime.getSlot("reloader")?.instance;
 		if (!reloader) return;
 		const coreEntry = reloader.get(APP_RENDERER_RELOADER_ID);
 		if (!coreEntry?.viteServer) return;
 		const graph = coreEntry.viteServer.moduleGraph;
-		const invalidateScope = (s) => {
-			const prefix = RESOLVED_PREFIX + s;
+		const invalidateMatching = (test) => {
 			const ids = [];
 			for (const id of graph.idToModuleMap.keys()) {
 				if (typeof id !== "string") continue;
-				if (id === prefix || id.startsWith(prefix + "?")) ids.push(id);
+				if (test(id)) ids.push(id);
 			}
 			for (const id of ids) {
 				const mod = graph.getModuleById(id);
 				if (mod) graph.invalidateModule(mod);
 			}
 		};
-		if (scope === "*") for (const s of getAllScopes()) invalidateScope(s);
-		else invalidateScope(scope);
+		if (type === "*") invalidateMatching((id) => id.startsWith(RESOLVED_PREFIX));
+		else {
+			const prefix = RESOLVED_PREFIX + type;
+			invalidateMatching((id) => id === prefix || id.startsWith(prefix + "?"));
+		}
 	} catch {}
 }
-function emitReload(scope) {
-	invalidatePrelude(scope);
+function emitReload(type) {
+	invalidatePrelude(type);
 	try {
 		const rpc = runtime.getSlot("rpc")?.instance;
 		if (!rpc) return;
-		if (scope === "*") for (const s of getAllScopes()) rpc.emit.advice.reload({ scope: s });
-		else rpc.emit.advice.reload({ scope });
+		rpc.emit.advice.reload({ type });
 	} catch {}
 }
-function registerAdvice(scope, entry, meta) {
+function registerAdvice(type, entry, meta) {
 	const resolvedEntry = {
 		...entry,
 		modulePath: resolvePluginPath(entry.modulePath, meta)
 	};
-	const list = adviceEntries.get(scope) ?? [];
+	const list = adviceEntries.get(type) ?? [];
 	list.push(resolvedEntry);
-	adviceEntries.set(scope, list);
-	emitReload(scope);
+	adviceEntries.set(type, list);
+	emitReload(type);
 	return () => {
-		const current = adviceEntries.get(scope);
+		const current = adviceEntries.get(type);
 		if (!current) return;
 		const idx = current.indexOf(resolvedEntry);
 		if (idx >= 0) current.splice(idx, 1);
-		if (current.length === 0) adviceEntries.delete(scope);
-		emitReload(scope);
+		if (current.length === 0) adviceEntries.delete(type);
+		emitReload(type);
 	};
 }
-function getAdvice(scope) {
-	return adviceEntries.get(scope) ?? [];
+function getAdvice(type) {
+	return adviceEntries.get(type) ?? [];
 }
-function getAllAdviceScopes() {
+function getAllAdviceTypes() {
 	return [...adviceEntries.keys()];
 }
 /**
-* Register a content script for the given scope. `modulePath` is normally
+* Register a content script for the given view type. `modulePath` is normally
 * a path relative to the plugin root (the folder with `zenbu.plugin.json`);
 * pass `import.meta` so we can resolve it. Absolute paths are accepted as
 * an escape hatch.
@@ -109,35 +120,35 @@ function getAllAdviceScopes() {
 *     registerContentScript("app", "src/content/clock.tsx", import.meta),
 *   )
 */
-function registerContentScript(scope, modulePath, meta) {
+function registerContentScript(type, modulePath, meta) {
 	const entry = { path: resolvePluginPath(modulePath, meta) };
-	const list = contentScripts.get(scope) ?? [];
+	const list = contentScripts.get(type) ?? [];
 	list.push(entry);
-	contentScripts.set(scope, list);
-	emitReload(scope === "*" ? "*" : scope);
+	contentScripts.set(type, list);
+	emitReload(type === "*" ? "*" : type);
 	return () => {
-		const current = contentScripts.get(scope);
+		const current = contentScripts.get(type);
 		if (!current) return;
 		const idx = current.indexOf(entry);
 		if (idx >= 0) current.splice(idx, 1);
-		if (current.length === 0) contentScripts.delete(scope);
-		emitReload(scope === "*" ? "*" : scope);
+		if (current.length === 0) contentScripts.delete(type);
+		emitReload(type === "*" ? "*" : type);
 	};
 }
-function getContentScripts(scope) {
-	const scoped = (contentScripts.get(scope) ?? []).map((e) => e.path);
-	return [...scope !== "*" ? (contentScripts.get("*") ?? []).map((e) => e.path) : [], ...scoped];
+function getContentScripts(type) {
+	const scoped = (contentScripts.get(type) ?? []).map((e) => e.path);
+	return [...type !== "*" ? (contentScripts.get("*") ?? []).map((e) => e.path) : [], ...scoped];
 }
 function getAllContentScriptPaths() {
 	const paths = [];
 	for (const list of contentScripts.values()) for (const entry of list) paths.push(entry.path);
 	return paths;
 }
-function getAllScopes() {
-	const scopes = /* @__PURE__ */ new Set();
-	for (const k of adviceEntries.keys()) scopes.add(k);
-	for (const k of contentScripts.keys()) if (k !== "*") scopes.add(k);
-	return [...scopes];
+function getAllTypes() {
+	const types = /* @__PURE__ */ new Set();
+	for (const k of adviceEntries.keys()) types.add(k);
+	for (const k of contentScripts.keys()) if (k !== "*") types.add(k);
+	return [...types];
 }
 //#endregion
-export { getContentScripts as a, getAllScopes as i, getAllAdviceScopes as n, registerAdvice as o, getAllContentScriptPaths as r, registerContentScript as s, getAdvice as t };
+export { getAllTypes as a, registerContentScript as c, getAllContentScriptPaths as i, getAdvice as n, getContentScripts as o, getAllAdviceTypes as r, registerAdvice as s, advice_config_exports as t };

package/dist/advice.d.mts

@@ -15,11 +15,11 @@ interface ViewAdviceEntry {
 type AdviceSpec = Omit<ViewAdviceEntry, "modulePath"> & {
   modulePath: string;
 };
-declare function registerAdvice(scope: string, entry: AdviceSpec, meta?: ImportMeta): () => void;
-declare function getAdvice(scope: string): ViewAdviceEntry[];
-declare function getAllAdviceScopes(): string[];
+declare function registerAdvice(type: string, entry: AdviceSpec, meta?: ImportMeta): () => void;
+declare function getAdvice(type: string): ViewAdviceEntry[];
+declare function getAllAdviceTypes(): string[];
 /**
- * Register a content script for the given scope. `modulePath` is normally
+ * Register a content script for the given view type. `modulePath` is normally
  * a path relative to the plugin root (the folder with `zenbu.plugin.json`);
  * pass `import.meta` so we can resolve it. Absolute paths are accepted as
  * an escape hatch.
@@ -28,9 +28,9 @@ declare function getAllAdviceScopes(): string[];
  *     registerContentScript("app", "src/content/clock.tsx", import.meta),
  *   )
  */
-declare function registerContentScript(scope: string, modulePath: string, meta?: ImportMeta): () => void;
-declare function getContentScripts(scope: string): string[];
+declare function registerContentScript(type: string, modulePath: string, meta?: ImportMeta): () => void;
+declare function getContentScripts(type: string): string[];
 declare function getAllContentScriptPaths(): string[];
-declare function getAllScopes(): string[];
+declare function getAllTypes(): string[];
 //#endregion
-export { type AdviceSpec, type ViewAdviceEntry, getAdvice, getAllAdviceScopes, getAllContentScriptPaths, getAllScopes, getContentScripts, registerAdvice, registerContentScript };
+export { type AdviceSpec, type ViewAdviceEntry, getAdvice, getAllAdviceTypes, getAllContentScriptPaths, getAllTypes, getContentScripts, registerAdvice, registerContentScript };

package/dist/advice.mjs

@@ -1,2 +1,2 @@
-import { a as getContentScripts, i as getAllScopes, n as getAllAdviceScopes, o as registerAdvice, r as getAllContentScriptPaths, s as registerContentScript, t as getAdvice } from "./advice-config-BLXjqjGN.mjs";
-export { getAdvice, getAllAdviceScopes, getAllContentScriptPaths, getAllScopes, getContentScripts, registerAdvice, registerContentScript };
+import { a as getAllTypes, c as registerContentScript, i as getAllContentScriptPaths, n as getAdvice, o as getContentScripts, r as getAllAdviceTypes, s as registerAdvice } from "./advice-config-DXSIo0sg.mjs";
+export { getAdvice, getAllAdviceTypes, getAllContentScriptPaths, getAllTypes, getContentScripts, registerAdvice, registerContentScript };

package/dist/base-window-BxBZ2md_.mjs

@@ -0,0 +1,143 @@
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { Service, getAppEntrypoint, runtime } from "./runtime.mjs";
+import { t as createLogger } from "./log-6rzaCV0I.mjs";
+import { a as DbService } from "./renderer-host-DD16MXhI.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { nanoid } from "nanoid";
+import { BaseWindow } from "electron";
+//#region src/shared/zenbu-bg.ts
+const META_RE = /<meta\s+name=["']zenbu-bg["']\s+content=["']([^"']+)["']/i;
+/**
+* Read the `<meta name="zenbu-bg" content="#xxx">` value from an HTML
+* file. Returns the configured value, or `fallback` when the file is
+* missing, unreadable, or has no `zenbu-bg` meta tag.
+*
+* This convention exists because Electron paints a `BaseWindow`'s
+* `backgroundColor` for the brief window between the window appearing
+* on screen and the `WebContentsView`'s first frame reaching the
+* compositor — and similarly the view itself flashes its
+* `setBackgroundColor` before any HTML renders. Reading the meta from
+* the same HTML the renderer will paint keeps both colors in sync with
+* whatever theme the renderer is committing to (`#111` for a dark app,
+* `#F4F4F4` for a light one), so the user never sees a single white
+* frame on window open.
+*/
+function readZenbuBgColor(htmlPath, fallback = "#F4F4F4") {
+	try {
+		const match = fs.readFileSync(htmlPath, "utf8").match(META_RE);
+		if (match?.[1]) return match[1];
+	} catch {}
+	return fallback;
+}
+/**
+* Resolve the renderer entrypoint's `zenbu-bg` color via the global
+* plugin registry. Convenience wrapper: services creating windows
+* post-boot don't need to plumb the entrypoint path through —
+* `getAppEntrypoint()` returns whatever was published by the loader's
+* registry-setup module at import time.
+*
+* Returns `fallback` if the registry hasn't been populated yet (i.e.
+* pre-loader code paths) or if the entrypoint dir has no `index.html`
+* with a `zenbu-bg` meta tag.
+*/
+function entrypointBgColor(fallback = "#F4F4F4") {
+	const entrypoint = getAppEntrypoint();
+	if (!entrypoint) return fallback;
+	return readZenbuBgColor(path.join(entrypoint, "index.html"), fallback);
+}
+//#endregion
+//#region src/services/base-window.ts
+var base_window_exports = /* @__PURE__ */ __exportAll({
+	BaseWindowService: () => BaseWindowService,
+	MAIN_WINDOW_ID: () => MAIN_WINDOW_ID
+});
+const log = createLogger("base-window");
+const MAIN_WINDOW_ID = "main";
+var BaseWindowService = class extends Service.create({
+	key: "base-window",
+	deps: { db: DbService }
+}) {
+	windows = /* @__PURE__ */ new Map();
+	get bootWindows() {
+		return globalThis.__zenbu_boot_windows__ ?? [];
+	}
+	set bootWindows(v) {
+		globalThis.__zenbu_boot_windows__ = v;
+	}
+	getZenWidth() {
+		const flag = process.argv.find((a) => a.startsWith("--zen-width="));
+		if (!flag) return void 0;
+		const n = parseInt(flag.slice(12), 10);
+		return isNaN(n) ? void 0 : n;
+	}
+	getWindowId(win) {
+		for (const [id, w] of this.windows) if (w === win) return id;
+	}
+	createWindow(opts) {
+		const windowId = opts?.windowId ?? nanoid();
+		const zenWidth = this.getZenWidth();
+		const win = new BaseWindow({
+			width: opts?.width ?? zenWidth ?? 1100,
+			height: opts?.height ?? 750,
+			...opts?.x != null && opts?.y != null ? {
+				x: opts.x,
+				y: opts.y
+			} : {},
+			show: opts?.show ?? true,
+			titleBarStyle: "hidden",
+			trafficLightPosition: {
+				x: 14,
+				y: 10
+			},
+			backgroundColor: entrypointBgColor()
+		});
+		this.windows.set(windowId, win);
+		win.on("closed", () => this.windows.delete(windowId));
+		return {
+			win,
+			windowId
+		};
+	}
+	evaluate() {
+		if (this.windows.size === 0) if (this.bootWindows.length > 0) {
+			for (const boot of this.bootWindows) {
+				this.windows.set(boot.windowId, boot.win);
+				boot.win.on("closed", () => this.windows.delete(boot.windowId));
+			}
+			this.bootWindows = [];
+		} else {
+			const prefs = this.ctx.db.client.readRoot().plugin.core.windowPrefs;
+			this.createWindow({
+				windowId: MAIN_WINDOW_ID,
+				...prefs[MAIN_WINDOW_ID]?.lastKnownBounds
+			});
+		}
+		this.setup("window-cleanup", () => {
+			return () => {
+				const snapshot = [...this.windows.entries()].map(([windowId, win]) => ({
+					windowId,
+					bounds: win.getBounds()
+				}));
+				this.ctx.db.client.update((root) => {
+					const next = { ...root.plugin.core.windowPrefs };
+					for (const { windowId, bounds } of snapshot) next[windowId] = {
+						...next[windowId],
+						lastKnownBounds: bounds
+					};
+					root.plugin.core.windowPrefs = next;
+				});
+				for (const win of this.windows.values()) {
+					win.__zenbu_on_close = null;
+					win.__zenbu_on_closed = null;
+					win.close();
+				}
+				this.windows.clear();
+			};
+		});
+		log.verbose(`ready (${this.windows.size} windows)`);
+	}
+};
+runtime.register(BaseWindowService, import.meta);
+//#endregion
+export { entrypointBgColor as i, MAIN_WINDOW_ID as n, base_window_exports as r, BaseWindowService as t };

package/dist/build-config-Dzg2frpk.d.mts

@@ -0,0 +1,215 @@
+//#region src/cli/lib/build-config.d.ts
+interface BuildContext {
+  /** Absolute path to the source root (`build.source` resolved). */
+  sourceDir: string;
+  /** Absolute path to the staging output dir (`build.out` resolved). */
+  outDir: string;
+  /** Git HEAD of the source repo at build time, or `"uncommitted"`. */
+  sourceSha: string;
+  /** Absolute path to the `zenbu.config.ts` driving this build. */
+  configPath: string;
+}
+interface EmitContext extends BuildContext {
+  /**
+   * Write an additional file into `outDir`. Relative paths only — anything
+   * absolute or escaping `outDir` (via `..`) throws. Emitted files
+   * participate in the build's `.sha` content hash.
+   */
+  emit(relPath: string, contents: string | Uint8Array): void;
+}
+interface BuildPlugin {
+  name: string;
+  /**
+   * Called once per text file after `include`/`ignore` filtering, before
+   * the file is written to `outDir`. Plugins run in declaration order;
+   * each plugin's return value (if any) feeds the next.
+   *
+   * Return:
+   *   - a string  → use it as the new contents
+   *   - `null`    → drop the file (short-circuits remaining plugins)
+   *   - `void`    → leave contents unchanged
+   *
+   * Binary files (anything outside the small text-extension allow-list)
+   * are not visible to `transform` — they're copied byte-for-byte.
+   */
+  transform?(file: {
+    path: string;
+    contents: string;
+  }, ctx: BuildContext): string | null | void | Promise<string | null | void>;
+  /**
+   * Called once after every source file is written. Use `ctx.emit(...)` to
+   * write additional files (build manifests, generated artifacts, etc.)
+   * into `outDir`. Plugins run in declaration order.
+   */
+  done?(ctx: EmitContext): void | Promise<void>;
+}
+interface MirrorConfig {
+  target: string;
+  branch?: string;
+}
+interface BundleConfig {
+  extraResources?: string[];
+}
+/**
+ * Which package manager the produced .app should bundle and use to install
+ * the cloned source's dependencies on first launch.
+ *
+ * Exactly one PM per .app. The `version` is honored verbatim across all four
+ * variants: it drives the download URL at build time and is recorded in
+ * `app-config.json` so the launcher knows which CI-mode codepath to take.
+ *
+ * `bun` is not special at the API layer — but internally the runtime bun and
+ * the PM bun are collapsed into a single binary at the user's chosen
+ * version (so picking bun yields one binary in the bundle, not two).
+ */
+type PackageManagerSpec = {
+  type: "pnpm";
+  version: string;
+} | {
+  type: "npm";
+  version: string;
+} | {
+  type: "yarn";
+  version: string;
+} | {
+  type: "bun";
+  version: string;
+};
+interface BuildConfig {
+  /**
+   * The .app's "host version" — the developer's product version for the
+   * Electron+core+toolchain bundle as a whole. Required, semver-shaped
+   * (e.g. `"0.0.6"`).
+   *
+   * This is NOT derived from `package.json#version` (which lives in the
+   * source tree and gets overwritten by `git pull`) or from
+   * `@zenbujs/core`'s installed version (a transitive dep, not the
+   * developer's product). Bump it whenever you ship a new .app build.
+   *
+   * `zen build:electron` writes this verbatim into `<bundle>/host.json`.
+   * The launcher and `UpdaterService` read that file to drive
+   * compatibility checks against each commit's `package.json#zenbu.host`
+   * range — the predicate is
+   * `semver.satisfies(hostVersion, commitPackageJson.zenbu.host)`.
+   */
+  hostVersion: string;
+  source?: string;
+  out?: string;
+  include: string[];
+  ignore?: string[];
+  plugins?: BuildPlugin[];
+  mirror?: MirrorConfig;
+  bundle?: BundleConfig;
+  packageManager?: PackageManagerSpec;
+}
+declare function defineBuildConfig(config: BuildConfig): BuildConfig;
+type ResolvedBuildConfig = Required<Omit<BuildConfig, "mirror" | "bundle">> & {
+  mirror?: MirrorConfig;
+  bundle?: BundleConfig;
+  packageManager: PackageManagerSpec;
+};
+declare function resolveBuildConfig(config: BuildConfig): ResolvedBuildConfig;
+/**
+ * A Zenbu plugin's main-process surface. Plugins are pure main-process: they
+ * register services + side-effect modules (schema, preload, events). UI is
+ * handled exclusively at the outer config level via `uiEntrypoint` — there
+ * is exactly one HTML entrypoint per app.
+ *
+ * `services` is an array of glob patterns (relative to the plugin file's
+ * directory). `schema` / `preload` / `events` are optional file paths.
+ */
+interface Plugin {
+  name: string;
+  services: string[];
+  schema?: string;
+  migrations?: string;
+  preload?: string;
+  events?: string;
+  /**
+   * Plugin-author-defined SVG icons keyed by view type. Read by
+   * `view-registry` to decorate registered views. Optional.
+   */
+  icons?: Record<string, string>;
+}
+declare function definePlugin(plugin: Plugin): Plugin;
+/**
+ * A plugin manifest after path resolution. Every relative path has been made
+ * absolute against `dir` (the directory the manifest came from). Glob-form
+ * service entries stay as patterns (still anchored to `dir`).
+ *
+ * The runtime stores these in `runtime.getPlugins()`; consumers like
+ * `services/db.ts`, `services/advice-config.ts`, `vite-plugins.ts` read from
+ * there instead of walking the filesystem looking for `zenbu.plugin.json`.
+ */
+interface ResolvedPlugin {
+  name: string;
+  /** Absolute directory the plugin was loaded from. */
+  dir: string;
+  /** Glob patterns for service files. Anchored to `dir`. */
+  services: string[];
+  /** Absolute path to `schema.ts` (or undefined). */
+  schemaPath?: string;
+  /** Absolute path to migrations dir/file (or undefined). */
+  migrationsPath?: string;
+  /** Absolute path to `preload.ts` (or undefined). */
+  preloadPath?: string;
+  /** Absolute path to `events.ts` (or undefined). */
+  eventsPath?: string;
+  /** Plugin-author-defined SVG icons. */
+  icons?: Record<string, string>;
+}
+/**
+ * The whole-app `zenbu.config.ts` shape. Authored by user code; imported
+ * (and re-imported on every change) by the loader and CLI.
+ *
+ * - `db`: directory the kyju database lives in (relative to the config file).
+ * - `uiEntrypoint`: path to the boot-window's HTML file. Exactly one — there
+ *   is no per-plugin UI (today's per-plugin `uiEntrypoint` was effectively a
+ *   bug that the new shape disallows at the type level).
+ * - `plugins`: flat list. Each entry is either an inline `definePlugin({...})`
+ *   or a path to a `zenbu.plugin.ts` whose default export is a plugin. The
+ *   "host plugin" is just `plugins[0]` by convention; nothing structurally
+ *   distinguishes it.
+ * - `build`: shipped as `defineBuildConfig({...})`. Drives `zen build:source`
+ *   and `zen build:electron`.
+ */
+interface Config {
+  db: string;
+  uiEntrypoint: string;
+  plugins: Array<Plugin | string>;
+  build?: BuildConfig;
+}
+declare function defineConfig(config: Config): Config;
+interface ResolvedConfig {
+  /** Absolute path to the `zenbu.config.ts` this came from. */
+  configPath: string;
+  /** Directory containing `zenbu.config.ts`. */
+  projectDir: string;
+  /** Absolute path to the database directory. */
+  dbPath: string;
+  /**
+   * Absolute path to the renderer's entrypoint directory. Vite's `root`
+   * resolves here; `index.html` inside it is served through Vite.
+   */
+  uiEntrypointPath: string;
+  /**
+   * Absolute path to `splash.html` inside the entrypoint directory. Loaded
+   * raw (no Vite) into a transient BrowserView during the brief window
+   * between Electron `whenReady` and the renderer's first paint.
+   */
+  splashPath: string;
+  /**
+   * Absolute path to `installing.html` inside the entrypoint directory, if
+   * the user provided one. Optional. Production launcher loads this raw
+   * during clone + first install (before the user's source even exists in
+   * the apps-dir). Receives IPC progress events via the framework's
+   * built-in `installing-preload.cjs`. Not used in dev mode — `pnpm dev`
+   * doesn't clone or install.
+   */
+  installingPath?: string;
+  plugins: ResolvedPlugin[];
+  /** Resolved build config; defaults filled in even when user omits. */
+  build: ResolvedBuildConfig;
+}
+//#endregion
+export { Config as a, PackageManagerSpec as c, ResolvedConfig as d, ResolvedPlugin as f, resolveBuildConfig as g, definePlugin as h, BundleConfig as i, Plugin as l, defineConfig as m, BuildContext as n, EmitContext as o, defineBuildConfig as p, BuildPlugin as r, MirrorConfig as s, BuildConfig as t, ResolvedBuildConfig as u };

package/dist/build-config-pWdmLnrk.mjs

@@ -0,0 +1,53 @@
+//#region src/cli/lib/build-config.ts
+/**
+* Soft default when the user omits `build.packageManager` entirely. Existing
+* apps scaffolded before this field existed pick this up. The version
+* tracks whatever pnpm we'd otherwise have hardcoded in the toolchain.
+*/
+const DEFAULT_PACKAGE_MANAGER = {
+	type: "pnpm",
+	version: "10.33.0"
+};
+function defineBuildConfig(config) {
+	return config;
+}
+const SEMVER_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+function validateHostVersion(value) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error("zenbu build.hostVersion: required `string` (e.g. \"0.0.6\"). Set it on `defineBuildConfig({ hostVersion: \"...\" })`.");
+	const trimmed = value.trim();
+	if (!SEMVER_RE.test(trimmed)) throw new Error(`zenbu build.hostVersion: "${value}" is not a valid semver string (expected MAJOR.MINOR.PATCH with optional prerelease / build metadata).`);
+	return trimmed;
+}
+function validatePackageManager(spec) {
+	const allowed = [
+		"pnpm",
+		"npm",
+		"yarn",
+		"bun"
+	];
+	if (!allowed.includes(spec.type)) throw new Error(`zenbu build.packageManager: unknown type "${spec.type}". Expected one of: ${allowed.join(", ")}.`);
+	if (typeof spec.version !== "string" || spec.version.trim().length === 0) throw new Error(`zenbu build.packageManager.${spec.type}: \`version\` is required and must be a non-empty string.`);
+	return spec;
+}
+function resolveBuildConfig(config) {
+	const packageManager = validatePackageManager(config.packageManager ?? DEFAULT_PACKAGE_MANAGER);
+	return {
+		hostVersion: validateHostVersion(config.hostVersion),
+		source: config.source ?? ".",
+		out: config.out ?? ".zenbu/build/source",
+		include: config.include,
+		ignore: config.ignore ?? [],
+		plugins: config.plugins ?? [],
+		mirror: config.mirror,
+		bundle: config.bundle,
+		packageManager
+	};
+}
+function definePlugin(plugin) {
+	return plugin;
+}
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+export { resolveBuildConfig as i, defineConfig as n, definePlugin as r, defineBuildConfig as t };