@zenbujs/core 0.0.8 → 0.0.12

package/dist/runtime-DYUONc3S.mjs

@@ -0,0 +1,861 @@
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/services/advice-config.ts
+var advice_config_exports = /* @__PURE__ */ __exportAll({
+	addAdvice: () => addAdvice,
+	addContentScript: () => addContentScript,
+	getAdvice: () => getAdvice,
+	getAllAdviceTypes: () => getAllAdviceTypes,
+	getAllContentScriptPaths: () => getAllContentScriptPaths,
+	getAllTypes: () => getAllTypes,
+	getContentScripts: () => getContentScripts
+});
+const RESOLVED_PREFIX = "\0@advice-prelude/";
+const APP_RENDERER_RELOADER_ID = "app";
+const adviceEntries = /* @__PURE__ */ new Map();
+const contentScripts = /* @__PURE__ */ new Map();
+function resolveAgainstPlugin(modulePath, pluginDir) {
+	if (path.isAbsolute(modulePath)) return modulePath;
+	return path.resolve(pluginDir, modulePath);
+}
+function invalidatePrelude(type) {
+	try {
+		const reloader = runtime.getSlot("reloader")?.instance;
+		if (!reloader) return;
+		const coreEntry = reloader.get(APP_RENDERER_RELOADER_ID);
+		if (!coreEntry?.viteServer) return;
+		const graph = coreEntry.viteServer.moduleGraph;
+		const invalidateMatching = (test) => {
+			const ids = [];
+			for (const id of graph.idToModuleMap.keys()) {
+				if (typeof id !== "string") continue;
+				if (test(id)) ids.push(id);
+			}
+			for (const id of ids) {
+				const mod = graph.getModuleById(id);
+				if (mod) graph.invalidateModule(mod);
+			}
+		};
+		if (type === "*") invalidateMatching((id) => id.startsWith(RESOLVED_PREFIX));
+		else {
+			const prefix = RESOLVED_PREFIX + type;
+			invalidateMatching((id) => id === prefix || id.startsWith(prefix + "?"));
+		}
+	} catch {}
+}
+function emitReload(type) {
+	invalidatePrelude(type);
+	try {
+		const rpc = runtime.getSlot("rpc")?.instance;
+		if (!rpc) return;
+		rpc.emit.core.advice.reload({ type });
+	} catch {}
+}
+/**
+* Internal advice registrar. Called by `Service#advise` after the runtime
+* has resolved the calling plugin's root directory from its service slot.
+* User code does not call this directly; use `service.advise({...})`
+* instead.
+*/
+function addAdvice(pluginDir, spec) {
+	const { view, ...entry } = spec;
+	const resolvedEntry = {
+		...entry,
+		modulePath: resolveAgainstPlugin(entry.modulePath, pluginDir)
+	};
+	const list = adviceEntries.get(view) ?? [];
+	list.push(resolvedEntry);
+	adviceEntries.set(view, list);
+	emitReload(view);
+	return () => {
+		const current = adviceEntries.get(view);
+		if (!current) return;
+		const idx = current.indexOf(resolvedEntry);
+		if (idx >= 0) current.splice(idx, 1);
+		if (current.length === 0) adviceEntries.delete(view);
+		emitReload(view);
+	};
+}
+function getAdvice(type) {
+	return adviceEntries.get(type) ?? [];
+}
+function getAllAdviceTypes() {
+	return [...adviceEntries.keys()];
+}
+/**
+* Internal content-script registrar. Called by `Service#contentScript`
+* after the runtime has resolved the calling plugin's root directory.
+* User code uses `service.contentScript({...})`.
+*/
+function addContentScript(pluginDir, spec) {
+	const { view, modulePath } = spec;
+	const entry = { path: resolveAgainstPlugin(modulePath, pluginDir) };
+	const list = contentScripts.get(view) ?? [];
+	list.push(entry);
+	contentScripts.set(view, list);
+	emitReload(view === "*" ? "*" : view);
+	return () => {
+		const current = contentScripts.get(view);
+		if (!current) return;
+		const idx = current.indexOf(entry);
+		if (idx >= 0) current.splice(idx, 1);
+		if (current.length === 0) contentScripts.delete(view);
+		emitReload(view === "*" ? "*" : view);
+	};
+}
+function getContentScripts(type) {
+	const scoped = (contentScripts.get(type) ?? []).map((e) => e.path);
+	return [...type !== "*" ? (contentScripts.get("*") ?? []).map((e) => e.path) : [], ...scoped];
+}
+function getAllContentScriptPaths() {
+	const paths = [];
+	for (const list of contentScripts.values()) for (const entry of list) paths.push(entry.path);
+	return paths;
+}
+function getAllTypes() {
+	const types = /* @__PURE__ */ new Set();
+	for (const k of adviceEntries.keys()) types.add(k);
+	for (const k of contentScripts.keys()) if (k !== "*") types.add(k);
+	return [...types];
+}
+//#endregion
+//#region src/runtime.ts
+/**
+* The synthetic plugin name used for everything that ships inside
+* `@zenbujs/core`. Mirrors the `core` DB section so RPC, events, and the
+* database all use the same top-level namespace.
+*/
+const CORE_PLUGIN_NAME = "core";
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5e3;
+function readShutdownTimeoutMs() {
+	const raw = process.env.ZENBU_SHUTDOWN_TIMEOUT_MS;
+	if (!raw) return DEFAULT_SHUTDOWN_TIMEOUT_MS;
+	const value = Number(raw);
+	return Number.isFinite(value) && value > 0 ? value : DEFAULT_SHUTDOWN_TIMEOUT_MS;
+}
+function resolveDepKey(entry) {
+	if (typeof entry === "string") return entry;
+	return entry.key;
+}
+var Service = class {
+	static deps = {};
+	/**
+	* 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(config) {
+		const { key, deps } = config;
+		const resolvedDeps = deps ?? {};
+		class ConfiguredService extends Service {
+			static key = key;
+			static deps = resolvedDeps;
+		}
+		return ConfiguredService;
+	}
+	ctx;
+	/** @internal */
+	__setupCleanups = /* @__PURE__ */ new Map();
+	evaluate() {}
+	/**
+	* Register advice (component wrap/replace, function before/after/around)
+	* targeting another plugin's exports. The owning plugin's root directory
+	* is resolved automatically from this service's slot, so relative
+	* `modulePath` values just work.
+	*
+	*   this.setup("wrap-counter", () =>
+	*     this.advise({
+	*       view: "app",
+	*       moduleId: "App.tsx",
+	*       name: "Counter",
+	*       type: "around",
+	*       modulePath: "src/content/wrap-counter.tsx",
+	*       exportName: "WrapCounter",
+	*     }),
+	*   )
+	*
+	* Returns an unregister function — wrap the call in `this.setup(...)`
+	* so cleanup runs on hot reload.
+	*/
+	advise(spec) {
+		return addAdvice(this.__getPluginDir("advise"), spec);
+	}
+	/**
+	* Inject a content script into a view. Same plugin-root resolution
+	* rules as `advise`.
+	*
+	*   this.setup("inject", () =>
+	*     this.injectContentScript({
+	*       view: "*",
+	*       modulePath: "src/content/toolbar.tsx",
+	*     }),
+	*   )
+	*/
+	injectContentScript(spec) {
+		return addContentScript(this.__getPluginDir("injectContentScript"), spec);
+	}
+	/** @internal */
+	__getPluginDir(method) {
+		const ctor = this.constructor;
+		const key = ctor.key;
+		const dir = (key ? runtime.getSlot(key) : void 0)?.pluginDir ?? null;
+		if (!dir) {
+			const label = ctor.name ?? key ?? "<anonymous>";
+			throw new Error(`[runtime] Service "${label}" called this.${method}() but its slot has no pluginDir. This service was registered from a file outside any plugin's directory; ${method}() is only valid for services declared inside a plugin.`);
+		}
+		return dir;
+	}
+	setup(key, fn) {
+		const existing = this.__setupCleanups.get(key);
+		if (existing) try {
+			existing("reload");
+		} catch (e) {
+			console.error(`[hot] setup cleanup "${key}" failed:`, e);
+		}
+		const cleanup = fn();
+		if (cleanup) this.__setupCleanups.set(key, cleanup);
+		else this.__setupCleanups.delete(key);
+	}
+	/**
+	* 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(_name, fn, _meta) {
+		return Promise.resolve(fn());
+	}
+	traceSync(_name, fn, _meta) {
+		return fn();
+	}
+	/** @internal */
+	async __cleanupAllSetups(reason = "shutdown") {
+		for (const [key, cleanup] of this.__setupCleanups) try {
+			await cleanup(reason);
+		} catch (e) {
+			console.error(`[hot] setup cleanup "${key}" failed:`, e);
+		}
+		this.__setupCleanups.clear();
+	}
+};
+const SERVICE_BASE_METHODS = new Set(Object.getOwnPropertyNames(Service.prototype));
+var ServiceRuntime = class {
+	definitions = /* @__PURE__ */ new Map();
+	dependentsIndex = /* @__PURE__ */ new Map();
+	dirtyKeys = /* @__PURE__ */ new Set();
+	drainError = null;
+	draining = null;
+	registrationTokens = /* @__PURE__ */ new Map();
+	slots = /* @__PURE__ */ new Map();
+	onReconciledCallbacks = [];
+	subscribers = /* @__PURE__ */ new Map();
+	register(ServiceClass, importMeta) {
+		const hot = importMeta?.hot ?? null;
+		const slotKey = ServiceClass.key;
+		if (typeof slotKey !== "string" || slotKey.length === 0) {
+			const name = ServiceClass.name ?? "<anonymous>";
+			throw new Error(`[runtime] service "${name}" is missing \`static key\`. Define it via \`Service.create({ key: "...", ... })\`.`);
+		}
+		const metaUrl = importMeta?.url;
+		const pluginDir = metaUrl ? findOwningPluginDir(metaUrl) : null;
+		this.definitions.set(slotKey, ServiceClass);
+		const slot = this.slots.get(slotKey);
+		if (slot) {
+			slot.ServiceClass = ServiceClass;
+			slot.pluginDir = pluginDir;
+		} else this.slots.set(slotKey, {
+			error: null,
+			instance: null,
+			ServiceClass,
+			status: "blocked",
+			pluginDir
+		});
+		this.rebuildDependentsIndex();
+		hot?.accept();
+		const token = Symbol(slotKey);
+		this.registrationTokens.set(slotKey, token);
+		hot?.prune?.(() => {
+			this.unregister(slotKey, token);
+		});
+		this.scheduleReconcile([slotKey]);
+	}
+	getAllKeys() {
+		return [...this.slots.keys()];
+	}
+	getSlot(key) {
+		return this.slots.get(key);
+	}
+	async whenIdle() {
+		while (this.draining) await this.draining;
+		if (this.drainError) {
+			const error = this.drainError;
+			this.drainError = null;
+			throw error;
+		}
+	}
+	async reloadAll() {
+		const keys = [...this.slots.keys()];
+		if (keys.length === 0) return;
+		await this.scheduleReconcile(keys);
+		await this.whenIdle();
+	}
+	/**
+	* 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.
+	*/
+	async reload(key) {
+		if (!this.slots.has(key)) return;
+		await this.scheduleReconcile([key]);
+		await this.whenIdle();
+	}
+	async shutdown() {
+		try {
+			await this.whenIdle();
+		} catch (error) {
+			console.error("[hot] runtime idle wait failed during shutdown:", error);
+		}
+		const keys = [...this.slots.keys()].reverse();
+		for (const key of keys) await this.teardownService(key, { removeSlot: true });
+		this.definitions.clear();
+		this.dependentsIndex.clear();
+		this.dirtyKeys.clear();
+		this.registrationTokens.clear();
+	}
+	/**
+	* 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(ref, cb) {
+		const key = ref.key;
+		let subs = this.subscribers.get(key);
+		if (!subs) {
+			subs = /* @__PURE__ */ new Set();
+			this.subscribers.set(key, subs);
+		}
+		const wrapped = cb;
+		subs.add(wrapped);
+		const slot = this.slots.get(key);
+		const current = slot?.status === "ready" && slot.instance ? slot.instance : void 0;
+		try {
+			cb(current);
+		} catch (e) {
+			console.error(`[hot] runtime.get subscriber for "${key}" threw:`, e);
+		}
+		return () => {
+			const set = this.subscribers.get(key);
+			if (!set) return;
+			set.delete(wrapped);
+			if (set.size === 0) this.subscribers.delete(key);
+		};
+	}
+	fireSubscribers(key) {
+		const subs = this.subscribers.get(key);
+		if (!subs || subs.size === 0) return;
+		const slot = this.slots.get(key);
+		const instance = slot?.status === "ready" && slot.instance ? slot.instance : void 0;
+		for (const cb of [...subs]) try {
+			cb(instance);
+		} catch (e) {
+			console.error(`[hot] runtime.get subscriber for "${key}" threw:`, e);
+		}
+	}
+	/**
+	* Build a 3-level router keyed by plugin name → service key → method.
+	* Mirrors how the database is sectioned (`root.<plugin>.<field>`) so a
+	* service's RPC surface lives under its owning plugin's namespace
+	* instead of polluting the top level. Core services bucket under
+	* `"core"` because the core package is registered as a synthetic
+	* plugin (see `getPluginRegistry`).
+	*/
+	buildRouter() {
+		const router = {};
+		for (const [slotKey, slot] of this.slots) {
+			if (slot.status !== "ready" || !slot.instance) continue;
+			const proto = Object.getPrototypeOf(slot.instance);
+			const methods = {};
+			for (const name of Object.getOwnPropertyNames(proto)) {
+				if (SERVICE_BASE_METHODS.has(name)) continue;
+				if (name.startsWith("_")) continue;
+				const desc = Object.getOwnPropertyDescriptor(proto, name);
+				if (!desc || typeof desc.value !== "function") continue;
+				const instance = slot.instance;
+				methods[name] = (...args) => instance[name](...args);
+			}
+			if (Object.keys(methods).length === 0) continue;
+			const pluginName = pluginNameForDir(slot.pluginDir);
+			const bucket = router[pluginName] ??= {};
+			bucket[slotKey] = methods;
+		}
+		return router;
+	}
+	onReconciled(cb) {
+		this.onReconciledCallbacks.push(cb);
+		return () => {
+			const idx = this.onReconciledCallbacks.indexOf(cb);
+			if (idx >= 0) this.onReconciledCallbacks.splice(idx, 1);
+		};
+	}
+	resolveDepSlot(depKey) {
+		return this.slots.get(depKey);
+	}
+	injectCtx(instance, ServiceClass) {
+		const deps = ServiceClass.deps ?? {};
+		const ctx = {};
+		for (const [name, entry] of Object.entries(deps)) {
+			const key = resolveDepKey(entry);
+			const slot = this.resolveDepSlot(key);
+			if (!slot || slot.status !== "ready" || !slot.instance) throw new Error(`Dependency "${key}" not ready for "${ServiceClass.key}"`);
+			ctx[name] = slot.instance;
+		}
+		instance.ctx = ctx;
+	}
+	rebuildDependentsIndex() {
+		const next = /* @__PURE__ */ new Map();
+		for (const [slotKey, ServiceClass] of this.definitions) {
+			const deps = ServiceClass.deps ?? {};
+			for (const entry of Object.values(deps)) {
+				const depKey = resolveDepKey(entry);
+				const dependents = next.get(depKey) ?? /* @__PURE__ */ new Set();
+				dependents.add(slotKey);
+				next.set(depKey, dependents);
+			}
+		}
+		this.dependentsIndex = next;
+	}
+	getAffectedKeys(changedKeys) {
+		const affected = /* @__PURE__ */ new Set();
+		const visit = (key) => {
+			if (affected.has(key)) return;
+			affected.add(key);
+			for (const dependent of this.dependentsIndex.get(key) ?? []) visit(dependent);
+		};
+		for (const key of changedKeys) visit(key);
+		return [...affected].filter((key) => this.definitions.has(key));
+	}
+	listMissingDeps(ServiceClass) {
+		const deps = ServiceClass.deps ?? {};
+		const missing = [];
+		for (const entry of Object.values(deps)) {
+			const key = resolveDepKey(entry);
+			const slot = this.resolveDepSlot(key);
+			if (!slot || slot.status !== "ready" || !slot.instance) missing.push(key);
+		}
+		return missing;
+	}
+	ensureSlot(key, ServiceClass) {
+		const existing = this.slots.get(key);
+		if (existing) return existing;
+		const slot = {
+			error: null,
+			instance: null,
+			ServiceClass,
+			status: "blocked",
+			pluginDir: null
+		};
+		this.slots.set(key, slot);
+		return slot;
+	}
+	async teardownService(key, options = {}) {
+		const slot = this.slots.get(key);
+		if (!slot) return;
+		const instance = slot.instance;
+		slot.instance = null;
+		slot.status = "blocked";
+		slot.error = null;
+		if (instance) {
+			const reason = options.reason ?? "shutdown";
+			const timeoutMs = readShutdownTimeoutMs();
+			const cleanup = instance.__cleanupAllSetups(reason);
+			let timer = null;
+			const timeout = new Promise((resolve) => {
+				timer = setTimeout(() => {
+					console.error(`[hot] ${key} ${reason} cleanup timed out after ${timeoutMs}ms; forcing teardown`);
+					resolve();
+				}, timeoutMs);
+				timer.unref?.();
+			});
+			try {
+				await Promise.race([cleanup, timeout]);
+			} finally {
+				if (timer) clearTimeout(timer);
+			}
+		}
+		if (options.removeSlot) this.slots.delete(key);
+	}
+	async unregister(key, token) {
+		if (this.registrationTokens.get(key) !== token) return;
+		this.registrationTokens.delete(key);
+		this.definitions.delete(key);
+		await this.teardownService(key, { removeSlot: true });
+		this.rebuildDependentsIndex();
+		this.fireSubscribers(key);
+		await this.scheduleReconcile([key]);
+	}
+	async scheduleReconcile(keys) {
+		for (const key of keys) this.dirtyKeys.add(key);
+		if (this.draining) return this.draining;
+		this.draining = (async () => {
+			try {
+				while (this.dirtyKeys.size > 0) {
+					const batch = [...this.dirtyKeys];
+					this.dirtyKeys.clear();
+					await this.reconcileBatch(batch);
+				}
+			} catch (error) {
+				this.drainError = error;
+				console.error("[hot] runtime reconcile failed:", error);
+			} finally {
+				this.draining = null;
+				if (this.dirtyKeys.size > 0) this.scheduleReconcile([]);
+			}
+		})();
+		return this.draining;
+	}
+	async reconcileBatch(changedKeys) {
+		const affectedKeys = this.getAffectedKeys(changedKeys);
+		if (affectedKeys.length === 0) return;
+		const affected = /* @__PURE__ */ new Map();
+		for (const key of affectedKeys) {
+			const ServiceClass = this.definitions.get(key);
+			if (ServiceClass) affected.set(key, ServiceClass);
+		}
+		const levels = this.topologicalLevels(affected);
+		const wasReady = /* @__PURE__ */ new Set();
+		for (const key of affectedKeys) if (this.slots.get(key)?.status === "ready") wasReady.add(key);
+		for (const level of [...levels].reverse()) await Promise.all(level.map((key) => this.teardownService(key, { reason: "reload" })));
+		for (const level of levels) await Promise.all(level.map((key) => this.reconcileKey(key, wasReady)));
+		for (const key of affectedKeys) this.fireSubscribers(key);
+		if (affectedKeys.length > 0) for (const cb of this.onReconciledCallbacks) try {
+			cb(affectedKeys);
+		} catch (e) {
+			console.error("[hot] onReconciled callback failed:", e);
+		}
+	}
+	async reconcileKey(key, wasReady) {
+		const ServiceClass = this.definitions.get(key);
+		if (!ServiceClass) return;
+		const slot = this.ensureSlot(key, ServiceClass);
+		slot.ServiceClass = ServiceClass;
+		const missingDeps = this.listMissingDeps(ServiceClass);
+		if (missingDeps.length > 0) {
+			await this.teardownService(key, { reason: "reload" });
+			if (wasReady.has(key)) console.log(`[hot] ${key} waiting on: ${missingDeps.join(", ")}`);
+			return;
+		}
+		const instance = new ServiceClass();
+		slot.instance = instance;
+		slot.status = "evaluating";
+		slot.error = null;
+		try {
+			this.injectCtx(instance, ServiceClass);
+			await instance.evaluate();
+			slot.status = "ready";
+		} catch (e) {
+			slot.status = "failed";
+			slot.error = e;
+			console.error(`[hot] ${key} failed to evaluate:`, e);
+		}
+	}
+	topologicalLevels(services) {
+		const keys = new Set(services.keys());
+		const inDegree = /* @__PURE__ */ new Map();
+		const dependents = /* @__PURE__ */ new Map();
+		for (const key of keys) {
+			inDegree.set(key, 0);
+			dependents.set(key, []);
+		}
+		for (const [slotKey, ServiceClass] of services) {
+			const deps = ServiceClass.deps ?? {};
+			let degree = 0;
+			for (const entry of Object.values(deps)) {
+				const depKey = resolveDepKey(entry);
+				if (keys.has(depKey)) {
+					degree++;
+					dependents.get(depKey).push(slotKey);
+				}
+			}
+			inDegree.set(slotKey, degree);
+		}
+		const levels = [];
+		let queue = [...keys].filter((k) => inDegree.get(k) === 0);
+		while (queue.length > 0) {
+			levels.push(queue);
+			const next = [];
+			for (const key of queue) for (const dep of dependents.get(key)) {
+				const d = inDegree.get(dep) - 1;
+				inDegree.set(dep, d);
+				if (d === 0) next.push(dep);
+			}
+			queue = next;
+		}
+		const resolved = levels.flat();
+		if (resolved.length !== keys.size) {
+			const missing = [...keys].filter((k) => !resolved.includes(k));
+			throw new Error(`Circular dependency detected involving: ${missing.join(", ")}`);
+		}
+		return levels;
+	}
+};
+/**
+* fixme: i don't think these commments make sense
+*/
+/**
+* Devtools-only handles, attached to the global so they aren't part of the
+* public `ServiceRuntime` autocomplete surface. Same shape React DevTools
+* uses (`__REACT_DEVTOOLS_GLOBAL_HOOK__`): user code reading
+* `runtime.<...>` never lands on these methods; you only find them if you
+* specifically type `globalThis.__zenbu_dev__`. Kept here (next to the
+* runtime that owns the state) because the hook reaches into private
+* implementation details — `scheduleReconcile` stays `private` on the
+* class; the cast lives inside the encapsulation boundary.
+*/
+function installDevHook(rt) {
+	const internals = rt;
+	globalThis.__zenbu_dev__ = { reloadService: async (key) => {
+		if (!internals.definitions.has(key)) throw new Error(`No service registered for key "${key}"`);
+		await internals.scheduleReconcile([key]);
+		await rt.whenIdle();
+	} };
+}
+const runtime = (() => {
+	const existing = globalThis.__zenbu_service_runtime__;
+	if (existing) {
+		Object.setPrototypeOf(existing, ServiceRuntime.prototype);
+		installDevHook(existing);
+		return existing;
+	}
+	const fresh = new ServiceRuntime();
+	globalThis.__zenbu_service_runtime__ = fresh;
+	installDevHook(fresh);
+	return fresh;
+})();
+function getPluginRegistry() {
+	const slot = globalThis;
+	if (!slot.__zenbu_plugin_registry__) {
+		slot.__zenbu_plugin_registry__ = {
+			plugins: /* @__PURE__ */ new Map(),
+			appEntrypoint: null,
+			splashPath: null,
+			subscribers: /* @__PURE__ */ new Set()
+		};
+		seedCorePlugin(slot.__zenbu_plugin_registry__);
+	} else if (!slot.__zenbu_plugin_registry__.subscribers) slot.__zenbu_plugin_registry__.subscribers = /* @__PURE__ */ new Set();
+	return slot.__zenbu_plugin_registry__;
+}
+/**
+* Walk up from this module's location until we hit the `@zenbujs/core`
+* package.json. Cached at first call. Same trick as `findCorePackageRoot`
+* in `services/db.ts`; consolidated here so the runtime can register
+* itself without round-tripping through a service file.
+*/
+let cachedCorePluginDir = null;
+function getCorePluginDir() {
+	if (cachedCorePluginDir) return cachedCorePluginDir;
+	const here = path.dirname(fileURLToPath(import.meta.url));
+	let dir = here;
+	while (dir !== path.dirname(dir)) {
+		const pkgPath = path.join(dir, "package.json");
+		try {
+			if (JSON.parse(fs.readFileSync(pkgPath, "utf8"))?.name === "@zenbujs/core") {
+				cachedCorePluginDir = dir;
+				return dir;
+			}
+		} catch {}
+		dir = path.dirname(dir);
+	}
+	cachedCorePluginDir = path.resolve(here, "..");
+	return cachedCorePluginDir;
+}
+function seedCorePlugin(reg) {
+	if (reg.plugins.has("core")) return;
+	reg.plugins.set(CORE_PLUGIN_NAME, {
+		name: CORE_PLUGIN_NAME,
+		dir: getCorePluginDir(),
+		services: []
+	});
+}
+/**
+* Resolve the plugin namespace that owns a given service slot's
+* `pluginDir`. Core services (and anything not declared inside a plugin)
+* fall back to `"core"`. Used by `buildRouter` to nest the runtime
+* router by plugin name.
+*/
+function pluginNameForDir(dir) {
+	if (!dir) return CORE_PLUGIN_NAME;
+	for (const plugin of getPluginRegistry().plugins.values()) if (plugin.dir === dir) return plugin.name;
+	return CORE_PLUGIN_NAME;
+}
+function snapshotConfig(reg) {
+	return {
+		plugins: [...reg.plugins.values()],
+		appEntrypoint: reg.appEntrypoint,
+		splashPath: reg.splashPath
+	};
+}
+function notifySubscribers(reg) {
+	if (reg.subscribers.size === 0) return;
+	const snapshot = snapshotConfig(reg);
+	for (const cb of reg.subscribers) try {
+		cb(snapshot);
+	} catch (err) {
+		console.error("[zenbu config subscriber] threw:", err);
+	}
+}
+/**
+* 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.
+*/
+function registerPlugin(record) {
+	const reg = getPluginRegistry();
+	if (record.name === "core") {
+		console.warn(`[zenbu] plugin name "${CORE_PLUGIN_NAME}" is reserved for the core package; ignoring registerPlugin`);
+		return;
+	}
+	reg.plugins.set(record.name, record);
+	notifySubscribers(reg);
+}
+/**
+* Drop a plugin from the registry. Used when the loader regenerates the
+* barrel and needs to clear stale entries.
+*/
+function unregisterPlugin(name) {
+	const reg = getPluginRegistry();
+	if (!reg.plugins.delete(name)) return;
+	notifySubscribers(reg);
+}
+/**
+* Replace the entire plugin set in one shot. The loader uses this on every
+* barrel regeneration so removed plugins disappear cleanly. The synthetic
+* `core` plugin is always reseeded after the clear so user records cannot
+* accidentally evict it (and a user record named `"core"` is rejected so
+* the namespace stays unambiguous).
+*/
+function replacePlugins(records) {
+	const reg = getPluginRegistry();
+	reg.plugins.clear();
+	seedCorePlugin(reg);
+	for (const record of records) {
+		if (record.name === "core") {
+			console.warn(`[zenbu] plugin name "${CORE_PLUGIN_NAME}" is reserved for the core package; ignoring user plugin record`);
+			continue;
+		}
+		reg.plugins.set(record.name, record);
+	}
+	notifySubscribers(reg);
+}
+function getPlugins() {
+	return [...getPluginRegistry().plugins.values()];
+}
+/**
+* Find the plugin whose `dir` contains the file at `metaUrl`. The plugin
+* registry (populated by the loader-emitted barrel before any service
+* file imports) is the source of truth — no filesystem walking. Returns
+* the plugin's absolute directory, or `null` if the file lives outside
+* every registered plugin (the framework's own `@zenbujs/core/services/*`
+* files take this branch and end up with `slot.pluginDir = null`).
+*
+* Picks the deepest matching plugin so a nested workspace plugin wins
+* over its parent.
+*/
+function findOwningPluginDir(metaUrl) {
+	let file;
+	try {
+		file = fileURLToPath(metaUrl);
+	} catch {
+		return null;
+	}
+	let bestMatch = null;
+	for (const plugin of getPluginRegistry().plugins.values()) {
+		const rel = path.relative(plugin.dir, file);
+		if (rel.startsWith("..") || path.isAbsolute(rel)) continue;
+		const depth = plugin.dir.split(path.sep).length;
+		if (!bestMatch || depth > bestMatch.depth) bestMatch = {
+			dir: plugin.dir,
+			depth
+		};
+	}
+	return bestMatch?.dir ?? null;
+}
+function getPlugin(name) {
+	return getPluginRegistry().plugins.get(name);
+}
+/**
+* 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()`.
+*/
+function registerAppEntrypoint(rendererDir, splashPath) {
+	const reg = getPluginRegistry();
+	reg.appEntrypoint = rendererDir;
+	reg.splashPath = splashPath;
+	notifySubscribers(reg);
+}
+function getAppEntrypoint() {
+	return getPluginRegistry().appEntrypoint;
+}
+function getSplashPath() {
+	return getPluginRegistry().splashPath;
+}
+/**
+* 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.
+*/
+function getConfig() {
+	return snapshotConfig(getPluginRegistry());
+}
+/**
+* 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.
+*/
+function subscribeConfig(callback) {
+	const reg = getPluginRegistry();
+	reg.subscribers.add(callback);
+	try {
+		callback(snapshotConfig(reg));
+	} catch (err) {
+		console.error("[zenbu config subscriber] initial fire threw:", err);
+	}
+	return () => {
+		reg.subscribers.delete(callback);
+	};
+}
+//#endregion
+export { getAllAdviceTypes as _, getConfig as a, getContentScripts as b, getSplashPath as c, replacePlugins as d, runtime as f, getAdvice as g, advice_config_exports as h, getAppEntrypoint as i, registerAppEntrypoint as l, unregisterPlugin as m, Service as n, getPlugin as o, subscribeConfig as p, ServiceRuntime as r, getPlugins as s, CORE_PLUGIN_NAME as t, registerPlugin as u, getAllContentScriptPaths as v, getAllTypes as y };