@zenbujs/core 0.0.1

package/dist/renderer-host-DpvBPTHJ.mjs

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

package/dist/rpc-BwwQK6hD.mjs

@@ -0,0 +1,71 @@
+import { i as runtime, t as Service } from "./runtime-DUFKDIe4.mjs";
+import { t as createLogger } from "./log-CyKv8hQg.mjs";
+import { o as HttpService } from "./renderer-host-Bg8QdeeH.mjs";
+import { n as createRpcRouter, r as createServer } from "./src-pELM4_iH.mjs";
+//#region src/services/rpc.ts
+const log = createLogger("rpc");
+var RpcService = class extends Service {
+	static key = "rpc";
+	static deps = { http: HttpService };
+	_emit = null;
+	get emit() {
+		if (!this._emit) throw new Error("RpcService not yet evaluated");
+		return this._emit;
+	}
+	evaluate() {
+		const { http } = this.ctx;
+		this.setup("rpc-wiring", () => {
+			const rpcRouter = createRpcRouter();
+			const rpcServer = createServer({
+				router: () => runtime.buildRouter(),
+				version: "0",
+				send: rpcRouter.send
+			});
+			this._emit = rpcServer.emit;
+			const wsRpcConnections = /* @__PURE__ */ new Map();
+			const onConnected = (id, ws) => {
+				const rpcConn = rpcRouter.connection({
+					send: (data) => {
+						if (ws.readyState === ws.OPEN) ws.send(JSON.stringify({
+							ch: "rpc",
+							data
+						}));
+					},
+					postMessage: rpcServer.postMessage,
+					removeClient: rpcServer.removeClient
+				});
+				wsRpcConnections.set(id, {
+					rpcConn,
+					ws
+				});
+				ws.on("message", (raw) => {
+					const msg = JSON.parse(String(raw));
+					if (msg.ch === "rpc") rpcConn.receive(msg.data);
+				});
+			};
+			const onDisconnected = (id) => {
+				const entry = wsRpcConnections.get(id);
+				if (entry) {
+					entry.rpcConn.close();
+					wsRpcConnections.delete(id);
+				}
+			};
+			const unsubConnected = http.onConnected(onConnected);
+			const unsubDisconnected = http.onDisconnected(onDisconnected);
+			return () => {
+				this._emit = null;
+				unsubConnected();
+				unsubDisconnected();
+				for (const { rpcConn, ws } of wsRpcConnections.values()) {
+					rpcConn.close();
+					ws.close();
+				}
+				wsRpcConnections.clear();
+			};
+		});
+		log.verbose("service ready");
+	}
+};
+runtime.register(RpcService, import.meta);
+//#endregion
+export { RpcService as t };

package/dist/rpc-CqitnyR4.mjs

@@ -0,0 +1,2 @@
+import "./rpc-BwwQK6hD.mjs";
+export {};

package/dist/rpc.d.mts

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

package/dist/rpc.mjs

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

package/dist/runtime-CjqDr8Yf.d.mts

