@zenbujs/core 0.0.5 → 0.0.8

package/dist/services/index.d.mts

@@ -1,280 +1,2 @@
-import { i as Service, t as CleanupReason } from "../runtime-pCeVzj--.mjs";
-import { c as EffectFieldNode, d as KyjuError, l as FieldNode, r as createRouter, t as Db } from "../index-M_lSNBrq.mjs";
-import { o as ResolvedDbRoot, s as ResolvedEvents } from "../registry-eX6e2oql.mjs";
-import http from "node:http";
-import { WebSocket, WebSocketServer } from "ws";
-import { ViteDevServer } from "vite";
-import * as Effect from "effect/Effect";
-import { BaseWindow, WebPreferences } from "electron";
-import * as _$stream from "stream";
-
-//#region src/services/server.d.ts
-type UpgradeHandler = (req: http.IncomingMessage, socket: _$stream.Duplex, head: Buffer) => boolean;
-declare class ServerService extends Service {
-  static key: string;
-  static deps: {};
-  server: http.Server | null;
-  wss: WebSocketServer | null;
-  port: number;
-  authToken: string;
-  private upgradeHandlers;
-  addUpgradeHandler(handler: UpgradeHandler): () => void;
-  evaluate(): Promise<void>;
-  private isAuthorizedUpgrade;
-}
-//#endregion
-//#region src/services/reloader.d.ts
-interface ReloaderEntry {
-  id: string;
-  root: string;
-  url: string;
-  port: number;
-  viteServer: ViteDevServer;
-}
-declare class ReloaderService extends Service {
-  static key: string;
-  static deps: {};
-  private servers;
-  create(id: string, root: string, configFile?: string | false): Promise<ReloaderEntry>;
-  get(id: string): ReloaderEntry | undefined;
-  remove(id: string): Promise<void>;
-  evaluate(): void;
-}
-//#endregion
-//#region src/services/http.d.ts
-type ConnectedCallback = (id: string, ws: WebSocket) => void;
-type DisconnectedCallback = (id: string) => void;
-type RequestHandler = (req: http.IncomingMessage, res: http.ServerResponse) => void;
-declare class HttpService extends Service {
-  static key: string;
-  static deps: {
-    server: typeof ServerService;
-    reloader: typeof ReloaderService;
-  };
-  ctx: {
-    server: ServerService;
-    reloader: ReloaderService;
-  };
-  connectedCallbacks: ConnectedCallback[];
-  disconnectedCallbacks: DisconnectedCallback[];
-  activeConnections: Map<string, WebSocket>;
-  private requestHandlers;
-  get port(): number;
-  get authToken(): string;
-  addRequestHandler(prefix: string, handler: RequestHandler): () => void;
-  onConnected(cb: ConnectedCallback): () => void;
-  onDisconnected(cb: DisconnectedCallback): () => void;
-  evaluate(): void;
-}
-//#endregion
-//#region src/services/db.d.ts
-type EffectSectionProxy<S> = { [K in keyof S]: EffectFieldNode<S[K]> };
-type SectionProxy<S> = { [K in keyof S]: FieldNode<S[K]> };
-type Root = ResolvedDbRoot;
-type Plugin$1 = Root extends {
-  plugin: infer P;
-} ? P : never;
-type SectionedEffectClient = {
-  readRoot(): Root;
-  update(fn: (root: Root) => void | Root): Effect.Effect<void, KyjuError>;
-  createBlob(data: Uint8Array, hot?: boolean): Effect.Effect<string, KyjuError>;
-  deleteBlob(blobId: string): Effect.Effect<void, KyjuError>;
-  getBlobData(blobId: string): Effect.Effect<Uint8Array | null, KyjuError>;
-  plugin: { [K in keyof Plugin$1]: EffectSectionProxy<Plugin$1[K]> };
-};
-type SectionedClient = {
-  readRoot(): Root;
-  update(fn: (root: Root) => void | Root): Promise<void>;
-  createBlob(data: Uint8Array, hot?: boolean): Promise<string>;
-  deleteBlob(blobId: string): Promise<void>;
-  getBlobData(blobId: string): Promise<Uint8Array | null>;
-  plugin: { [K in keyof Plugin$1]: SectionProxy<Plugin$1[K]> };
-};
-declare class DbService extends Service {
-  static key: string;
-  static deps: {
-    http: typeof HttpService;
-  };
-  ctx: {
-    http: HttpService;
-  };
-  db: Db | null;
-  dbRouter: ReturnType<typeof createRouter> | null;
-  private sectionsHash;
-  private _dbPath;
-  /**
-   * Resolved DB path. Throws if accessed before `evaluate()` has run — the
-   * service contract guarantees deps are evaluated before dependents, so any
-   * access from a dependent service or RPC handler is safe.
-   */
-  get dbPath(): string;
-  get client(): SectionedClient;
-  get effectClient(): SectionedEffectClient;
-  /**
-   * Drain kyju's lagged-persistence queue. Safe to call anytime; idempotent
-   * when nothing is pending. Used by service teardown (effect cleanup) so
-   * shutdown / hot-reload don't lose in-memory writes.
-   */
-  flush(): Promise<void>;
-  /**
-   * Flush + release the kyju cross-process lock at `<dbPath>/.lock`.
-   * Called on service teardown so a subsequent process can open the DB
-   * without seeing a stale lock. Idempotent.
-   */
-  close(): Promise<void>;
-  evaluate(): Promise<void>;
-}
-//#endregion
-//#region src/services/view-registry.d.ts
-interface ViewEntry {
-  scope: string;
-  url: string;
-  port: number;
-  ownsServer: boolean;
-  meta?: {
-    kind?: string;
-    sidebar?: boolean;
-    bottomPanel?: boolean;
-    label?: string;
-  };
-}
-declare class ViewRegistryService extends Service {
-  static key: string;
-  static deps: {
-    reloader: typeof ReloaderService;
-    db: typeof DbService;
-  };
-  ctx: {
-    reloader: ReloaderService;
-    db: DbService;
-  };
-  private views;
-  private manifestIcons;
-  register(scope: string, root: string, configFile?: string | false, meta?: {
-    kind?: string;
-    sidebar?: boolean;
-    bottomPanel?: boolean;
-    label?: string;
-  }): Promise<ViewEntry>;
-  registerAlias(scope: string, reloaderId: string, pathPrefix: string, meta?: {
-    kind?: string;
-    sidebar?: boolean;
-    bottomPanel?: boolean;
-    label?: string;
-  }): ViewEntry;
-  unregister(scope: string): Promise<void>;
-  get(scope: string): ViewEntry | undefined;
-  evaluate(): void;
-  private loadManifestIcons;
-  private syncToDb;
-}
-//#endregion
-//#region src/services/renderer-host.d.ts
-declare class RendererHostService extends Service {
-  static key: string;
-  static deps: {
-    reloader: typeof ReloaderService;
-    viewRegistry: typeof ViewRegistryService;
-  };
-  ctx: {
-    reloader: ReloaderService;
-    viewRegistry: ViewRegistryService;
-  };
-  url: string;
-  port: number;
-  evaluate(): Promise<void>;
-}
-//#endregion
-//#region src/services/base-window.d.ts
-declare const MAIN_WINDOW_ID = "main";
-type WindowBounds = {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-};
-declare class BaseWindowService extends Service {
-  static key: string;
-  static deps: {
-    db: typeof DbService;
-  };
-  ctx: {
-    db: DbService;
-  };
-  windows: Map<string, BaseWindow>;
-  private get bootWindows();
-  private set bootWindows(value);
-  private getZenWidth;
-  getWindowId(win: BaseWindow): string | undefined;
-  createWindow(opts?: Partial<WindowBounds> & {
-    windowId?: string;
-    show?: boolean;
-  }): {
-    win: BaseWindow;
-    windowId: string;
-  };
-  evaluate(): void;
-}
-//#endregion
-//#region src/services/rpc.d.ts
-type EmitProxy<T> = { [K in keyof T]: T[K] extends Record<string, any> ? EmitProxy<T[K]> & ((data: T[K]) => void) : (data: T[K]) => void };
-declare class RpcService extends Service {
-  static key: string;
-  static deps: {
-    http: typeof HttpService;
-  };
-  ctx: {
-    http: HttpService;
-  };
-  private _emit;
-  get emit(): EmitProxy<ResolvedEvents>;
-  evaluate(): void;
-}
-//#endregion
-//#region src/services/window.d.ts
-declare const WindowService_base: (abstract new () => {
-  ctx: {
-    baseWindow: BaseWindowService;
-    viewRegistry: ViewRegistryService;
-    http: HttpService;
-    rendererHost: RendererHostService;
-  };
-  __setupCleanups: Map<string, (reason: CleanupReason) => void | Promise<void>>;
-  evaluate(): void | Promise<void>;
-  setup(key: string, fn: () => void | ((reason: CleanupReason) => void | Promise<void>)): void;
-  trace<T>(_name: string, fn: () => T | Promise<T>, _meta?: Record<string, unknown>): Promise<T>;
-  traceSync<T>(_name: string, fn: () => T, _meta?: Record<string, unknown>): T;
-  __cleanupAllSetups(reason?: CleanupReason): Promise<void>;
-}) & {
-  deps: Record<string, (string | (abstract new (...args: any[]) => Service)) | {
-    __optional: true;
-    ref: string | (abstract new (...args: any[]) => Service);
-  }>;
-  key: string;
-};
-declare class WindowService extends WindowService_base {
-  static key: string;
-  private mounted;
-  evaluate(): void;
-  openView(args: {
-    scope: string;
-    windowId?: string;
-    query?: Record<string, string | number | boolean | null | undefined>;
-    view?: {
-      backgroundColor?: string;
-      webPreferences?: WebPreferences;
-    };
-  }): Promise<{
-    windowId: string;
-  }>;
-  focusWindow(windowId: string): Promise<{
-    ok: true;
-  }>;
-  pickFiles(): Promise<string[] | null>;
-  pickDirectory(): Promise<string | null>;
-  openExternal(url: string): Promise<void>;
-  openPath(filePath: string): Promise<void>;
-  copyToClipboard(text: string): void;
-}
-//#endregion
-export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, ViewRegistryService, WindowService };
+import { a as MAIN_WINDOW_ID, c as DbService, d as ServerService, i as BaseWindowService, l as HttpService, n as WindowService, o as RendererHostService, r as RpcService, s as ViewRegistryService, t as UpdaterService, u as ReloaderService } from "../index-w5QyDjuf.mjs";
+export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, UpdaterService, ViewRegistryService, WindowService };

