@zenbujs/core 0.0.4 → 0.0.8

package/dist/services/default.mjs

@@ -2,21 +2,22 @@
 /**
 * Loads and registers all built-in services. Kept separate from
 * `./index.ts` (which statically re-exports the service classes for
-* `serviceWithDeps(...)` consumers) so that `setup-gate` can import it without
-* eagerly loading every service module before `setupGate()` has had a
-* chance to bootstrap env vars and `process.chdir(projectRoot)`.
+* `Service.withDeps(...)` consumers) so that `setup-gate` can import it
+* without eagerly loading every service module before `setupGate()` has
+* had a chance to bootstrap env vars and `process.chdir(projectRoot)`.
 */
 async function defaultServices() {
-	await import("../server-CgzQOPSW.mjs");
-	await import("../reloader-FeHKV2jd.mjs");
-	await import("../renderer-host-BQpS0ZM2.mjs");
-	await import("../http-B36qtsm0.mjs");
-	await import("../db-Bz_CDIWg.mjs");
-	await import("../base-window-OXg2KSyP.mjs");
-	await import("../rpc-D_s7-WZe.mjs");
-	await import("../view-registry-2zePxTEg.mjs");
-	await import("../window-S3TlTXlK.mjs");
-	await import("../advice-config-D6K_a7e9.mjs");
+	await import("../server-CZLMF8Dj.mjs").then((n) => n.n);
+	await import("../reloader-B22UiNA2.mjs").then((n) => n.n);
+	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.n);
+	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.c);
+	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.o);
+	await import("../base-window-BxBZ2md_.mjs").then((n) => n.r);
+	await import("../rpc-C4_NQmpT.mjs").then((n) => n.n);
+	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.i);
+	await import("../window-YFKvAM0l.mjs").then((n) => n.n);
+	await import("../advice-config-DXSIo0sg.mjs").then((n) => n.t);
+	await import("../updater-DCkz9M1c.mjs").then((n) => n.n);
 }
 //#endregion
 export { defaultServices };

package/dist/services/index.d.mts

@@ -1,276 +1,2 @@
-import { c as EffectFieldNode, d as KyjuError, l as FieldNode, r as createRouter, t as Db } from "../index-UK58xuoR.mjs";
-import { r as Service, t as CleanupReason } from "../runtime-CsiDppGF.mjs";
-import { o as ResolvedDbRoot, s as ResolvedEvents } from "../registry-CioEYLI5.mjs";
-import http from "node:http";
-import { WebSocket, WebSocketServer } from "ws";
-import { ViteDevServer } from "vite";
-import * as Effect from "effect/Effect";
-import { BaseWindow } 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>;
-  }): 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-DB3Eki_G.mjs";
-import { t as ReloaderService } from "../reloader-DJoCB0bC.mjs";
-import { n as ViewRegistryService, o as HttpService, r as DbService, t as RendererHostService } from "../renderer-host-ztaSIOGx.mjs";
-import { n as MAIN_WINDOW_ID, t as BaseWindowService } from "../base-window-D8CpxMU3.mjs";
-import { t as RpcService } from "../rpc-CsgWnlZx.mjs";
-import { t as WindowService } from "../window-DUvMTons.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-D62nX5lk.mjs";
+import { t as setupGate } from "./setup-gate-BQq0QgZH.mjs";
 export { setupGate };

package/dist/setup-gate.mjs

@@ -1,2 +1,342 @@
-import { t as setupGate } from "./setup-gate-D8XfYY52.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
+/**
+* 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";
+}
+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 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 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(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 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,
+		titleBarStyle: "hidden",
+		trafficLightPosition: {
+			x: 14,
+			y: 10
+		},
+		backgroundColor
+	});
+	const splashView = new electron.WebContentsView();
+	win.contentView.addChildView(splashView);
+	const bounds = win.getContentBounds();
+	splashView.setBounds({
+		x: 0,
+		y: 0,
+		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))]);
+	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);
+}
+/**
+* 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-C4Oe2qZO.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,
+			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-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) => {
+		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);
+	});
+	/**
+	* 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");
+	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);
+	}
+	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 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();
+	} 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;
+	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);
+		setTimeout(() => app.quit(), autoQuitMs).unref();
+	}
+}
+setupGate().catch((error) => {
+	console.error(error);
+	process.exit(1);
+});
+//#endregion
 export { setupGate };