@@ -0,0 +1,109 @@
+//#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: typeof Service;
+  status: "blocked" | "evaluating" | "ready" | "failed";
+}
+type AnyServiceClass = abstract new (...args: any[]) => Service;
+type DepRef = AnyServiceClass | string;
+type OptionalDep<R extends DepRef = DepRef> = {
+  __optional: true;
+  ref: R;
+};
+type DepEntry = DepRef | OptionalDep;
+type DepInstance<D> = D extends OptionalDep<infer R> ? R extends AnyServiceClass ? InstanceType<R> | undefined : unknown : D extends AnyServiceClass ? InstanceType<D> : unknown;
+type ResolveCtx<TDeps> = { [K in keyof TDeps]: DepInstance<TDeps[K]> };
+declare function optional<R extends DepRef>(ref: R): OptionalDep<R>;
+declare abstract class Service {
+  static key: string;
+  static deps: Record<string, DepEntry>;
+  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 a Service base class with typed deps. The returned class has
+ * `static deps = <your map>` already set, and `this.ctx` is auto-typed
+ * from the dep classes — no `declare ctx` needed in the subclass.
+ *
+ *     export class WindowService extends serviceWithDeps({
+ *       baseWindow: BaseWindowService,
+ *       http: HttpService,
+ *     }) {
+ *       static key = "window"
+ *       evaluate() {
+ *         this.ctx.baseWindow  // BaseWindowService
+ *         this.ctx.http        // HttpService
+ *       }
+ *     }
+ *
+ * `optional(SomeService)` is supported and produces `Instance | undefined`.
+ */
+declare function serviceWithDeps<TDeps extends Record<string, DepEntry>>(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>;
+}) & {
+  deps: Record<string, DepEntry>;
+  key: string;
+};
+declare class ServiceRuntime {
+  private definitions;
+  private dependentsIndex;
+  private dirtyKeys;
+  private drainError;
+  private draining;
+  private registrationTokens;
+  private slots;
+  private onReconciledCallbacks;
+  register(ServiceClass: typeof Service, importMeta?: ImportMeta | null): void;
+  getAllKeys(): string[];
+  getSlot(key: string): ServiceSlot | undefined;
+  whenIdle(): Promise<void>;
+  reloadAll(): Promise<void>;
+  shutdown(): Promise<void>;
+  get<T extends Service>(ref: {
+    key: string;
+  }): T;
+  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;
+//#endregion
+export { runtime as a, optional as i, Service as n, serviceWithDeps as o, ServiceRuntime as r, CleanupReason as t };

package/dist/runtime-DUFKDIe4.mjs

@@ -0,0 +1,409 @@
+//#region src/runtime.ts
+function optional(ref) {
+	return {
+		__optional: true,
+		ref
+	};
+}
+function resolveDep(entry) {
+	if (typeof entry === "string") return {
+		key: entry,
+		optional: false
+	};
+	if (typeof entry === "object" && entry !== null && "__optional" in entry) {
+		const ref = entry.ref;
+		return {
+			key: typeof ref === "string" ? ref : ref.key,
+			optional: true
+		};
+	}
+	return {
+		key: entry.key,
+		optional: false
+	};
+}
+var Service = class {
+	static key;
+	static deps;
+	ctx;
+	/** @internal */
+	__setupCleanups = /* @__PURE__ */ new Map();
+	evaluate() {}
+	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();
+	}
+};
+/**
+* Declare a Service base class with typed deps. The returned class has
+* `static deps = <your map>` already set, and `this.ctx` is auto-typed
+* from the dep classes — no `declare ctx` needed in the subclass.
+*
+*     export class WindowService extends serviceWithDeps({
+*       baseWindow: BaseWindowService,
+*       http: HttpService,
+*     }) {
+*       static key = "window"
+*       evaluate() {
+*         this.ctx.baseWindow  // BaseWindowService
+*         this.ctx.http        // HttpService
+*       }
+*     }
+*
+* `optional(SomeService)` is supported and produces `Instance | undefined`.
+*/
+function serviceWithDeps(deps) {
+	class ServiceWithDeps extends Service {
+		static deps = deps;
+	}
+	return ServiceWithDeps;
+}
+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 = [];
+	register(ServiceClass, importMeta) {
+		const hot = importMeta?.hot ?? null;
+		const baseKey = ServiceClass.key;
+		if (!baseKey) throw new Error("Service must have a static key property");
+		const slotKey = baseKey;
+		this.definitions.set(slotKey, ServiceClass);
+		const slot = this.slots.get(slotKey);
+		if (slot) slot.ServiceClass = ServiceClass;
+		else this.slots.set(slotKey, {
+			error: null,
+			instance: null,
+			ServiceClass,
+			status: "blocked"
+		});
+		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();
+	}
+	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();
+	}
+	get(ref) {
+		const slot = this.slots.get(ref.key);
+		if (!slot || slot.status !== "ready" || !slot.instance) throw new Error(`Service "${ref.key}" not ready. Is it registered and evaluated?`);
+		return slot.instance;
+	}
+	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) router[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, optional: isOptional } = resolveDep(entry);
+			const slot = this.resolveDepSlot(key);
+			if (!slot || slot.status !== "ready" || !slot.instance) {
+				if (isOptional) {
+					ctx[name] = void 0;
+					continue;
+				}
+				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 { key: depKey } = resolveDep(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, optional: isOptional } = resolveDep(entry);
+			if (isOptional) continue;
+			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"
+		};
+		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) await instance.__cleanupAllSetups(options.reason ?? "shutdown");
+		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();
+		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);
+		for (const level of [...levels].reverse()) await Promise.all(level.map(async (key) => {
+			const slot = this.slots.get(key);
+			if (slot?.instance) await slot.instance.__cleanupAllSetups("reload");
+		}));
+		for (const level of levels) await Promise.all(level.map((key) => this.reconcileKey(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) {
+		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) {
+			const shouldLog = slot.instance !== null || slot.status !== "blocked";
+			await this.teardownService(key, { reason: "reload" });
+			if (shouldLog) console.log(`[hot] ${key} waiting on: ${missingDeps.join(", ")}`);
+			return;
+		}
+		let instance = slot.instance;
+		if (!instance) {
+			instance = new ServiceClass();
+			slot.instance = instance;
+		} else Object.setPrototypeOf(instance, ServiceClass.prototype);
+		slot.status = "evaluating";
+		slot.error = null;
+		try {
+			await instance.__cleanupAllSetups("reload");
+			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 { key: depKey, optional: isOptional } = resolveDep(entry);
+				if (keys.has(depKey)) {
+					degree++;
+					dependents.get(depKey).push(slotKey);
+				} else if (isOptional) continue;
+			}
+			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;
+	}
+};
+/**
+* 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;
+})();
+//#endregion
+export { serviceWithDeps as a, runtime as i, ServiceRuntime as n, optional as r, Service as t };

package/dist/runtime.d.mts

@@ -0,0 +1,2 @@
+import { a as runtime, i as optional, n as Service, o as serviceWithDeps, r as ServiceRuntime, t as CleanupReason } from "./runtime-CjqDr8Yf.mjs";
+export { CleanupReason, Service, ServiceRuntime, optional, runtime, serviceWithDeps };

package/dist/runtime.mjs

@@ -0,0 +1,2 @@
+import { a as serviceWithDeps, i as runtime, n as ServiceRuntime, r as optional, t as Service } from "./runtime-DUFKDIe4.mjs";
+export { Service, ServiceRuntime, optional, runtime, serviceWithDeps };