package/dist/services/index.mjs

@@ -1,7 +1,8 @@
-import { t as ServerService } from "../server-y3PPbh3l.mjs";
-import { t as ReloaderService } from "../reloader-DzEO8kJr.mjs";
-import { a as DbService, r as ViewRegistryService, s as HttpService, t as RendererHostService } from "../renderer-host-Cau9JK0v.mjs";
-import { n as MAIN_WINDOW_ID, t as BaseWindowService } from "../base-window-BbFRRhKP.mjs";
-import { t as RpcService } from "../rpc-JfGv-Wuw.mjs";
-import { t as WindowService } from "../window-o2NGUsIb.mjs";
-export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, ViewRegistryService, WindowService };
+import { t as ServerService } from "../server-CZLMF8Dj.mjs";
+import { t as ReloaderService } from "../reloader-B22UiNA2.mjs";
+import { a as DbService, r as ViewRegistryService, s as HttpService, t as RendererHostService } from "../renderer-host-DD16MXhI.mjs";
+import { n as MAIN_WINDOW_ID, t as BaseWindowService } from "../base-window-BxBZ2md_.mjs";
+import { t as RpcService } from "../rpc-C4_NQmpT.mjs";
+import { t as WindowService } from "../window-YFKvAM0l.mjs";
+import { t as UpdaterService } from "../updater-DCkz9M1c.mjs";
+export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, UpdaterService, ViewRegistryService, WindowService };

