@zenbujs/core 0.0.4 → 0.0.8

package/dist/{renderer-host-ztaSIOGx.mjs → renderer-host-DD16MXhI.mjs}

@@ -1,12 +1,13 @@
-import { a as getPlugins, r as getAppEntrypoint, t as Service, u as runtime } from "./runtime-C95iyVn6.mjs";
-import { o as getZodDefault } from "./schema-CIg4GzHQ.mjs";
-import { t as schema } from "./schema-dGK6qkfR.mjs";
-import { t as createLogger } from "./log-CyKv8hQg.mjs";
-import { t as ServerService } from "./server-DB3Eki_G.mjs";
-import { n as DB_CONFIG_JSON, r as INTERNAL_DIR, t as ReloaderService } from "./reloader-DJoCB0bC.mjs";
-import { a as createBlob, c as makeErrorAck, g as layer$1, h as writeJsonFile, i as cleanupStaleTmpFiles, l as paths, m as validateSession, n as makeRootCache, o as createCollection, p as sendAck, r as broadcastDbUpdate, s as makeAck, t as handleWrite, u as readCollectionItemRange, v as FileSystem } from "./write-9dRFczGJ.mjs";
-import { t as traceKyju } from "./trace-DCB7qFzT.mjs";
-import { a as createClient, i as dbStringify, n as createRouter, o as createEffectClient, r as dbParse, s as createReplica } from "./transport-BMSzG2-F.mjs";
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { Service, getAppEntrypoint, getPlugins, runtime, subscribeConfig } from "./runtime.mjs";
+import { o as getZodDefault } from "./schema-Ca7SxXgS.mjs";
+import { schema } from "./schema.mjs";
+import { t as createLogger } from "./log-6rzaCV0I.mjs";
+import { t as ServerService } from "./server-CZLMF8Dj.mjs";
+import { i as INTERNAL_DIR, r as DB_CONFIG_JSON, t as ReloaderService } from "./reloader-B22UiNA2.mjs";
+import { a as createBlob, c as makeErrorAck, g as layer$1, h as writeJsonFile, i as cleanupStaleTmpFiles, l as paths, m as validateSession, n as makeRootCache, o as createCollection, p as sendAck, r as broadcastDbUpdate, s as makeAck, t as handleWrite, u as readCollectionItemRange, v as FileSystem } from "./write-DgIRjo23.mjs";
+import { t as traceKyju } from "./trace-BaVg0rnY.mjs";
+import { a as createClient, i as dbStringify, n as createRouter, o as createEffectClient, r as dbParse, s as createReplica } from "./transport-F2hv_OEm.mjs";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -14,6 +15,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import http from "node:http";
 import fsp from "node:fs/promises";
 import * as Effect from "effect/Effect";
+import { subscribe } from "@parcel/watcher";
 import * as Ref from "effect/Ref";
 import { nanoid } from "nanoid";
 //#region ../../node_modules/.pnpm/@effect+platform-node@0.104.1_@effect+cluster@0.56.4_@effect+platform@0.94.5_effect@3.2_4dd4c94e7ca0ae112861b6965a5da5f4/node_modules/@effect/platform-node/dist/esm/NodeFileSystem.js
@@ -798,13 +800,15 @@ async function resolveDbPath(argv, app) {
 }
 //#endregion
 //#region src/services/http.ts
+var http_exports = /* @__PURE__ */ __exportAll({ HttpService: () => HttpService });
 const log$3 = createLogger("http");
