@zenbujs/core 0.0.5 → 0.0.8

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

@@ -5,9 +5,9 @@ import { fileURLToPath } from "node:url";
 //#region src/services/advice-config.ts
 var advice_config_exports = /* @__PURE__ */ __exportAll({
 	getAdvice: () => getAdvice,
-	getAllAdviceScopes: () => getAllAdviceScopes,
+	getAllAdviceTypes: () => getAllAdviceTypes,
 	getAllContentScriptPaths: () => getAllContentScriptPaths,
-	getAllScopes: () => getAllScopes,
+	getAllTypes: () => getAllTypes,
 	getContentScripts: () => getContentScripts,
 	registerAdvice: () => registerAdvice,
 	registerContentScript: () => registerContentScript
@@ -53,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.
@@ -119,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 { getAllScopes as a, registerContentScript as c, getAllContentScriptPaths as i, getAdvice as n, getContentScripts as o, getAllAdviceScopes as r, registerAdvice as s, advice_config_exports 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 getAllScopes, c as registerContentScript, i as getAllContentScriptPaths, n as getAdvice, o as getContentScripts, r as getAllAdviceScopes, s as registerAdvice } from "./advice-config-QYB2qEd_.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-BbFRRhKP.mjs → base-window-BxBZ2md_.mjs}

@@ -1,9 +1,52 @@
 import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
-import { Service, runtime } from "./runtime.mjs";
+import { Service, getAppEntrypoint, runtime } from "./runtime.mjs";
 import { t as createLogger } from "./log-6rzaCV0I.mjs";
-import { a as DbService } from "./renderer-host-Cau9JK0v.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,
@@ -11,9 +54,10 @@ var base_window_exports = /* @__PURE__ */ __exportAll({
 });
 const log = createLogger("base-window");
 const MAIN_WINDOW_ID = "main";
-var BaseWindowService = class extends Service {
-	static key = "base-window";
-	static deps = { db: DbService };
+var BaseWindowService = class extends Service.create({
+	key: "base-window",
+	deps: { db: DbService }
+}) {
 	windows = /* @__PURE__ */ new Map();
 	get bootWindows() {
 		return globalThis.__zenbu_boot_windows__ ?? [];
@@ -46,7 +90,7 @@ var BaseWindowService = class extends Service {
 				x: 14,
 				y: 10
 			},
-			backgroundColor: "#F4F4F4"
+			backgroundColor: entrypointBgColor()
 		});
 		this.windows.set(windowId, win);
 		win.on("closed", () => this.windows.delete(windowId));
@@ -96,4 +140,4 @@ var BaseWindowService = class extends Service {
 };
 runtime.register(BaseWindowService, import.meta);
 //#endregion
-export { MAIN_WINDOW_ID as n, base_window_exports as r, BaseWindowService as t };
+export { entrypointBgColor as i, MAIN_WINDOW_ID as n, base_window_exports as r, BaseWindowService as t };

package/dist/{transforms-CuTODvDx.d.mts → build-config-Dzg2frpk.d.mts}

@@ -1,13 +1,48 @@
 //#region src/cli/lib/build-config.d.ts
-interface TransformInput {
-  path: string;
-  code: string;
+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 TransformOutput {
-  code?: string;
-  drop?: boolean;
+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>;
 }
-type Transform = (file: TransformInput) => TransformOutput | null | undefined | void;
 interface MirrorConfig {
   target: string;
   branch?: string;
@@ -15,19 +50,63 @@ interface MirrorConfig {
 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[];
-  transforms?: Transform[];
+  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;
 /**
@@ -47,7 +126,7 @@ interface Plugin {
   preload?: string;
   events?: string;
   /**
-   * Plugin-author-defined SVG icons keyed by view scope. Read by
+   * Plugin-author-defined SVG icons keyed by view type. Read by
    * `view-registry` to decorate registered views. Optional.
    */
   icons?: Record<string, string>;
@@ -119,27 +198,18 @@ interface ResolvedConfig {
    * 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
-//#region src/cli/lib/transforms.d.ts
-/**
- * Marker-based feature-flag stripping. Removes lines between
- *   // @zenbu:strip-if FLAG       (strip when FLAG is truthy)
- *   // @zenbu:strip-if !FLAG      (strip when FLAG is falsy)
- *   ...
- *   // @zenbu:end
- *
- * Pure string/line ops — no AST, no compiler dep.
- */
-declare function stripIfDisabled(flags: Record<string, boolean>): Transform;
-/**
- * Drop files whose path matches the given pattern (relative path from the
- * source root, posix slashes). Also covered by `ignore` globs in the config;
- * use this when a regex is more convenient than a glob.
- */
-declare function dropFiles(pattern: RegExp | ((path: string) => boolean)): Transform;
-//#endregion
-export { resolveBuildConfig as _, Config as a, ResolvedBuildConfig as c, Transform as d, TransformInput as f, definePlugin as g, defineConfig as h, BundleConfig as i, ResolvedConfig as l, defineBuildConfig as m, stripIfDisabled as n, MirrorConfig as o, TransformOutput as p, BuildConfig as r, Plugin as s, dropFiles as t, ResolvedPlugin as u };
+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 };