@zenbujs/core 0.0.3 → 0.0.5

package/dist/setup-gate.mjs

@@ -1,2 +1,249 @@
-import { t as setupGate } from "./setup-gate-BcoqWu8S.mjs";
+import { bootstrapEnv } from "./env-bootstrap.mjs";
+import { createRequire, register } from "node:module";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { register as register$1 } from "tsx/esm/api";
+//#region src/setup-gate.ts
+function registerLoader(specifier, opts) {
+	return register(specifier, void 0, opts);
+}
+const verbose = process.env.ZENBU_VERBOSE === "1";
+function isPluginModule(value) {
+	return typeof value === "object" && value !== null && typeof value.default === "function";
+}
+function isPluginController(value) {
+	return typeof value === "object" && value !== null && typeof value.main === "function";
+}
+function envMs(name) {
+	const raw = process.env[name];
+	if (!raw) return null;
+	const value = Number(raw);
+	return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function projectArg() {
+	const arg = process.argv.find((item) => item.startsWith("--project="));
+	return arg ? path.resolve(arg.slice(10)) : null;
+}
+function appDirName(name) {
+	return name.replace(/^@/, "").replace(/[\\/]/g, "__");
+}
+function readPackageJson(packageDir) {
+	const pkgPath = path.join(packageDir, "package.json");
+	return JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+}
+function findProjectRoot(projectDir) {
+	let dir = path.resolve(projectDir);
+	while (dir !== path.dirname(dir)) {
+		if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+		dir = path.dirname(dir);
+	}
+	return path.resolve(projectDir);
+}
+function resolveConfigPath(projectRoot) {
+	const candidates = [
+		"zenbu.config.ts",
+		"zenbu.config.mts",
+		"zenbu.config.js",
+		"zenbu.config.mjs"
+	];
+	for (const name of candidates) {
+		const candidate = path.join(projectRoot, name);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	throw new Error(`No zenbu config found at ${projectRoot}. Expected one of: ${candidates.join(", ")}`);
+}
+function findTsconfig(projectRoot) {
+	const candidate = path.join(projectRoot, "tsconfig.json");
+	return fs.existsSync(candidate) ? candidate : false;
+}
+function loadElectronApp() {
+	const electron = createRequire(import.meta.url)("electron");
+	if (!electron.app) throw new Error("Electron app API is unavailable; setup-gate must run inside Electron");
+	return electron.app;
+}
+async function closeRegisteredWatchers() {
+	await (await import("@zenbujs/hmr/pause")).closeAllWatchers?.();
+}
+/**
+* Extract the splash's intended background color from a
+* `<meta name="zenbu-bg" content="#xxx">` tag. Used as the BaseWindow's
+* `backgroundColor` so the OS doesn't paint a single white frame before
+* the WebContentsView's pixels reach the screen. Convention only —
+* defaults to `#F4F4F4` when unset.
+*/
+function readSplashBgColor(splashPath) {
+	try {
+		const match = fs.readFileSync(splashPath, "utf8").match(/<meta\s+name=["']zenbu-bg["']\s+content=["']([^"']+)["']/i);
+		if (match?.[1]) return match[1];
+	} catch {}
+	return "#F4F4F4";
+}
+/**
+* Spawn the splash window before any plugin service evaluates. The window
+* is created HIDDEN, the splash HTML is loaded into a `WebContentsView`,
+* we wait for `loadFile` to resolve (= did-finish-load), then `win.show()`
+* — by the time the OS composites the window, the splash pixels are already
+* there. No white-frame flash.
+*
+* `BaseWindowService.evaluate()` adopts this window from
+* `globalThis.__zenbu_boot_windows__` instead of creating a new one, so
+* `WindowService.openView` can swap the splash content view for the
+* Vite-served renderer in-place when the renderer is ready.
+*/
+async function spawnSplashWindow() {
+	const slot = globalThis;
+	const splashPath = slot.__zenbu_main_resolved_config__?.payload?.splashPath;
+	if (!splashPath || !fs.existsSync(splashPath)) {
+		if (verbose) console.log("[setup-gate] no splash.html resolved; skipping splash window");
+		return;
+	}
+	const electron = await import("electron");
+	const backgroundColor = readSplashBgColor(splashPath);
+	const win = new electron.BaseWindow({
+		width: 1100,
+		height: 750,
+		show: false,
+		titleBarStyle: "hidden",
+		trafficLightPosition: {
+			x: 14,
+			y: 10
+		},
+		backgroundColor
+	});
+	const splashView = new electron.WebContentsView({ webPreferences: { paintWhenInitiallyHidden: true } });
+	win.contentView.addChildView(splashView);
+	const bounds = win.getContentBounds();
+	splashView.setBounds({
+		x: 0,
+		y: 0,
+		width: bounds.width,
+		height: bounds.height
+	});
+	await Promise.race([splashView.webContents.loadFile(splashPath).catch(() => {}), new Promise((resolve) => setTimeout(resolve, 1500))]);
+	win.show();
+	const boot = {
+		windowId: "main",
+		win
+	};
+	slot.__zenbu_boot_windows__ = [...slot.__zenbu_boot_windows__ ?? [], boot];
+	if (verbose) console.log("[setup-gate] splash window shown with", splashPath, "bg=", backgroundColor);
+}
+async function registerLoaders(tsconfig, projectRoot) {
+	register$1({ tsconfig });
+	const { loadConfig } = await import("./load-config-xMf2wxH8.mjs").then((n) => n.n);
+	const { resolved, pluginSourceFiles } = await loadConfig(projectRoot);
+	const loaderData = {
+		payload: {
+			plugins: resolved.plugins.map((p) => ({
+				name: p.name,
+				dir: p.dir,
+				services: p.services,
+				schemaPath: p.schemaPath,
+				migrationsPath: p.migrationsPath,
+				preloadPath: p.preloadPath,
+				eventsPath: p.eventsPath,
+				icons: p.icons
+			})),
+			appEntrypoint: resolved.uiEntrypointPath,
+			splashPath: resolved.splashPath
+		},
+		pluginSourceFiles
+	};
+	globalThis.__zenbu_main_resolved_config__ = loaderData;
+	registerLoader(import.meta.resolve("@zenbujs/core/loaders/zenbu"), { data: loaderData });
+	process.env.ZENBU_ADVICE_ROOT = projectRoot;
+	await import("./node-_8xShqxr.mjs");
+	const dynohot = await import(pathToFileURL(createRequire(import.meta.url).resolve("@zenbujs/hmr/register")).href);
+	if (typeof dynohot.register === "function") dynohot.register({ ignore: /[/\\](?:node_modules|dist)[/\\]/ });
+}
+async function setupGate() {
+	const app = loadElectronApp();
+	await app.whenReady();
+	bootstrapEnv();
+	let shuttingDown = false;
+	const shutdown = async (exitCode = 0) => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		try {
+			await globalThis.__zenbu_service_runtime__?.shutdown();
+		} catch (err) {
+			console.error("[setup-gate] shutdown failed:", err);
+		}
+		try {
+			await closeRegisteredWatchers();
+		} catch (err) {
+			console.error("[setup-gate] closeAllWatchers failed:", err);
+		}
+		process.exit(exitCode);
+	};
+	app.on("before-quit", (event) => {
+		event.preventDefault();
+		shutdown(0);
+	});
+	process.on("SIGINT", () => void shutdown(0));
+	process.on("SIGTERM", () => void shutdown(0));
+	const autoQuitReadyMs = envMs("ZENBU_AUTO_QUIT_AFTER_READY_MS");
+	if (autoQuitReadyMs != null) {
+		if (verbose) console.log("[setup-gate] auto-quit after ready scheduled:", autoQuitReadyMs);
+		setTimeout(() => app.quit(), autoQuitReadyMs).unref();
+	}
+	const bundledAppPath = app.getAppPath();
+	const appName = readPackageJson(bundledAppPath).name ?? path.basename(bundledAppPath);
+	const resolvedProjectDir = projectArg() ?? path.join(process.env.ZENBU_APPS_DIR ?? path.join(os.homedir(), ".zenbu", "apps"), appDirName(appName));
+	if (!fs.existsSync(resolvedProjectDir)) throw new Error(`setup-gate: project directory ${resolvedProjectDir} does not exist. In a shipped .app, the launcher provisions this dir before invoking setup-gate. In dev, point at an existing project with --project=.`);
+	const projectRoot = findProjectRoot(resolvedProjectDir);
+	const configPath = resolveConfigPath(projectRoot);
+	const tsconfig = findTsconfig(projectRoot);
+	process.chdir(projectRoot);
+	process.env.ZENBU_CONFIG_PATH = configPath;
+	if (!process.argv.some((arg) => arg.startsWith("--project="))) process.argv.push(`--project=${resolvedProjectDir}`);
+	if (verbose) {
+		console.log("[setup-gate] project:", resolvedProjectDir);
+		console.log("[setup-gate] config:", configPath);
+	}
+	await registerLoaders(tsconfig, projectRoot);
+	if (shuttingDown) return;
+	try {
+		await spawnSplashWindow();
+	} catch (err) {
+		if (shuttingDown) return;
+		throw err;
+	}
+	if (shuttingDown) return;
+	try {
+		const { defaultServices } = await import("./services/default.mjs");
+		await defaultServices();
+	} catch (err) {
+		if (shuttingDown) return;
+		throw err;
+	}
+	if (shuttingDown) return;
+	const url = `zenbu:plugins?config=${encodeURIComponent(configPath)}`;
+	let mod;
+	try {
+		mod = await import(url, { with: { hot: "import" } });
+	} catch (err) {
+		if (shuttingDown) return;
+		throw err;
+	}
+	if (shuttingDown) return;
+	if (isPluginModule(mod)) {
+		const controller = mod.default();
+		if (isPluginController(controller)) await controller.main();
+	}
+	if (shuttingDown) return;
+	await globalThis.__zenbu_service_runtime__?.whenIdle();
+	const autoQuitMs = envMs("ZENBU_AUTO_QUIT_AFTER_IDLE_MS");
+	if (autoQuitMs != null) {
+		if (verbose) console.log("[setup-gate] auto-quit scheduled:", autoQuitMs);
+		setTimeout(() => app.quit(), autoQuitMs).unref();
+	}
+}
+setupGate().catch((error) => {
+	console.error(error);
+	process.exit(1);
+});
+//#endregion
 export { setupGate };

package/dist/{transform-DJH3vN4b.mjs → transform-CmFYPmt8.mjs}

@@ -1,4 +1,4 @@
-import { n as __require, t as __commonJSMin } from "./chunk-Dm34NbLt.mjs";
+import { r as __require, t as __commonJSMin } from "./chunk-DsiFFCwN.mjs";
 //#region ../../node_modules/.pnpm/@babel+types@7.29.0/node_modules/@babel/types/lib/utils/shallowEqual.js
 var require_shallowEqual = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });

package/dist/transforms-CuTODvDx.d.mts

@@ -0,0 +1,145 @@
+//#region src/cli/lib/build-config.d.ts
+interface TransformInput {
+  path: string;
+  code: string;
+}
+interface TransformOutput {
+  code?: string;
+  drop?: boolean;
+}
+type Transform = (file: TransformInput) => TransformOutput | null | undefined | void;
+interface MirrorConfig {
+  target: string;
+  branch?: string;
+}
+interface BundleConfig {
+  extraResources?: string[];
+}
+interface BuildConfig {
+  source?: string;
+  out?: string;
+  include: string[];
+  ignore?: string[];
+  transforms?: Transform[];
+  mirror?: MirrorConfig;
+  bundle?: BundleConfig;
+}
+declare function defineBuildConfig(config: BuildConfig): BuildConfig;
+type ResolvedBuildConfig = Required<Omit<BuildConfig, "mirror" | "bundle">> & {
+  mirror?: MirrorConfig;
+  bundle?: BundleConfig;
+};
+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 scope. 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;
+  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 };

package/dist/transforms-htxfTwsY.mjs

@@ -0,0 +1,47 @@
+//#region src/cli/lib/transforms.ts
+const STRIP_START = /^\s*\/\/\s*@zenbu:strip-if\s+(!?)([A-Za-z_][A-Za-z0-9_]*)\s*$/;
+const STRIP_END = /^\s*\/\/\s*@zenbu:end\s*$/;
+/**
+* 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.
+*/
+function stripIfDisabled(flags) {
+	return (file) => {
+		const lines = file.code.split("\n");
+		const out = [];
+		let stripDepth = 0;
+		for (const line of lines) {
+			const startMatch = STRIP_START.exec(line);
+			if (startMatch) {
+				const negated = startMatch[1] === "!";
+				const flagValue = flags[startMatch[2]] ?? false;
+				if ((negated ? !flagValue : flagValue) || stripDepth > 0) stripDepth += 1;
+				continue;
+			}
+			if (STRIP_END.test(line)) {
+				if (stripDepth > 0) stripDepth -= 1;
+				continue;
+			}
+			if (stripDepth === 0) out.push(line);
+		}
+		return { code: out.join("\n") };
+	};
+}
+/**
+* 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.
+*/
+function dropFiles(pattern) {
+	const test = typeof pattern === "function" ? pattern : (p) => pattern.test(p);
+	return (file) => {
+		if (test(file.path)) return { drop: true };
+	};
+}
+//#endregion
+export { stripIfDisabled as n, dropFiles as t };

package/dist/{transport-BMSzG2-F.mjs → transport-F2hv_OEm.mjs}

@@ -1,4 +1,4 @@
-import { t as traceKyju } from "./trace-DCB7qFzT.mjs";
+import { t as traceKyju } from "./trace-BaVg0rnY.mjs";
 import * as Effect from "effect/Effect";
 import * as Ref from "effect/Ref";
 import * as Context from "effect/Context";

package/dist/{vite-plugins-Bh3SCOw-.mjs → vite-plugins-Do7liKi_.mjs}

@@ -1,8 +1,8 @@
-import { n as require_lib, t as zenbuAdviceTransform$1 } from "./transform-DJH3vN4b.mjs";
-import { a as getContentScripts, i as getAllScopes, r as getAllContentScriptPaths, t as getAdvice } from "./advice-config-CjgkEf2E.mjs";
+import { getPlugins } from "./runtime.mjs";
+import { n as require_lib, t as zenbuAdviceTransform$1 } from "./transform-CmFYPmt8.mjs";
+import { a as getAllScopes, i as getAllContentScriptPaths, n as getAdvice, o as getContentScripts } from "./advice-config-QYB2qEd_.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import fsp from "node:fs/promises";
 //#region ../advice/src/vite.ts
 var import_lib = require_lib();
 const defaultInclude = /\.[jt]sx?$/;
@@ -117,22 +117,8 @@ function zenbuFrameworkResolve() {
 		* proactively calls `server.restart()` on add/change/unlink of any
 		* `tsconfig.local.json`.
 		*/
-		async configureServer(server) {
-			const configPath = process.env.ZENBU_CONFIG_PATH;
-			if (!configPath) return;
-			const configDir = path.dirname(configPath);
-			let tsconfigPaths = [];
-			try {
-				const raw = await fsp.readFile(configPath, "utf8");
-				const config = JSON.parse(raw);
-				if (Array.isArray(config.plugins)) for (const entry of config.plugins) {
-					if (typeof entry !== "string") continue;
-					const manifestAbs = path.isAbsolute(entry) ? entry : path.resolve(configDir, entry);
-					tsconfigPaths.push(path.join(path.dirname(manifestAbs), "tsconfig.local.json"));
-				}
-			} catch {
-				return;
-			}
+		configureServer(server) {
+			const tsconfigPaths = getPlugins().map((p) => path.join(p.dir, "tsconfig.local.json"));
 			if (tsconfigPaths.length === 0) return;
 			server.watcher.add(tsconfigPaths);
 			let restarting = false;

package/dist/vite.mjs

@@ -1,2 +1,2 @@
-import { a as zenbuVitePlugins, i as zenbuFrameworkResolve, n as resolveAdviceRuntime, r as zenbuAdviceTransform, t as advicePreludePlugin } from "./vite-plugins-Bh3SCOw-.mjs";
+import { a as zenbuVitePlugins, i as zenbuFrameworkResolve, n as resolveAdviceRuntime, r as zenbuAdviceTransform, t as advicePreludePlugin } from "./vite-plugins-Do7liKi_.mjs";
 export { advicePreludePlugin, resolveAdviceRuntime, zenbuAdviceTransform, zenbuFrameworkResolve, zenbuVitePlugins };

package/dist/{window-CmmpCVX6.mjs → window-o2NGUsIb.mjs}

@@ -1,11 +1,13 @@
-import { a as serviceWithDeps, i as runtime } from "./runtime-DUFKDIe4.mjs";
-import { t as createLogger } from "./log-CyKv8hQg.mjs";
-import { n as ViewRegistryService, o as HttpService, t as RendererHostService } from "./renderer-host-Bg8QdeeH.mjs";
-import { t as BaseWindowService } from "./base-window-BUt8pwbw.mjs";
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { runtime, serviceWithDeps } from "./runtime.mjs";
+import { t as createLogger } from "./log-6rzaCV0I.mjs";
+import { r as ViewRegistryService, s as HttpService, t as RendererHostService } from "./renderer-host-Cau9JK0v.mjs";
+import { t as BaseWindowService } from "./base-window-BbFRRhKP.mjs";
 import { URLSearchParams } from "node:url";
 import { WebContentsView, clipboard, dialog, shell } from "electron";
 import electronContextMenu from "electron-context-menu";
 //#region src/services/window.ts
+var window_exports = /* @__PURE__ */ __exportAll({ WindowService: () => WindowService });
 const log = createLogger("window");
 function queryString(query) {
 	if (!query) return "";
@@ -62,9 +64,10 @@ var WindowService = class extends serviceWithDeps({
 		const view = new WebContentsView({ webPreferences: {
 			nodeIntegration: false,
 			contextIsolation: true,
-			sandbox: true
+			sandbox: true,
+			...args.view?.webPreferences
 		} });
-		view.setBackgroundColor("#F4F4F4");
+		view.setBackgroundColor(args.view?.backgroundColor ?? "#F4F4F4");
 		win.contentView.addChildView(view);
 		const disposeContextMenu = electronContextMenu({
 			window: view,
@@ -153,4 +156,4 @@ var WindowService = class extends serviceWithDeps({
 };
 runtime.register(WindowService, import.meta);
 //#endregion
-export { WindowService as t };
+export { window_exports as n, WindowService as t };

package/dist/{write-9dRFczGJ.mjs → write-DgIRjo23.mjs}

@@ -1,4 +1,4 @@
-import { n as traceKyjuSync, t as traceKyju } from "./trace-DCB7qFzT.mjs";
+import { n as traceKyjuSync, t as traceKyju } from "./trace-BaVg0rnY.mjs";
 import * as NFS from "node:fs";
 import * as OS from "node:os";
 import * as Path from "node:path";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenbujs/core",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,6 +22,10 @@
       "types": "./dist/cli/build.d.mts",
       "import": "./dist/cli/build.mjs"
     },
+    "./config": {
+      "types": "./dist/config.d.mts",
+      "import": "./dist/config.mjs"
+    },
     "./loaders/zenbu": {
       "types": "./dist/loaders/zenbu.d.mts",
       "import": "./dist/loaders/zenbu.mjs"
@@ -98,27 +102,24 @@
     "vite": "^6.0.0",
     "ws": "^8.18.0",
     "zod": "^4.3.6",
-    "@zenbujs/hmr": "0.0.1"
+    "@zenbujs/hmr": "0.0.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
     "@types/ws": "^8.18.0",
     "electron": "^42.0.0",
-    "eslint": "^9.0.0",
     "tsdown": "^0.21.10",
     "typescript": "^5.4.5",
+    "@zenbu/zenrpc": "0.0.0",
     "@zenbu/kyju": "0.0.0",
-    "@zenbu/lint": "0.0.0",
-    "@zenbu/advice": "0.0.0",
-    "@zenbu/zenrpc": "0.0.0"
+    "@zenbu/advice": "0.0.0"
   },
   "scripts": {
     "build": "node --max-old-space-size=8192 ./node_modules/tsdown/dist/run.mjs",
     "dev": "tsdown --watch",
-    "link:types": "node ../zen/dist/bin.mjs link --types-config ./zenbu-types.config.json --registry ./types",
-    "db:generate": "node ../zen/dist/bin.mjs db generate --schema src/schema.ts --migrations ./migrations",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
-    "lint": "eslint . --max-warnings=0"
+    "link:types": "node ./dist/cli/bin.mjs link --types-config ./zenbu-types.config.json --registry ./types",
+    "db:generate": "node ./dist/cli/bin.mjs db generate --schema src/schema.ts --migrations ./migrations",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
   }
 }

package/dist/advice-config-Cy133IQP.mjs

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

package/dist/base-window-DEIAk618.mjs

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

package/dist/chunk-Dm34NbLt.mjs

@@ -1,6 +0,0 @@
-import { createRequire } from "node:module";
-//#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-//#endregion
-export { __require as n, __commonJSMin as t };

package/dist/config-LK73dJmO.mjs

@@ -1,2 +0,0 @@
-import { n as loadConfig, t as findConfigFile } from "./config-CdVrW85P.mjs";
-export { findConfigFile, loadConfig };

package/dist/db-ByKPbnP6.mjs

@@ -1,2 +0,0 @@
-import "./renderer-host-Bg8QdeeH.mjs";
-export {};

package/dist/env-bootstrap-rj7I-59x.mjs

@@ -1,53 +0,0 @@
-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 as t };