@zenbujs/core 0.0.1

package/dist/react.mjs

@@ -0,0 +1,291 @@
+import { i as dbStringify, r as dbParse, t as connectReplica } from "./transport-BMSzG2-F.mjs";
+import { t as connectRpc } from "./src-pELM4_iH.mjs";
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+//#region ../kyju/src/v2/react/index.ts
+function createKyjuReact() {
+	const KyjuContext = createContext(null);
+	function KyjuProvider({ client, replica, children }) {
+		const value = useMemo(() => ({
+			client,
+			replica
+		}), [client, replica]);
+		return createElement(KyjuContext.Provider, { value }, children);
+	}
+	function useKyjuContext() {
+		const ctx = useContext(KyjuContext);
+		if (!ctx) throw new Error("useDb/useCollection must be used inside KyjuProvider");
+		return ctx;
+	}
+	function useDb(selector, isEqual) {
+		const { replica } = useKyjuContext();
+		const selectorRef = useRef(selector);
+		selectorRef.current = selector;
+		const isEqualRef = useRef(isEqual);
+		isEqualRef.current = isEqual;
+		const cacheRef = useRef(null);
+		return useSyncExternalStore(useCallback((cb) => replica.subscribe(() => cb()), [replica]), useCallback(() => {
+			const state = replica.getState();
+			if (state.kind !== "connected") return void 0;
+			const root = state.root;
+			const sel = selectorRef.current;
+			if (!sel) return root;
+			const next = sel(root);
+			const cache = cacheRef.current;
+			if (cache != null) {
+				if ((isEqualRef.current ?? shallowEqual)(cache.output, next)) return cache.output;
+			}
+			cacheRef.current = { output: next };
+			return next;
+		}, [replica]));
+	}
+	function useCollection(ref) {
+		const { replica } = useKyjuContext();
+		const collectionId = ref?.collectionId || null;
+		const [state, setState] = useState({
+			items: [],
+			totalCount: 0,
+			collection: null
+		});
+		useEffect(() => {
+			if (!collectionId) return;
+			const onData = (data) => {
+				setState({
+					items: data.collection.items,
+					totalCount: data.collection.totalCount,
+					collection: data.collection
+				});
+			};
+			replica.onCollectionConcat(collectionId, onData);
+			replica.postMessage({
+				kind: "subscribe-collection",
+				collectionId
+			}).then(() => {
+				const s = replica.getState();
+				if (s.kind === "connected") {
+					const col = s.collections.find((c) => c.id === collectionId);
+					if (col) onData({
+						collection: col,
+						newItems: []
+					});
+				}
+			});
+			return () => {
+				replica.offCollectionConcat(collectionId, onData);
+				replica.postMessage({
+					kind: "unsubscribe-collection",
+					collectionId
+				}).catch(() => {});
+			};
+		}, [collectionId, replica]);
+		const concat = useMemo(() => {
+			if (!collectionId) return (_items) => {};
+			return (items) => {
+				replica.postMessage({
+					kind: "write",
+					op: {
+						type: "collection.concat",
+						collectionId,
+						data: items
+					}
+				});
+			};
+		}, [collectionId, replica]);
+		return useMemo(() => ({
+			...state,
+			concat
+		}), [state, concat]);
+	}
+	return {
+		KyjuProvider,
+		useDb,
+		useCollection
+	};
+}
+function shallowEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+		return true;
+	}
+	if (Array.isArray(b)) return false;
+	const ao = a;
+	const bo = b;
+	const ka = Object.keys(ao);
+	const kb = Object.keys(bo);
+	if (ka.length !== kb.length) return false;
+	for (const k of ka) {
+		if (!Object.prototype.hasOwnProperty.call(bo, k)) return false;
+		if (!Object.is(ao[k], bo[k])) return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/react.ts
+/**
+* Public renderer-side surface for plugin authors. Wraps the websocket
+* lifecycle, RPC client, replica DB connection, and event subscription
+* behind a single `<ZenbuProvider>` plus hooks.
+*
+* DB hooks (`useDb`, `useCollection`) are implemented in `@zenbu/kyju/react`
+* and composed here via `KyjuProvider` mounted inside `ZenbuProvider`.
+* Core only adds the websocket lifecycle (RPC/events) and the
+* `ZenbuRegister`-driven type narrowing so call sites never need a generic.
+*/
+const ConnectionContext = createContext(null);
+const kyjuReact = createKyjuReact();
+function useDb(selector, isEqual) {
+	return kyjuReact.useDb(selector, isEqual);
+}
+const useCollection = kyjuReact.useCollection;
+function ZenbuProvider({ wsUrl, fallback, errorFallback, children }) {
+	const [state, setState] = useState({ status: "connecting" });
+	const cleanupRef = useRef(null);
+	const retriesRef = useRef(0);
+	useEffect(() => {
+		let cancelled = false;
+		let reconnectTimer = null;
+		const resolvedUrl = (() => {
+			if (wsUrl) return wsUrl;
+			const params = new URLSearchParams(window.location.search);
+			const port = params.get("wsPort");
+			const token = params.get("wsToken");
+			if (!port) return { error: "Missing ?wsPort= in URL" };
+			if (!token) return { error: "Missing ?wsToken= in URL" };
+			return `ws://127.0.0.1:${port}?token=${encodeURIComponent(token)}`;
+		})();
+		if (typeof resolvedUrl !== "string") {
+			setState({
+				status: "error",
+				error: resolvedUrl.error
+			});
+			return;
+		}
+		function connect() {
+			if (cancelled) return;
+			setState({ status: "connecting" });
+			cleanupRef.current = null;
+			const ws = new WebSocket(resolvedUrl);
+			ws.onopen = async () => {
+				try {
+					retriesRef.current = 0;
+					const { server: rpc, events, disconnect: disconnectRpc } = await connectRpc({
+						version: "0",
+						send: (data) => {
+							if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({
+								ch: "rpc",
+								data
+							}));
+						},
+						subscribe: (cb) => {
+							const handler = (e) => {
+								const msg = JSON.parse(e.data);
+								if (msg.ch === "rpc") cb(msg.data);
+							};
+							ws.addEventListener("message", handler);
+							return () => ws.removeEventListener("message", handler);
+						}
+					});
+					const { client: db, replica, disconnect: disconnectDb } = await connectReplica({
+						send: (event) => {
+							if (ws.readyState === WebSocket.OPEN) ws.send(dbStringify({
+								ch: "db",
+								data: event
+							}));
+						},
+						subscribe: (cb) => {
+							const handler = (e) => {
+								const msg = dbParse(e.data);
+								if (msg.ch === "db") cb(msg.data);
+							};
+							ws.addEventListener("message", handler);
+							return () => ws.removeEventListener("message", handler);
+						}
+					});
+					if (cancelled) {
+						await disconnectDb();
+						disconnectRpc();
+						ws.close();
+						return;
+					}
+					const viewMatch = window.location.pathname.match(/^\/views\/([^/]+)\//);
+					const viewScope = viewMatch ? viewMatch[1] : null;
+					let unsubReload = null;
+					if (viewScope) {
+						const adviceReload = events?.advice?.reload;
+						if (adviceReload?.subscribe) unsubReload = adviceReload.subscribe((data) => {
+							if (data?.scope === viewScope) location.reload();
+						});
+					}
+					cleanupRef.current = () => {
+						unsubReload?.();
+						disconnectDb();
+						disconnectRpc();
+						ws.close();
+					};
+					setState({
+						status: "connected",
+						conn: {
+							rpc,
+							events,
+							db,
+							replica
+						}
+					});
+				} catch (err) {
+					if (!cancelled) {
+						ws.close();
+						scheduleReconnect();
+					}
+				}
+			};
+			ws.onerror = () => {};
+			ws.onclose = () => {
+				if (!cancelled) {
+					cleanupRef.current?.();
+					cleanupRef.current = null;
+					scheduleReconnect();
+				}
+			};
+		}
+		function scheduleReconnect() {
+			if (cancelled) return;
+			const delay = Math.min(300 * Math.pow(2, retriesRef.current), 3e3);
+			retriesRef.current++;
+			setState({ status: "connecting" });
+			reconnectTimer = setTimeout(connect, delay);
+		}
+		connect();
+		return () => {
+			cancelled = true;
+			if (reconnectTimer) clearTimeout(reconnectTimer);
+			cleanupRef.current?.();
+			cleanupRef.current = null;
+		};
+	}, [wsUrl]);
+	if (state.status === "connecting") return createElement("span", { "data-zenbu-connecting": true }, fallback ?? null);
+	if (state.status === "error") return createElement("span", { "data-zenbu-error": true }, errorFallback ? errorFallback(state.error) : null);
+	return createElement(ConnectionContext.Provider, { value: state }, createElement(kyjuReact.KyjuProvider, {
+		client: state.conn.db,
+		replica: state.conn.replica,
+		children
+	}));
+}
+function useConnection() {
+	const state = useContext(ConnectionContext);
+	if (!state) throw new Error("useDb/useRpc/useEvents must be used inside <ZenbuProvider>");
+	if (state.status !== "connected") throw new Error(`Zenbu connection is not ready (status: ${state.status}). Render a <ZenbuProvider fallback={...}> around your hooks.`);
+	return state.conn;
+}
+function useRpc() {
+	return useConnection().rpc;
+}
+function useDbClient() {
+	return useConnection().db;
+}
+function useEvents() {
+	return useConnection().events;
+}
+//#endregion
+export { ZenbuProvider, useCollection, useDb, useDbClient, useEvents, useRpc };

package/dist/registry-Dh_e7HU1.d.mts

@@ -0,0 +1,61 @@
+import { n as SchemaRoot } from "./schema-DMoSkwUx.mjs";
+
+//#region src/registry.d.ts
+type CoreEvents = {
+  advice: {
+    reload: {
+      scope: string;
+    };
+  };
+};
+type Events = CoreEvents;
+type CoreDbSections = {
+  core: SchemaRoot;
+};
+type CorePreloads = {};
+type CoreServiceRouter = {};
+/**
+ * Module-augmentation point for plugin authors. `zen link` generates
+ * `<app>/types/zenbu-register.ts` which declares:
+ *
+ *   declare module "@zenbujs/core/registry" {
+ *     interface ZenbuRegister {
+ *       db: DbRoot
+ *       rpc: ServiceRouter
+ *       events: PluginEvents
+ *     }
+ *   }
+ *
+ * Server services (`DbService.client`, `RpcService.emit`) and renderer hooks
+ * (`useDb`, `useRpc`, `useEvents`) all read their types from this single
+ * registry, so the user's plugin types flow everywhere automatically.
+ *
+ * Mirrors the pattern TanStack Router uses for `Register`.
+ */
+interface ZenbuRegister {}
+/**
+ * Resolve the DB-root type from `ZenbuRegister["db"]`, falling back to a
+ * core-only root when no augmentation has been declared (e.g. a plugin that
+ * only emits events / RPC and doesn't define its own DB sections).
+ */
+type ResolvedDbRoot = ZenbuRegister extends {
+  db: infer T;
+} ? T : {
+  plugin: CoreDbSections;
+};
+/**
+ * Resolve the RPC router type from `ZenbuRegister["rpc"]`, falling back to
+ * the core router when no augmentation has been declared.
+ */
+type ResolvedServiceRouter = ZenbuRegister extends {
+  rpc: infer T;
+} ? T : CoreServiceRouter;
+/**
+ * Resolve the events tree from `ZenbuRegister["events"]`, falling back to
+ * `CoreEvents` when no augmentation has been declared.
+ */
+type ResolvedEvents = ZenbuRegister extends {
+  events: infer T;
+} ? T : CoreEvents;
+//#endregion
+export { Events as a, ResolvedServiceRouter as c, CoreServiceRouter as i, ZenbuRegister as l, CoreEvents as n, ResolvedDbRoot as o, CorePreloads as r, ResolvedEvents as s, CoreDbSections as t };

package/dist/registry.d.mts

@@ -0,0 +1,2 @@
+import { a as Events, c as ResolvedServiceRouter, i as CoreServiceRouter, l as ZenbuRegister, n as CoreEvents, o as ResolvedDbRoot, r as CorePreloads, s as ResolvedEvents, t as CoreDbSections } from "./registry-Dh_e7HU1.mjs";
+export { CoreDbSections, CoreEvents, CorePreloads, CoreServiceRouter, Events, ResolvedDbRoot, ResolvedEvents, ResolvedServiceRouter, ZenbuRegister };

package/dist/registry.mjs

@@ -0,0 +1 @@
+export {};

package/dist/reloader-BCkLjDhS.mjs

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

package/dist/reloader-lLAJ3lqg.mjs

@@ -0,0 +1,164 @@
+import { i as runtime, t as Service } from "./runtime-DUFKDIe4.mjs";
+import { t as createLogger } from "./log-CyKv8hQg.mjs";
+import { a as zenbuVitePlugins } from "./vite-plugins-Bh3SCOw-.mjs";
+import os from "node:os";
+import path, { resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { createServer } from "vite";
+import { access, mkdir, readdir } from "node:fs/promises";
+import { createServer as createServer$1 } from "node:net";
+//#region src/shared/paths.ts
+const ZENBU_HOME = path.join(os.homedir(), ".zenbu");
+const INTERNAL_DIR = path.join(ZENBU_HOME, ".internal");
+path.join(INTERNAL_DIR, "runtime.json");
+const DB_CONFIG_JSON = path.join(INTERNAL_DIR, "db.json");
+path.join(INTERNAL_DIR, "plugin-setup-state.json");
+//#endregion
+//#region src/services/reloader.ts
+const log = createLogger("reloader");
+function safeCacheSegment(value) {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "renderer";
+}
+function resolveRendererCacheDir(options) {
+	const hash = createHash("sha256").update(options.id).update("\0").update(resolve(options.root)).update("\0").update(options.configFile ? resolve(options.configFile) : "no-config").digest("hex").slice(0, 12);
+	return resolve(INTERNAL_DIR, "vite-cache", `${safeCacheSegment(options.id)}-${hash}`);
+}
+async function fileExists(p) {
+	try {
+		await access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function rendererWarmupUrls(root) {
+	const urls = /* @__PURE__ */ new Set();
+	if (await fileExists(resolve(root, "main.tsx"))) urls.add("/main.tsx");
+	const viewsDir = resolve(root, "views");
+	try {
+		for (const entry of await readdir(viewsDir, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			if (await fileExists(resolve(viewsDir, entry.name, "main.tsx"))) urls.add(`/views/${entry.name}/main.tsx`);
+		}
+	} catch {}
+	return [...urls];
+}
+async function warmupRendererEntrypoints(server, root) {
+	try {
+		const urls = await rendererWarmupUrls(root);
+		await Promise.all(urls.map((url) => server.warmupRequest(url)));
+	} catch (e) {
+		log.warn("renderer warmup failed:", e);
+	}
+}
+function getEphemeralPort() {
+	return new Promise((resolve, reject) => {
+		const srv = createServer$1();
+		srv.listen(0, () => {
+			const { port } = srv.address();
+			srv.close(() => resolve(port));
+		});
+		srv.on("error", reject);
+	});
+}
+async function startRendererServer(options) {
+	let server;
+	const port = options.port || await getEphemeralPort();
+	const cacheDir = options.cacheDir ?? resolveRendererCacheDir(options);
+	await mkdir(cacheDir, { recursive: true });
+	const sharedConfig = {
+		cacheDir,
+		server: {
+			port,
+			strictPort: true,
+			hmr: {
+				protocol: "ws",
+				host: "localhost"
+			},
+			fs: { strict: false }
+		},
+		logLevel: "warn"
+	};
+	const frameworkPlugins = zenbuVitePlugins();
+	if (options.configFile) server = await createServer({
+		...sharedConfig,
+		root: options.root,
+		configFile: options.configFile,
+		plugins: [...frameworkPlugins, ...options.plugins ?? []]
+	});
+	else {
+		const plugins = [...frameworkPlugins, ...options.plugins ?? []];
+		if (options.reactPlugin) plugins.unshift(options.reactPlugin());
+		else try {
+			const react = await import("@vitejs/plugin-react");
+			plugins.unshift(react.default());
+		} catch {}
+		server = await createServer({
+			...sharedConfig,
+			root: options.root,
+			plugins,
+			resolve: options.resolve,
+			configFile: false
+		});
+	}
+	await server.listen();
+	const addr = server.httpServer?.address();
+	const assignedPort = typeof addr === "object" && addr ? addr.port : 0;
+	if (assignedPort) {
+		const hmr = server.config.server.hmr;
+		if (typeof hmr === "object") hmr.clientPort = assignedPort;
+	}
+	await warmupRendererEntrypoints(server, options.root);
+	return server;
+}
+var ReloaderService = class extends Service {
+	static key = "reloader";
+	static deps = {};
+	servers = /* @__PURE__ */ new Map();
+	async create(id, root, configFile) {
+		if (this.servers.has(id)) return this.servers.get(id);
+		const viteServer = await startRendererServer({
+			id,
+			root,
+			configFile: configFile ?? false,
+			port: 0
+		});
+		const address = viteServer.httpServer?.address();
+		const port = typeof address === "object" && address ? address.port : 5173;
+		const entry = {
+			id,
+			root,
+			url: `http://localhost:${port}`,
+			port,
+			viteServer
+		};
+		this.servers.set(id, entry);
+		log.verbose(`${id} ready at ${entry.url}`);
+		return entry;
+	}
+	get(id) {
+		return this.servers.get(id);
+	}
+	async remove(id) {
+		const entry = this.servers.get(id);
+		if (entry) {
+			await entry.viteServer.close();
+			this.servers.delete(id);
+		}
+	}
+	evaluate() {
+		this.setup("vite-cleanup", () => {
+			return async () => {
+				const entries = [...this.servers.values()];
+				this.servers.clear();
+				(await Promise.allSettled(entries.map((entry) => entry.viteServer.close()))).forEach((res, i) => {
+					if (res.status === "rejected") log.error(`viteServer.close failed for ${entries[i].id}:`, res.reason);
+				});
+			};
+		});
+		log.verbose(`service ready (${this.servers.size} servers)`);
+	}
+};
+runtime.register(ReloaderService, import.meta);
+//#endregion
+export { DB_CONFIG_JSON as n, INTERNAL_DIR as r, ReloaderService as t };