package/dist/setup-gate.d.mts

@@ -1,2 +1,2 @@
-import { t as setupGate } from "./setup-gate-Dcy8gGPJ.mjs";
+import { t as setupGate } from "./setup-gate-BQq0QgZH.mjs";
 export { setupGate };

package/dist/setup-gate.mjs

@@ -6,10 +6,30 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { register as register$1 } from "tsx/esm/api";
 //#region src/setup-gate.ts
+/**
+* this file is in a really hacky state needs to be fixed
+*/
 function registerLoader(specifier, opts) {
 	return register(specifier, void 0, opts);
 }
 const verbose = process.env.ZENBU_VERBOSE === "1";
+/**
+* Suppress `@babel/generator`'s "[BABEL] Note: The code generator has
+* deoptimised the styling of <file> as it exceeds the max of 500KB" notice.
+* It's hardcoded as `console.error` in @babel/generator's printer with no
+* opt-out (https://github.com/babel/babel/issues/7569). Vite's
+* `@vitejs/plugin-react` runs Babel for fast-refresh on prebundled deps
+* caches, hitting this for `react-dom_client.js` and similar large chunks
+* on every dev boot. We filter the one specific message at the
+* `console.error` boundary so the rest of console.error stays useful.
+*
+* Patched once at module init, before any Vite dev server has started.
+*/
+const _origConsoleError = console.error.bind(console);
+console.error = (...args) => {
+	if (args.length > 0 && typeof args[0] === "string" && args[0].startsWith("[BABEL] Note: The code generator has deoptimised")) return;
+	_origConsoleError(...args);
+};
 function isPluginModule(value) {
 	return typeof value === "object" && value !== null && typeof value.default === "function";
 }
