@zenbujs/core 0.0.1

package/LICENSE

@@ -0,0 +1,11 @@
+All Rights Reserved
+
+Copyright (c) 2026 Zenbu Labs Inc.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/advice-config-CjgkEf2E.mjs

@@ -0,0 +1,135 @@
+import { i as runtime } from "./runtime-DUFKDIe4.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/services/advice-config.ts
+/**
+* Walk up from the given file URL until we find a `zenbu.plugin.json`. The
+* folder containing it is the plugin root and the anchor that
+* `registerContentScript` / `registerAdvice` resolve relative paths against.
+*
+* Throws (with the URL in the message) if no manifest is found, because a
+* silent fallback to `process.cwd()` would attach a content script to a
+* nonsensical location and you'd debug it by staring at empty iframes.
+*/
+function findPluginRoot(metaUrl) {
+	let dir = path.dirname(fileURLToPath(metaUrl));
+	while (dir !== path.dirname(dir)) {
+		if (fs.existsSync(path.join(dir, "zenbu.plugin.json"))) return dir;
+		dir = path.dirname(dir);
+	}
+	throw new Error(`Could not find zenbu.plugin.json walking up from ${metaUrl}. Pass an absolute path, or call this from a file inside a Zenbu plugin.`);
+}
+/**
+* Accepts either an absolute path (used as-is) or a path relative to the
+* caller's plugin root. The `meta` argument is `import.meta` from the calling
+* module; without it we can't compute the plugin root, so relative paths
+* require it.
+*/
+function resolvePluginPath(modulePath, meta) {
+	if (path.isAbsolute(modulePath)) return modulePath;
+	if (!meta?.url) throw new Error(`registerContentScript/registerAdvice: relative path "${modulePath}" requires import.meta as the second argument so we can find the plugin root.`);
+	return path.resolve(findPluginRoot(meta.url), modulePath);
+}
+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) {
+	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 ids = [];
+			for (const id of graph.idToModuleMap.keys()) {
+				if (typeof id !== "string") continue;
+				if (id === prefix || id.startsWith(prefix + "?")) 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);
+	} catch {}
+}
+function emitReload(scope) {
+	invalidatePrelude(scope);
+	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 });
+	} catch {}
+}
+function registerAdvice(scope, entry, meta) {
+	const resolvedEntry = {
+		...entry,
+		modulePath: resolvePluginPath(entry.modulePath, meta)
+	};
+	const list = adviceEntries.get(scope) ?? [];
+	list.push(resolvedEntry);
+	adviceEntries.set(scope, list);
+	emitReload(scope);
+	return () => {
+		const current = adviceEntries.get(scope);
+		if (!current) return;
+		const idx = current.indexOf(resolvedEntry);
+		if (idx >= 0) current.splice(idx, 1);
+		if (current.length === 0) adviceEntries.delete(scope);
+		emitReload(scope);
+	};
+}
+function getAdvice(scope) {
+	return adviceEntries.get(scope) ?? [];
+}
+function getAllAdviceScopes() {
+	return [...adviceEntries.keys()];
+}
+/**
+* Register a content script for the given scope. `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.
+*
+*   this.setup("inject", () =>
+*     registerContentScript("app", "src/content/clock.tsx", import.meta),
+*   )
+*/
+function registerContentScript(scope, modulePath, meta) {
+	const entry = { path: resolvePluginPath(modulePath, meta) };
+	const list = contentScripts.get(scope) ?? [];
+	list.push(entry);
+	contentScripts.set(scope, list);
+	emitReload(scope === "*" ? "*" : scope);
+	return () => {
+		const current = contentScripts.get(scope);
+		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);
+	};
+}
+function getContentScripts(scope) {
+	const scoped = (contentScripts.get(scope) ?? []).map((e) => e.path);
+	return [...scope !== "*" ? (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];
+}
+//#endregion
+export { getContentScripts as a, getAllScopes as i, getAllAdviceScopes as n, registerAdvice as o, getAllContentScriptPaths as r, registerContentScript as s, getAdvice as t };

package/dist/advice-config-Cy133IQP.mjs

@@ -0,0 +1,2 @@
+import "./advice-config-CjgkEf2E.mjs";
+export {};

package/dist/advice-runtime.d.mts

@@ -0,0 +1,35 @@
+//#region ../advice/src/runtime/registry.d.ts
+type AdviceType = "before" | "after" | "around";
+//#endregion
+//#region ../advice/src/runtime/index.d.ts
+/**
+ * Register a function implementation. Called by transformed code.
+ * Sets entry.impl only -- does not touch entry.replacement, so plugin
+ * overrides survive HMR re-evaluation of the original module.
+ */
+declare function __def(moduleId: string, name: string, fn: Function): void;
+/**
+ * Returns a stable wrapper function that dispatches through the advice chain.
+ * Returns the same function reference for the same moduleId+name across calls,
+ * which is critical for React Refresh component identity.
+ */
+declare function __ref(moduleId: string, name: string): Function;
+/**
+ * Override a function with a plugin-provided replacement.
+ * Unlike __def(), this sets entry.replacement which takes precedence
+ * over entry.impl and is NOT cleared by subsequent __def() calls.
+ * This allows a prelude script to call replace() before modules load,
+ * and have the replacement survive module evaluation.
+ */
+declare function replace(moduleId: string, name: string, newFn: Function): void;
+/**
+ * Remove a previously set replacement, restoring the original implementation.
+ */
+declare function unreplace(moduleId: string, name: string): void;
+/**
+ * Add before/after/around advice to a function.
+ * Returns a removal function.
+ */
+declare function advise(moduleId: string, name: string, type: AdviceType, fn: Function): () => void;
+//#endregion
+export { type AdviceType, __def, __ref, advise, replace, unreplace };

package/dist/advice-runtime.mjs

@@ -0,0 +1,131 @@
+//#region ../advice/src/runtime/registry.ts
+const registry = /* @__PURE__ */ new Map();
+function getEntry(moduleId, name) {
+	return registry.get(moduleId)?.get(name);
+}
+function getOrCreateEntry(moduleId, name) {
+	let moduleMap = registry.get(moduleId);
+	if (!moduleMap) {
+		moduleMap = /* @__PURE__ */ new Map();
+		registry.set(moduleId, moduleMap);
+	}
+	let entry = moduleMap.get(name);
+	if (!entry) {
+		entry = {
+			impl: () => {
+				throw new Error(`${moduleId}:${name} not yet defined`);
+			},
+			replacement: null,
+			advice: []
+		};
+		moduleMap.set(name, entry);
+	}
+	return entry;
+}
+function setImpl(moduleId, name, fn) {
+	const entry = getOrCreateEntry(moduleId, name);
+	entry.impl = fn;
+	entry.wrapper = void 0;
+}
+function setReplacement(moduleId, name, fn) {
+	const entry = getOrCreateEntry(moduleId, name);
+	entry.replacement = fn;
+}
+function clearReplacement(moduleId, name) {
+	const entry = getEntry(moduleId, name);
+	if (entry) entry.replacement = null;
+}
+function addAdvice(moduleId, name, type, fn) {
+	const entry = getOrCreateEntry(moduleId, name);
+	const adviceEntry = {
+		type,
+		fn
+	};
+	entry.advice.push(adviceEntry);
+	return () => {
+		const idx = entry.advice.indexOf(adviceEntry);
+		if (idx >= 0) entry.advice.splice(idx, 1);
+	};
+}
+//#endregion
+//#region ../advice/src/runtime/chain.ts
+function applyAdviceChain(entry, args, thisArg) {
+	const befores = [];
+	const afters = [];
+	const arounds = [];
+	for (const a of entry.advice) switch (a.type) {
+		case "before":
+			befores.push(a);
+			break;
+		case "after":
+			afters.push(a);
+			break;
+		case "around":
+			arounds.push(a);
+			break;
+	}
+	const coreWithBeforesAfters = (...callArgs) => {
+		for (const b of befores) b.fn.apply(thisArg, callArgs);
+		let result = (entry.replacement ?? entry.impl).apply(thisArg, callArgs);
+		for (let i = afters.length - 1; i >= 0; i--) {
+			const afterResult = afters[i].fn.call(thisArg, result, ...callArgs);
+			if (afterResult !== void 0) result = afterResult;
+		}
+		return result;
+	};
+	let composed = coreWithBeforesAfters;
+	for (let i = arounds.length - 1; i >= 0; i--) {
+		const aroundFn = arounds[i].fn;
+		const next = composed;
+		composed = (...callArgs) => aroundFn.call(thisArg, next, ...callArgs);
+	}
+	return composed(...args);
+}
+//#endregion
+//#region ../advice/src/runtime/index.ts
+globalThis.__zenbu_advice_registry__ = registry;
+/**
+* Register a function implementation. Called by transformed code.
+* Sets entry.impl only -- does not touch entry.replacement, so plugin
+* overrides survive HMR re-evaluation of the original module.
+*/
+function __def(moduleId, name, fn) {
+	setImpl(moduleId, name, fn);
+}
+/**
+* Returns a stable wrapper function that dispatches through the advice chain.
+* Returns the same function reference for the same moduleId+name across calls,
+* which is critical for React Refresh component identity.
+*/
+function __ref(moduleId, name) {
+	const entry = getOrCreateEntry(moduleId, name);
+	if (!entry.wrapper) entry.wrapper = function wrapper(...args) {
+		return applyAdviceChain(entry, args, this);
+	};
+	return entry.wrapper;
+}
+/**
+* Override a function with a plugin-provided replacement.
+* Unlike __def(), this sets entry.replacement which takes precedence
+* over entry.impl and is NOT cleared by subsequent __def() calls.
+* This allows a prelude script to call replace() before modules load,
+* and have the replacement survive module evaluation.
+*/
+function replace(moduleId, name, newFn) {
+	setReplacement(moduleId, name, newFn);
+}
+/**
+* Remove a previously set replacement, restoring the original implementation.
+*/
+function unreplace(moduleId, name) {
+	clearReplacement(moduleId, name);
+}
+/**
+* Add before/after/around advice to a function.
+* Returns a removal function.
+*/
+function advise(moduleId, name, type, fn) {
+	return addAdvice(moduleId, name, type, fn);
+}
+//#endregion
+export { __def, __ref, advise, replace, unreplace };

package/dist/advice.d.mts

@@ -0,0 +1,36 @@
+//#region src/services/advice-config.d.ts
+interface ViewAdviceEntry {
+  moduleId: string;
+  name: string;
+  type: "replace" | "before" | "after" | "around";
+  modulePath: string;
+  exportName: string;
+}
+/**
+ * Public-facing advice spec. `modulePath` is normally a path relative to
+ * the plugin root (the folder containing `zenbu.plugin.json`); pass
+ * `import.meta` as the second argument so we can resolve it. Absolute
+ * paths are also accepted as an escape hatch.
+ */
+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[];
+/**
+ * Register a content script for the given scope. `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.
+ *
+ *   this.setup("inject", () =>
+ *     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 getAllContentScriptPaths(): string[];
+declare function getAllScopes(): string[];
+//#endregion
+export { type AdviceSpec, type ViewAdviceEntry, getAdvice, getAllAdviceScopes, getAllContentScriptPaths, getAllScopes, getContentScripts, registerAdvice, registerContentScript };

package/dist/advice.mjs

@@ -0,0 +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-CjgkEf2E.mjs";
+export { getAdvice, getAllAdviceScopes, getAllContentScriptPaths, getAllScopes, getContentScripts, registerAdvice, registerContentScript };

package/dist/base-window-BUt8pwbw.mjs

@@ -0,0 +1,94 @@
+import { i as runtime, t as Service } from "./runtime-DUFKDIe4.mjs";
+import { t as createLogger } from "./log-CyKv8hQg.mjs";
+import { r as DbService } from "./renderer-host-Bg8QdeeH.mjs";
+import { nanoid } from "nanoid";
+import { BaseWindow } from "electron";
+//#region src/services/base-window.ts
+const log = createLogger("base-window");
+const MAIN_WINDOW_ID = "main";
+var BaseWindowService = class extends Service {
+	static key = "base-window";
+	static 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: "#F4F4F4"
+		});
+		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 { MAIN_WINDOW_ID as n, BaseWindowService as t };

package/dist/base-window-DEIAk618.mjs

@@ -0,0 +1,2 @@
+import "./base-window-BUt8pwbw.mjs";
+export {};

package/dist/build-config-pbv0w4oN.mjs

@@ -0,0 +1,17 @@
+//#region src/cli/lib/build-config.ts
+function defineBuildConfig(config) {
+	return config;
+}
+function resolveBuildConfig(config) {
+	return {
+		source: config.source ?? ".",
+		out: config.out ?? ".zenbu/build/seed",
+		include: config.include,
+		ignore: config.ignore ?? [],
+		transforms: config.transforms ?? [],
+		mirror: config.mirror,
+		bundle: config.bundle
+	};
+}
+//#endregion
+export { resolveBuildConfig as n, defineBuildConfig as t };