-var HttpService = class extends Service {
-	static key = "http";
-	static deps = {
+var HttpService = class extends Service.create({
+	key: "http",
+	deps: {
 		server: ServerService,
 		reloader: ReloaderService
-	};
+	}
+}) {
 	connectedCallbacks = [];
 	disconnectedCallbacks = [];
 	activeConnections = /* @__PURE__ */ new Map();
@@ -932,6 +936,11 @@ var HttpService = class extends Service {
 runtime.register(HttpService, import.meta);
 //#endregion
 //#region src/services/db.ts
+var db_exports = /* @__PURE__ */ __exportAll({
+	DbService: () => DbService,
+	discoverSections: () => discoverSections,
+	resolveManifestModulePath: () => resolveManifestModulePath
+});
 const log$2 = createLogger("db");
 /**
 * Walk up from this file's location until we hit the @zenbujs/core
@@ -1007,7 +1016,7 @@ function resolveConfigPath() {
 * loader-emitted barrel before any service evaluates.
 */
 async function loadAppDbField(configPath) {
-	const { loadConfig } = await import("./load-config-CQG4297M.mjs");
+	const { loadConfig } = await import("./load-config-C4Oe2qZO.mjs").then((n) => n.n);
 	const { resolved } = await loadConfig(path.dirname(configPath));
 	return resolved.dbPath;
 }
@@ -1097,9 +1106,10 @@ async function discoverSections() {
 	for (const ptm of sorted) log$2.verbose(`  ${ptm.name.padEnd(28)} total=${String(ptm.totalMs).padStart(6)} resS=${String(ptm.resolveSchemaMs).padStart(5)} impS=${String(ptm.importSchemaMs).padStart(6)} resM=${String(ptm.resolveMigrationsMs).padStart(5)} impM=${String(ptm.importMigrationsMs).padStart(6)}`);
 	return sections;
 }
-var DbService = class extends Service {
-	static key = "db";
-	static deps = { http: HttpService };
+var DbService = class extends Service.create({
+	key: "db",
+	deps: { http: HttpService }
+}) {
 	db = null;
 	dbRouter = null;
 	sectionsHash = "";
@@ -1188,6 +1198,110 @@ var DbService = class extends Service {
 		this.setup("kyju-close-on-cleanup", () => async () => {
 			await this.close();
 		});
+		this.setup("migrations-watcher", () => {
+			const subs = [];
+			let closed = false;
+			let pendingTimer = null;
+			let inFlight = null;
+			let queued = false;
+			const triggerReload = async () => {
+				if (closed) return;
+				if (inFlight) {
+					queued = true;
+					return;
+				}
+				inFlight = runtime.reload("db").catch((err) => {
+					log$2.error("migrations-watcher reload failed:", err);
+				});
+				try {
+					await inFlight;
+				} finally {
+					inFlight = null;
+					if (queued && !closed) {
+						queued = false;
+						scheduleReload();
+					}
+				}
+			};
+			const scheduleReload = () => {
+				if (closed) return;
+				if (pendingTimer) clearTimeout(pendingTimer);
+				pendingTimer = setTimeout(() => {
+					pendingTimer = null;
+					triggerReload();
+				}, 100);
+			};
+			(async () => {
+				for (const plugin of getPlugins()) {
+					const migPath = plugin.migrationsPath;
+					if (!migPath) continue;
+					let isDir = false;
+					try {
+						isDir = (await fsp.stat(migPath)).isDirectory();
+					} catch {
+						continue;
+					}
+					if (!isDir) continue;
+					const journalPath = path.join(migPath, "meta", "_journal.json");
+					try {
+						const sub = await subscribe(migPath, (err, events) => {
+							if (err || closed) return;
+							for (const event of events) {
+								if (event.path === journalPath) {
+									scheduleReload();
+									return;
+								}
+								if (path.dirname(event.path) !== migPath) continue;
+								if (event.type === "update") continue;
+								const ext = path.extname(event.path);
+								if (ext === ".ts" || ext === ".js" || ext === ".mjs") {
+									scheduleReload();
+									return;
+								}
+							}
+						});
+						if (closed) {
+							await sub.unsubscribe().catch(() => {});
+							return;
+						}
+						subs.push(sub);
+					} catch (err) {
+						log$2.error(`migrations-watcher subscribe failed for ${plugin.name}: ${err instanceof Error ? err.message : String(err)}`);
+					}
+				}
+			})().catch((err) => {
+				log$2.error("migrations-watcher setup failed:", err);
+			});
+			return async () => {
+				closed = true;
+				if (pendingTimer) {
+					clearTimeout(pendingTimer);
+					pendingTimer = null;
+				}
+				const toClose = subs.splice(0);
+				await Promise.all(toClose.map((s) => s.unsubscribe().catch(() => {})));
+			};
+		});
+		this.setup("plugin-set-watcher", () => {
+			const fingerprint = (snap) => JSON.stringify([...snap.plugins].map((p) => ({
+				name: p.name,
+				schemaPath: p.schemaPath ?? null,
+				migrationsPath: p.migrationsPath ?? null
+			})).sort((a, b) => a.name.localeCompare(b.name)));
+			let lastHash = null;
+			return subscribeConfig((snap) => {
+				const hash = fingerprint(snap);
+				if (lastHash === null) {
+					lastHash = hash;
+					return;
+				}
+				if (hash === lastHash) return;
+				lastHash = hash;
+				runtime.reload("db").catch((err) => {
+					log$2.error("plugin-set-watcher reload failed:", err);
+				});
+			});
+		});
 		this.setup("ws-transport", () => {
 			const onConnected = (id, ws) => {
 				const dbConn = this.dbRouter.connection({
@@ -1227,69 +1341,71 @@ var DbService = class extends Service {
 runtime.register(DbService, import.meta);
 //#endregion
 //#region src/services/view-registry.ts
+var view_registry_exports = /* @__PURE__ */ __exportAll({ ViewRegistryService: () => ViewRegistryService });
 const log$1 = createLogger("view-registry");
-var ViewRegistryService = class extends Service {
-	static key = "view-registry";
-	static deps = {
+var ViewRegistryService = class extends Service.create({
+	key: "view-registry",
+	deps: {
 		reloader: ReloaderService,
 		db: DbService
-	};
+	}
+}) {
 	views = /* @__PURE__ */ new Map();
 	manifestIcons = /* @__PURE__ */ new Map();
-	async register(scope, root, configFile, meta) {
-		log$1.verbose(`register("${scope}", root="${root}", config="${configFile}")`);
-		const existing = this.views.get(scope);
+	async register(type, root, configFile, meta) {
+		log$1.verbose(`register("${type}", root="${root}", config="${configFile}")`);
+		const existing = this.views.get(type);
 		if (existing) {
-			log$1.verbose(`"${scope}" already exists at ${existing.url}`);
+			log$1.verbose(`"${type}" already exists at ${existing.url}`);
 			return existing;
 		}
-		log$1.verbose(`creating reloader for "${scope}"...`);
-		const reloaderEntry = await this.ctx.reloader.create(scope, root, configFile);
+		log$1.verbose(`creating reloader for "${type}"...`);
+		const reloaderEntry = await this.ctx.reloader.create(type, root, configFile);
 		log$1.verbose(`reloader created: ${reloaderEntry.url} (port ${reloaderEntry.port})`);
 		const entry = {
-			scope,
+			type,
 			url: reloaderEntry.url,
 			port: reloaderEntry.port,
 			ownsServer: true,
 			meta
 		};
-		this.views.set(scope, entry);
+		this.views.set(type, entry);
 		await this.syncToDb();
-		log$1.verbose(`"${scope}" registered at ${entry.url}`);
+		log$1.verbose(`"${type}" registered at ${entry.url}`);
 		return entry;
 	}
-	registerAlias(scope, reloaderId, pathPrefix, meta) {
-		const existing = this.views.get(scope);
+	registerAlias(type, reloaderId, pathPrefix, meta) {
+		const existing = this.views.get(type);
 		if (existing) return existing;
 		const reloaderEntry = this.ctx.reloader.get(reloaderId);
-		if (!reloaderEntry) throw new Error(`Reloader "${reloaderId}" not found for alias "${scope}"`);
+		if (!reloaderEntry) throw new Error(`Reloader "${reloaderId}" not found for alias "${type}"`);
 		const entry = {
-			scope,
+			type,
 			url: `${reloaderEntry.url}${pathPrefix}`,
 			port: reloaderEntry.port,
 			ownsServer: false,
 			meta
 		};
-		this.views.set(scope, entry);
+		this.views.set(type, entry);
 		this.syncToDb();
 		return entry;
 	}
-	async unregister(scope) {
-		const entry = this.views.get(scope);
+	async unregister(type) {
+		const entry = this.views.get(type);
 		if (!entry) return;
-		if (entry.ownsServer) await this.ctx.reloader.remove(scope);
-		this.views.delete(scope);
+		if (entry.ownsServer) await this.ctx.reloader.remove(type);
+		this.views.delete(type);
 		await this.syncToDb();
 	}
-	get(scope) {
-		return this.views.get(scope);
+	get(type) {
+		return this.views.get(type);
 	}
 	evaluate() {
 		this.loadManifestIcons();
 		this.syncToDb();
 		this.setup("view-registry-cleanup", () => {
 			return async () => {
-				for (const [scope, entry] of this.views) if (entry.ownsServer) await this.ctx.reloader.remove(scope);
+				for (const [type, entry] of this.views) if (entry.ownsServer) await this.ctx.reloader.remove(type);
 				this.views.clear();
 				await this.syncToDb();
 			};
@@ -1299,16 +1415,16 @@ var ViewRegistryService = class extends Service {
 		this.manifestIcons.clear();
 		for (const plugin of getPlugins()) {
 			if (!plugin.icons) continue;
-			for (const [scope, svg] of Object.entries(plugin.icons)) this.manifestIcons.set(scope, svg);
+			for (const [type, svg] of Object.entries(plugin.icons)) this.manifestIcons.set(type, svg);
 		}
 	}
 	async syncToDb() {
 		const client = this.ctx.db.effectClient;
 		const snapshot = [...this.views.values()].map((e) => ({
-			scope: e.scope,
+			type: e.type,
 			url: e.url,
 			port: e.port,
-			icon: this.manifestIcons.get(e.scope),
+			icon: this.manifestIcons.get(e.type),
 			meta: e.meta
 		}));
 		await Effect.runPromise(client.update((root) => {
@@ -1319,6 +1435,10 @@ var ViewRegistryService = class extends Service {
 runtime.register(ViewRegistryService, import.meta);
 //#endregion
 //#region src/services/renderer-host.ts
+var renderer_host_exports = /* @__PURE__ */ __exportAll({
+	APP_RENDERER_RELOADER_ID: () => "app",
+	RendererHostService: () => RendererHostService
+});
 const log = createLogger("renderer-host");
 async function pathExists(filePath) {
 	try {
@@ -1329,18 +1449,18 @@ async function pathExists(filePath) {
 	}
 }
 /**
-* The app's renderer root is the directory containing the boot-window HTML
-* file (`uiEntrypoint` in `zenbu.config.ts`). Vite's `root` resolves to that
-* directory, and `index.html` is served from there.
+* The app's renderer root is the `uiEntrypoint` directory in
+* `zenbu.config.ts`. Vite's `root` resolves to it, and `index.html` inside
+* it is served through Vite. `splash.html` (sibling) is loaded raw — see
+* `setup-gate.spawnSplashWindow`.
 *
 * `vite.config.ts` is picked up from the project root if present (sibling
 * of `zenbu.config.ts`).
 */
 async function resolveRendererRoot() {
-	const entrypoint = getAppEntrypoint();
-	if (!entrypoint) throw new Error("[renderer-host] no `uiEntrypoint` registered. Set `uiEntrypoint` in zenbu.config.ts before starting the app.");
-	const rendererRoot = path.dirname(entrypoint);
-	if (!await pathExists(rendererRoot)) throw new Error(`[renderer-host] uiEntrypoint references ${entrypoint} but ${rendererRoot} does not exist.`);
+	const rendererRoot = getAppEntrypoint();
+	if (!rendererRoot) throw new Error("[renderer-host] no `uiEntrypoint` registered. Set `uiEntrypoint` in zenbu.config.ts before starting the app.");
+	if (!await pathExists(rendererRoot)) throw new Error(`[renderer-host] uiEntrypoint directory does not exist: ${rendererRoot}.`);
 	const configPath = process.env.ZENBU_CONFIG_PATH;
 	const projectDir = configPath ? path.dirname(configPath) : rendererRoot;
 	const viteConfig = path.join(projectDir, "vite.config.ts");
@@ -1349,12 +1469,13 @@ async function resolveRendererRoot() {
 		configFile: await pathExists(viteConfig) ? viteConfig : false
 	};
 }
-var RendererHostService = class extends Service {
-	static key = "renderer-host";
-	static deps = {
+var RendererHostService = class extends Service.create({
+	key: "renderer-host",
+	deps: {
 		reloader: ReloaderService,
 		viewRegistry: ViewRegistryService
-	};
+	}
+}) {
 	url = "";
 	port = 0;
 	async evaluate() {
@@ -1371,4 +1492,4 @@ var RendererHostService = class extends Service {
 };
 runtime.register(RendererHostService, import.meta);
 //#endregion
-export { resolveManifestModulePath as a, discoverSections as i, ViewRegistryService as n, HttpService as o, DbService as r, RendererHostService as t };
+export { DbService as a, http_exports as c, view_registry_exports as i, renderer_host_exports as n, db_exports as o, ViewRegistryService as r, HttpService as s, RendererHostService as t };

package/dist/{rpc-CsgWnlZx.mjs → rpc-C4_NQmpT.mjs}

@@ -1,12 +1,15 @@
-import { t as Service, u as runtime } from "./runtime-C95iyVn6.mjs";
-import { t as createLogger } from "./log-CyKv8hQg.mjs";
-import { o as HttpService } from "./renderer-host-ztaSIOGx.mjs";
-import { n as createRpcRouter, r as createServer } from "./src-pELM4_iH.mjs";
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { Service, runtime } from "./runtime.mjs";
+import { t as createLogger } from "./log-6rzaCV0I.mjs";
+import { s as HttpService } from "./renderer-host-DD16MXhI.mjs";
+import { n as createRpcRouter, r as createServer } from "./src-Cven45mq.mjs";
 //#region src/services/rpc.ts
+var rpc_exports = /* @__PURE__ */ __exportAll({ RpcService: () => RpcService });
 const log = createLogger("rpc");
-var RpcService = class extends Service {
-	static key = "rpc";
-	static deps = { http: HttpService };
+var RpcService = class extends Service.create({
+	key: "rpc",
+	deps: { http: HttpService }
+}) {
 	_emit = null;
 	get emit() {
 		if (!this._emit) throw new Error("RpcService not yet evaluated");
@@ -68,4 +71,4 @@ var RpcService = class extends Service {
 };
 runtime.register(RpcService, import.meta);
 //#endregion
-export { RpcService as t };
+export { rpc_exports as n, RpcService as t };

package/dist/rpc.d.mts

@@ -1,2 +1,2 @@
-import { n as EventProxy, r as RouterProxy, t as connectRpc } from "./index-CE0iPntP.mjs";
+import { n as EventProxy, r as RouterProxy, t as connectRpc } from "./index-C-ALz_SH.mjs";
 export { type EventProxy, type RouterProxy, connectRpc };

package/dist/rpc.mjs

@@ -1,2 +1,2 @@
-import { t as connectRpc } from "./src-pELM4_iH.mjs";
+import { t as connectRpc } from "./src-Cven45mq.mjs";
 export { connectRpc };

package/dist/runtime-BQWntcOb.d.mts

@@ -0,0 +1,218 @@
+//#region src/runtime.d.ts
+type CleanupReason = "reload" | "shutdown";
+type SetupCleanup = ((reason: CleanupReason) => void | Promise<void>) | void;
+type SetupFn = () => SetupCleanup;
+interface ServiceSlot {
+  error: unknown | null;
+  instance: Service | null;
+  ServiceClass: ServiceConstructor;
+  status: "blocked" | "evaluating" | "ready" | "failed";
+}
+type AnyServiceClass = (abstract new (...args: any[]) => Service) & {
+  key: string;
+};
+type DepEntry = AnyServiceClass | string;
+type DepInstance<D> = D extends AnyServiceClass ? InstanceType<D> : unknown;
+type ResolveCtx<TDeps> = { [K in keyof TDeps]: DepInstance<TDeps[K]> };
+/**
+ * A concrete service class registered with the runtime. Always has a
+ * `static key` (set by `Service.create`) and an optional `static deps`
+ * map. Used as the parameter type of `runtime.register`.
+ */
+type ServiceConstructor = (new (...args: any[]) => Service) & {
+  key: string;
+  deps?: Record<string, DepEntry>;
+};
+declare abstract class Service {
+  static deps: Record<string, DepEntry>;
+  /**
+   * Define a Service base class. The returned abstract class has
+   * `static key`, `static deps`, and a typed `this.ctx` already set up;
+   * extend it and add your `evaluate()` body.
+   *
+   *     export class WindowService extends Service.create({
+   *       key: "window",
+   *       deps: {
+   *         baseWindow: BaseWindowService,
+   *         http: HttpService,
+   *       },
+   *     }) {
+   *       evaluate() {
+   *         this.ctx.baseWindow  // BaseWindowService
+   *         this.ctx.http        // HttpService
+   *       }
+   *     }
+   *
+   * `key` is a required field on the config object, so TypeScript errors
+   * if you forget it. `deps` is optional (defaults to no deps).
+   *
+   * For dynamic / optional access to another service, use
+   * `runtime.get(SomeService, cb)` instead of declaring it in `deps`.
+   */
+  static create<TKey extends string, TDeps extends Record<string, DepEntry> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: ResolveCtx<TDeps>; /** @internal */
+    __setupCleanups: Map<string, (reason: CleanupReason) => void | Promise<void>>;
+    evaluate(): void | Promise<void>;
+    setup(key: string, fn: SetupFn): void;
+    /**
+     * Run `fn` and return its result. Historically reported a boot-trace span;
+     * now a thin wrapper preserved for caller ergonomics inside service
+     * `evaluate()` bodies.
+     */
+    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; /** @internal */
+    __cleanupAllSetups(reason?: CleanupReason): Promise<void>;
+  }) & {
+    key: TKey;
+    deps: Record<string, DepEntry>;
+    create<TKey extends string, TDeps extends Record<string, DepEntry> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+  ctx: any;
+  /** @internal */
+  __setupCleanups: Map<string, (reason: CleanupReason) => void | Promise<void>>;
+  evaluate(): void | Promise<void>;
+  setup(key: string, fn: SetupFn): void;
+  /**
+   * Run `fn` and return its result. Historically reported a boot-trace span;
+   * now a thin wrapper preserved for caller ergonomics inside service
+   * `evaluate()` bodies.
+   */
+  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;
+  /** @internal */
+  __cleanupAllSetups(reason?: CleanupReason): Promise<void>;
+}
+declare class ServiceRuntime {
+  private definitions;
+  private dependentsIndex;
+  private dirtyKeys;
+  private drainError;
+  private draining;
+  private registrationTokens;
+  private slots;
+  private onReconciledCallbacks;
+  private subscribers;
+  register(ServiceClass: ServiceConstructor, importMeta?: ImportMeta | null): void;
+  getAllKeys(): string[];
+  getSlot(key: string): ServiceSlot | undefined;
+  whenIdle(): Promise<void>;
+  reloadAll(): Promise<void>;
+  /**
+   * Reload a single service by key. No-op if the key is not registered.
+   * Used by infrastructure that watches resources outside dynohot's
+   * import-graph (e.g. the migrations directory watcher in DbService) and
+   * needs to nudge a specific service to re-evaluate without leaning on
+   * the devtools-only `__zenbu_dev__.reloadService` hook.
+   */
+  reload(key: string): Promise<void>;
+  shutdown(): Promise<void>;
+  /**
+   * Subscribe to a service. Behavior-subject style: the callback fires
+   * synchronously once with the current value (the live instance if ready,
+   * `undefined` otherwise), then again on every reconcile of that service —
+   * so you see the new instance after each HMR. Pass through `undefined`
+   * when the service tears down or unregisters.
+   *
+   * Returns an unsubscribe function. Always call it from a `setup()` cleanup
+   * (or wherever you'd otherwise leak callbacks across reloads).
+   */
+  get<T extends Service>(ref: {
+    key: string;
+  }, cb: (instance: T | undefined) => void): () => void;
+  private fireSubscribers;
+  buildRouter(): Record<string, Record<string, (...args: any[]) => any>>;
+  onReconciled(cb: (changedKeys: string[]) => void): () => void;
+  private resolveDepSlot;
+  private injectCtx;
+  private rebuildDependentsIndex;
+  private getAffectedKeys;
+  private listMissingDeps;
+  private ensureSlot;
+  private teardownService;
+  private unregister;
+  private scheduleReconcile;
+  private reconcileBatch;
+  private reconcileKey;
+  private topologicalLevels;
+}
+declare const runtime: ServiceRuntime;
+/**
+ * A plugin manifest after the loader has resolved every relative path to
+ * absolute. Mirrors `ResolvedPlugin` in `cli/lib/build-config.ts` but is
+ * declared inline here to avoid runtime.ts importing CLI code.
+ */
+interface PluginRecord {
+  name: string;
+  dir: string;
+  services: string[];
+  schemaPath?: string;
+  migrationsPath?: string;
+  preloadPath?: string;
+  eventsPath?: string;
+  icons?: Record<string, string>;
+}
+/**
+ * Live snapshot of the resolved Zenbu config. Returned by `getConfig()` and
+ * delivered to `subscribeConfig` callbacks. Re-emitted whenever the loader
+ * regenerates the plugin barrel — i.e. on every edit to `zenbu.config.ts`
+ * or any imported `zenbu.plugin.ts`.
+ */
+interface ConfigSnapshot {
+  plugins: PluginRecord[];
+  /** Absolute path of the renderer entrypoint directory. */
+  appEntrypoint: string | null;
+  /** Absolute path of `splash.html` inside the entrypoint dir. */
+  splashPath: string | null;
+}
+/**
+ * Register a plugin's resolved manifest. Idempotent — replaces any existing
+ * entry for the same `name`. Called by the loader-emitted barrel; user code
+ * normally does not call this directly.
+ */
+declare function registerPlugin(record: PluginRecord): void;
+/**
+ * Drop a plugin from the registry. Used when the loader regenerates the
+ * barrel and needs to clear stale entries.
+ */
+declare function unregisterPlugin(name: string): void;
+/**
+ * Replace the entire plugin set in one shot. The loader uses this on every
+ * barrel regeneration so removed plugins disappear cleanly.
+ */
+declare function replacePlugins(records: PluginRecord[]): void;
+declare function getPlugins(): PluginRecord[];
+declare function getPlugin(name: string): PluginRecord | undefined;
+/**
+ * Set the renderer entrypoint directory + the absolute path to splash.html
+ * inside it. Called once by the loader-emitted barrel. Consumers
+ * (`view-registry`, `vite-plugins`, `setup-gate`'s splash window) read
+ * via `getAppEntrypoint()` / `getSplashPath()`.
+ */
+declare function registerAppEntrypoint(rendererDir: string, splashPath: string): void;
+declare function getAppEntrypoint(): string | null;
+declare function getSplashPath(): string | null;
+/**
+ * Snapshot of the current resolved config — plugins + entrypoints. Cheap;
+ * just walks the in-memory registry. The returned object is a fresh copy,
+ * safe to retain or pass through serialization boundaries.
+ */
+declare function getConfig(): ConfigSnapshot;
+/**
+ * Subscribe to config changes. The callback fires:
+ *   - immediately on subscription (with the current snapshot),
+ *   - after each `replacePlugins(...)` / `registerPlugin(...)` /
+ *     `registerAppEntrypoint(...)` call — i.e. every time the loader
+ *     regenerates the plugin barrel after a `zenbu.config.ts` edit.
+ *
+ * Callback exceptions are logged and swallowed so one buggy subscriber
+ * can't break others. The returned function unsubscribes.
+ */
+declare function subscribeConfig(callback: (snapshot: ConfigSnapshot) => void): () => void;
+//#endregion
+export { unregisterPlugin as _, ServiceConstructor as a, getConfig as c, getSplashPath as d, registerAppEntrypoint as f, subscribeConfig as g, runtime as h, Service as i, getPlugin as l, replacePlugins as m, ConfigSnapshot as n, ServiceRuntime as o, registerPlugin as p, PluginRecord as r, getAppEntrypoint as s, CleanupReason as t, getPlugins as u };

package/dist/runtime.d.mts

@@ -1,2 +1,2 @@
-import { a as getAppEntrypoint, c as optional, d as replacePlugins, f as runtime, i as ServiceRuntime, l as registerAppEntrypoint, m as unregisterPlugin, n as PluginRecord, o as getPlugin, p as serviceWithDeps, r as Service, s as getPlugins, t as CleanupReason, u as registerPlugin } from "./runtime-CsiDppGF.mjs";
-export { CleanupReason, PluginRecord, Service, ServiceRuntime, getAppEntrypoint, getPlugin, getPlugins, optional, registerAppEntrypoint, registerPlugin, replacePlugins, runtime, serviceWithDeps, unregisterPlugin };
+import { _ as unregisterPlugin, a as ServiceConstructor, c as getConfig, d as getSplashPath, f as registerAppEntrypoint, g as subscribeConfig, h as runtime, i as Service, l as getPlugin, m as replacePlugins, n as ConfigSnapshot, o as ServiceRuntime, p as registerPlugin, r as PluginRecord, s as getAppEntrypoint, t as CleanupReason, u as getPlugins } from "./runtime-BQWntcOb.mjs";
+export { CleanupReason, ConfigSnapshot, PluginRecord, Service, ServiceConstructor, ServiceRuntime, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, registerAppEntrypoint, registerPlugin, replacePlugins, runtime, subscribeConfig, unregisterPlugin };