@@ -81,30 +101,51 @@ function readSplashBgColor(splashPath) {
 	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.
+* Spawn the splash window as early as possible OR adopt the launcher's
+* pre-existing installing window. The window is created with `show: true`
+* and its `backgroundColor` set up front so the OS composites a colored
+* frame on the next vsync — no waiting for `did-finish-load` before any
+* pixels reach the screen. Splash content paints into the WebContentsView
+* a frame or two later, replacing the flat color.
+*
+* If the launcher already opened an installing window
+* (`globalThis.__zenbu_boot_windows__` is non-empty), we reuse that
+* BaseWindow and just swap its child WebContentsView from installing.html
+* to splash.html. The titlebar / window chrome stays continuous.
 *
-* `BaseWindowService.evaluate()` adopts this window from
+* `BaseWindowService.evaluate()` adopts the resulting 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;
+async function spawnSplashWindow(splashPath) {
 	if (!splashPath || !fs.existsSync(splashPath)) {
 		if (verbose) console.log("[setup-gate] no splash.html resolved; skipping splash window");
 		return;
 	}
+	const slot = globalThis;
 	const electron = await import("electron");
 	const backgroundColor = readSplashBgColor(splashPath);
-	const win = new electron.BaseWindow({
+	const existing = slot.__zenbu_boot_windows__?.find((b) => b.windowId === "main");
+	let win;
+	if (existing) {
+		win = existing.win;
+		try {
+			win.setBackgroundColor(backgroundColor);
+		} catch {}
+		for (const child of [...win.contentView.children]) {
+			try {
+				win.contentView.removeChildView(child);
+			} catch {}
+			const wc = child.webContents;
+			try {
+				wc?.close();
+			} catch {}
+		}
+		if (verbose) console.log("[setup-gate] adopting existing installing window for splash");
+	} else win = new electron.BaseWindow({
 		width: 1100,
 		height: 750,
-		show: false,
 		titleBarStyle: "hidden",
 		trafficLightPosition: {
 			x: 14,
@@ -112,7 +153,7 @@ async function spawnSplashWindow() {
 		},
 		backgroundColor
 	});
-	const splashView = new electron.WebContentsView({ webPreferences: { paintWhenInitiallyHidden: true } });
+	const splashView = new electron.WebContentsView();
 	win.contentView.addChildView(splashView);
 	const bounds = win.getContentBounds();
 	splashView.setBounds({
@@ -121,18 +162,31 @@ async function spawnSplashWindow() {
 		width: bounds.width,
 		height: bounds.height
 	});
+	/**
+	* human note: this is a bad solution we should have an invariant verifying program state
+	* but its fine for now
+	*/
 	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 (!existing) {
+		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) {
+/**
+* Phase 1 of loader setup: register tsx + read the user's `zenbu.config.ts`.
+* This is split out from the rest of the loader registration so the splash
+* window can be spawned the moment `splashPath` is known, instead of
+* waiting for advice + dynohot to register too. tsx must run with the
+* project's tsconfig because user code (config + plugins) may rely on
+* non-default TS settings (paths, jsx, etc.).
+*/
+async function loadConfigPhase(tsconfig, projectRoot) {
 	register$1({ tsconfig });
-	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, pluginSourceFiles } = await loadConfig(projectRoot);
 	const loaderData = {
 		payload: {
@@ -147,20 +201,37 @@ async function registerLoaders(tsconfig, projectRoot) {
 				icons: p.icons
 			})),
 			appEntrypoint: resolved.uiEntrypointPath,
-			splashPath: resolved.splashPath
+			splashPath: resolved.splashPath,
+			installingPath: resolved.installingPath
 		},
 		pluginSourceFiles
 	};
 	globalThis.__zenbu_main_resolved_config__ = loaderData;
+	return loaderData;
+}
+/**
+* Phase 2 of loader setup: register the zenbu loader, advice, and dynohot.
+* Runs AFTER the splash window is on screen so the user sees pixels while
+* advice patches install and dynohot's worker spawns. Node 22+ runs loader
+* hooks in a worker thread; the resolved config crosses the boundary via
+* `register()`'s `data` argument.
+*/
+async function registerLoadersPhase(projectRoot, loaderData) {
 	registerLoader(import.meta.resolve("@zenbujs/core/loaders/zenbu"), { data: loaderData });
 	process.env.ZENBU_ADVICE_ROOT = projectRoot;
-	await import("./node-_8xShqxr.mjs");
+	await import("./node-BhfLKYCi.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 t0 = Date.now();
+	const ms = () => `+${Date.now() - t0}ms`;
+	const step = (label) => {
+		console.log(`[zenbu] ${label} (${ms()})`);
+	};
 	const app = loadElectronApp();
 	await app.whenReady();
+	step("electron ready");
 	bootstrapEnv();
 	let shuttingDown = false;
 	const shutdown = async (exitCode = 0) => {
@@ -182,6 +253,10 @@ async function setupGate() {
 		event.preventDefault();
 		shutdown(0);
 	});
+	/**
+	* i think we probably want to expose this in an editable form to the user
+	*/
+	app.on("window-all-closed", () => {});
 	process.on("SIGINT", () => void shutdown(0));
 	process.on("SIGTERM", () => void shutdown(0));
 	const autoQuitReadyMs = envMs("ZENBU_AUTO_QUIT_AFTER_READY_MS");
@@ -203,15 +278,31 @@ async function setupGate() {
 		console.log("[setup-gate] project:", resolvedProjectDir);
 		console.log("[setup-gate] config:", configPath);
 	}
-	await registerLoaders(tsconfig, projectRoot);
+	let loaderData;
+	try {
+		loaderData = await loadConfigPhase(tsconfig, projectRoot);
+	} catch (err) {
+		if (shuttingDown) return;
+		throw err;
+	}
+	if (shuttingDown) return;
+	step(`config loaded (${loaderData.payload.plugins.length} plugins)`);
+	try {
+		await spawnSplashWindow(loaderData.payload.splashPath);
+	} catch (err) {
+		if (shuttingDown) return;
+		throw err;
+	}
 	if (shuttingDown) return;
+	step("splash shown");
 	try {
-		await spawnSplashWindow();
+		await registerLoadersPhase(projectRoot, loaderData);
 	} catch (err) {
 		if (shuttingDown) return;
 		throw err;
 	}
 	if (shuttingDown) return;
+	step("loaders registered");
 	try {
 		const { defaultServices } = await import("./services/default.mjs");
 		await defaultServices();
@@ -234,7 +325,9 @@ async function setupGate() {
 		if (isPluginController(controller)) await controller.main();
 	}
 	if (shuttingDown) return;
+	step("plugins evaluated");
 	await globalThis.__zenbu_service_runtime__?.whenIdle();
+	step("ready");
 	const autoQuitMs = envMs("ZENBU_AUTO_QUIT_AFTER_IDLE_MS");
 	if (autoQuitMs != null) {
 		if (verbose) console.log("[setup-gate] auto-quit scheduled:", autoQuitMs);