@zenbujs/core 0.0.4 → 0.0.8

package/dist/loaders/zenbu.mjs

@@ -1,16 +1,9 @@
-import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { execFileSync } from "node:child_process";
 //#region src/loaders/zenbu.ts
 const verbose = process.env.ZENBU_VERBOSE === "1";
-const { subscribe } = createRequire(import.meta.url)("@parcel/watcher");
-let registerWatcherClosable = () => {};
-try {
-	const pause = await import("@zenbujs/hmr/pause");
-	registerWatcherClosable = typeof pause.registerWatcherClosable === "function" ? pause.registerWatcherClosable : registerWatcherClosable;
-} catch {}
 const loaderName = "zenbu-loader";
 let tracePort = null;
 const stats = {
@@ -19,26 +12,24 @@ const stats = {
 	loadCount: 0,
 	loadMs: 0
 };
-const barrels = /* @__PURE__ */ new Map();
-const dirWatchers = /* @__PURE__ */ new Map();
 let resolvedPayload = null;
 let resolvedPluginSourceFiles = [];
 /**
-* Number of times we've materialized the plugin root since boot. The first
-* call uses the payload that setup-gate sent through `register()`'s `data`
-* channel; every subsequent call shells out to `resolve-config.mjs` to
-* re-evaluate `zenbu.config.ts` from scratch (so editing the config file
-* actually picks up new plugins / removed plugins / changed paths).
-*
-* We can't `await import()` from inside the loader (Node's ESM loader hooks
-* run in a worker thread and serialize on this same hook, deadlocking).
-* `execFileSync` blocks the loader for ~300ms per HMR cycle, which is fine.
+* Set of absolute service file paths derived from the resolved payload.
+* Used by the `file://` branch in `load()` to decide which user files
+* should have `runtime.register(...)` auto-injected. Refreshed alongside
+* `resolvedPayload` whenever the loader picks up a new config snapshot.
+*/
+let serviceFileSet = /* @__PURE__ */ new Set();
+/**
+* Number of times we've materialized the plugin root since boot. 
 */
 let pluginsRootInvocations = 0;
 function initialize(data) {
 	if (data?.payload) {
 		resolvedPayload = data.payload;
 		resolvedPluginSourceFiles = data.pluginSourceFiles ?? [];
+		serviceFileSet = collectServiceFiles(data.payload);
 	}
 	if (data?.tracePort) {
 		tracePort = data.tracePort;
@@ -67,56 +58,88 @@ function expandGlob(pattern) {
 	if (!fs.existsSync(dir)) return [];
 	return fs.readdirSync(dir).filter((file) => regex.test(file)).map((file) => path.resolve(dir, file));
 }
-function snapshotDir(dir, regex) {
-	if (!fs.existsSync(dir)) return /* @__PURE__ */ new Set();
-	try {
-		return new Set(fs.readdirSync(dir).filter((file) => regex.test(file)));
-	} catch {
-		return /* @__PURE__ */ new Set();
-	}
+function buildSource(imports) {
+	return imports.map((specifier) => `import ${JSON.stringify(specifier)}\n`).join("");
 }
-function handleDirEvent(dir, filename) {
-	for (const entry of barrels.values()) for (const glob of entry.globs) {
-		if (glob.dir !== dir) continue;
-		if (!glob.regex.test(filename)) continue;
-		const nextSnapshot = snapshotDir(dir, glob.regex);
-		if (!(nextSnapshot.size !== glob.snapshot.size || [...nextSnapshot].some((file) => !glob.snapshot.has(file)))) continue;
-		glob.snapshot = nextSnapshot;
-		try {
-			entry.hot?.invalidate?.();
-			if (verbose) console.log(`[zenbu-loader] invalidated barrel (${filename} added/removed in ${dir})`);
-		} catch (err) {
-			console.error("[zenbu-loader] invalidate failed:", err);
-		}
-		break;
-	}
+/**
+* Matches the canonical service declaration shape after the upstream HMR
+* loader (dynohot) has transformed the module. Dynohot strips the
+* `export` keyword and minifies the source, so the regex must not
+* require `export` and must tolerate a non-whitespace separator (e.g.
+* `;class Foo extends Service.create(...)`). The `\b` boundary still
+* rejects `subclass Foo` matches inside identifiers/comments.
+*
+*     export class FooService extends Service.create({ ... }) { ... }
+*     ;class FooService extends Service.create({...}) {...}        // post-dynohot
+*
+* `zen link` runs on the original on-disk source (pre-dynohot), so it
+* keeps the `export` requirement in `discoverServices` to avoid matching
+* non-exported helper classes.
+*/
+const SERVICE_CLASS_RE = /\bclass\s+(\w+)\s+extends\s+Service\.create\s*\(/g;
+/**
+* Decode the loader's `source` payload (which Node permits as string,
+* Buffer, ArrayBuffer, or any TypedArray) into a plain UTF-8 string.
+*/
+function decodeSource(source) {
+	if (typeof source === "string") return source;
+	if (source instanceof Uint8Array) return Buffer.from(source).toString("utf8");
+	if (source instanceof ArrayBuffer) return Buffer.from(source).toString("utf8");
+	return String(source);
 }
-function ensureDirWatcher(dir) {
-	if (dirWatchers.has(dir)) return;
-	if (!fs.existsSync(dir)) return;
-	let subscription = null;
-	let closed = false;
-	subscribe(dir, (err, events) => {
-		if (err) return;
-		for (const event of events) {
-			if (path.dirname(event.path) !== dir) continue;
-			handleDirEvent(dir, path.basename(event.path));
-		}
-	}).then((sub) => {
-		if (closed) sub.unsubscribe().catch(() => {});
-		else subscription = sub;
-	}).catch((err) => {
-		console.error(`[zenbu-loader] subscribe failed for ${dir}:`, err);
-	});
-	const closable = { close: () => {
-		closed = true;
-		if (subscription) return subscription.unsubscribe().catch(() => {});
-	} };
-	registerWatcherClosable(closable);
-	dirWatchers.set(dir, closable);
+/**
+* Tail-append a `runtime.register(<Class>, import.meta)` call to the
+* loader result so user service files don't have to carry the boilerplate.
+*
+* - Idempotent: if the source already contains `runtime.register(`
+*   (manual migration leftover, or a user choosing to register
+*   explicitly), we leave it untouched.
+* - Errors loudly when zero or multiple service classes are found, since
+*   the runtime's HMR model is "one slot per import.meta".
+* - The runtime singleton imported here resolves through the loader's
+*   own `@zenbujs/core` short-circuit in `resolve()`, so the registered
+*   class lands in the same registry the rest of the framework reads.
+*/
+function appendAutoRegister(downstream, filePath) {
+	if (!downstream || typeof downstream !== "object") return downstream;
+	const result = downstream;
+	if (result.format !== "module") return downstream;
+	if (result.source == null) return downstream;
+	const source = decodeSource(result.source);
+	if (/\bruntime\s*\.\s*register\s*\(/.test(source)) return {
+		...result,
+		source
+	};
+	SERVICE_CLASS_RE.lastIndex = 0;
+	const matches = [...source.matchAll(SERVICE_CLASS_RE)];
+	if (matches.length === 0) throw new Error(`[zenbu-loader] auto-register: no \`class <Name> extends Service.create({ ... })\` found in ${filePath}.\n         Either rewrite the class to use Service.create or add an explicit \`runtime.register(<Class>, import.meta)\`.`);
+	if (matches.length > 1) {
+		const names = matches.map((m) => m[1]).join(", ");
+		throw new Error(`[zenbu-loader] auto-register: ${matches.length} service classes (${names}) in ${filePath}.\n         The HMR model is one service per file; split into separate files.`);
+	}
+	const tail = `\n;import { runtime as __zenbu_runtime__ } from "@zenbujs/core/runtime";\n__zenbu_runtime__.register(${matches[0][1]}, import.meta);\n`;
+	return {
+		...result,
+		source: source + tail
+	};
 }
-function buildSource(imports) {
-	return imports.map((specifier) => `import ${JSON.stringify(specifier)}\n`).join("");
+/**
+* Expand each plugin's `services` glob list into a flat set of absolute
+* file paths. Consulted by the `file://` branch in `load()` to decide
+* whether to auto-inject `runtime.register(...)` for the loaded module.
+*
+* Glob expansion uses the same `expandGlob` (and therefore the same
+* `fs.readdirSync` snapshot) that `buildPluginBarrel` uses, so the set
+* stays in lockstep with what the barrel actually imports.
+*/
+function collectServiceFiles(payload) {
+	const set = /* @__PURE__ */ new Set();
+	for (const plugin of payload.plugins) for (const entry of plugin.services) {
+		const resolved = path.isAbsolute(entry) ? entry : path.resolve(plugin.dir, entry);
+		if (resolved.includes("*")) for (const f of expandGlob(resolved)) set.add(f);
+		else set.add(resolved);
+	}
+	return set;
 }
 /**
 * Read the resolved config from the process global. setup-gate populates
@@ -164,6 +187,7 @@ function getResolvedConfig(configPath) {
 	const fresh = resolveConfigViaSubprocess(path.dirname(configPath));
 	resolvedPayload = fresh.payload;
 	resolvedPluginSourceFiles = fresh.pluginSourceFiles;
+	serviceFileSet = collectServiceFiles(fresh.payload);
 	return fresh;
 }
 /**
@@ -190,38 +214,30 @@ function buildRegistryModule(payload) {
 	return [
 		"import { replacePlugins, registerAppEntrypoint } from \"@zenbujs/core/runtime\"",
 		`replacePlugins(${JSON.stringify(payload.plugins)})`,
-		`registerAppEntrypoint(${JSON.stringify(payload.appEntrypoint)})`,
+		`registerAppEntrypoint(${JSON.stringify(payload.appEntrypoint)}, ${JSON.stringify(payload.splashPath)})`,
 		"import.meta.hot?.accept()"
 	].join("\n") + "\n";
 }
 /**
 * Generate a per-plugin barrel: just service-file imports anchored at the
 * plugin's `dir`. Glob-form entries get expanded via `fs.readdirSync` and
-* a parcel-watcher subscription is opened so dynohot invalidates the
-* barrel when service files are added/removed under the watched directory.
+* glob directories are registered with `context.hot.watch()` so dynohot
+* reloads the generated barrel when service files are added/removed.
 */
 function buildPluginBarrel(plugin) {
 	const imports = [];
 	const watchPaths = new Set([plugin.dir]);
-	const globs = [];
 	for (const entry of plugin.services) {
 		const resolved = path.isAbsolute(entry) ? entry : path.resolve(plugin.dir, entry);
 		if (resolved.includes("*")) {
 			const dir = path.dirname(resolved);
-			const regex = globRegex(path.basename(resolved));
 			watchPaths.add(dir);
-			globs.push({
-				dir,
-				regex,
-				snapshot: snapshotDir(dir, regex)
-			});
 			for (const file of expandGlob(resolved)) imports.push(pathToFileURL(file).href);
 		} else imports.push(pathToFileURL(resolved).href);
 	}
 	return {
 		source: `${buildSource(imports)}import.meta.hot?.accept()\n`,
-		watchPaths,
-		globs
+		watchPaths
 	};
 }
 const CORE_PACKAGE_ROOT_FOR_LOADER = (() => {
@@ -316,6 +332,19 @@ function loadImpl(url, context, nextLoad) {
 			shortCircuit: true
 		};
 	}
+	if (url.startsWith("file://")) {
+		let filePath;
+		try {
+			filePath = fileURLToPath(url);
+		} catch {
+			filePath = "";
+		}
+		if (filePath && serviceFileSet.has(filePath)) {
+			const downstream = nextLoad(url, context);
+			if (downstream && typeof downstream.then === "function") return Promise.resolve(downstream).then((r) => appendAutoRegister(r, filePath));
+			return appendAutoRegister(downstream, filePath);
+		}
+	}
 	if (url.startsWith("zenbu:barrel?")) {
 		const params = new URL(url).searchParams;
 		const pluginRaw = decodeURIComponent(params.get("plugin") ?? "");
@@ -325,16 +354,9 @@ function loadImpl(url, context, nextLoad) {
 		} catch (err) {
 			throw new Error(`[zenbu-loader] bad plugin payload: ${err.message}`);
 		}
-		const { source, watchPaths, globs } = buildPluginBarrel(plugin);
+		const { source, watchPaths } = buildPluginBarrel(plugin);
 		if (context.hot?.watch) for (const watchPath of watchPaths) context.hot.watch(pathToFileURL(watchPath));
-		if (context.hot) {
-			barrels.set(url, {
-				hot: context.hot,
-				globs
-			});
-			for (const glob of globs) ensureDirWatcher(glob.dir);
-		}
-		if (verbose) console.log(`[zenbu-loader] generated barrel for plugin ${plugin.name} (${source.split("\n").filter(Boolean).length} imports, ${watchPaths.size} watches, ${globs.length} globs)`);
+		if (verbose) console.log(`[zenbu-loader] generated barrel for plugin ${plugin.name} (${source.split("\n").filter(Boolean).length} imports, ${watchPaths.size} watches)`);
 		return {
 			format: "module",
 			source,

package/dist/{monorepo-DCruz9Jx.mjs → monorepo-Dct-kkbQ.mjs}

@@ -3,6 +3,9 @@ import os from "node:os";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
 //#region src/cli/commands/monorepo.ts
+/**
+* todo: should only be exposed when an env var is passed
+*/
 const MARKER_FILE = ".zenbu-dev-link";
 const DEFAULT_MONOREPO = path.join(os.homedir(), ".zenbu", "plugins", "zenbu");
 function resolveProjectDir() {

package/dist/node-loader.mjs

@@ -1,4 +1,4 @@
-import { n as require_lib, t as zenbuAdviceTransform } from "./transform-DJH3vN4b.mjs";
+import { n as require_lib, t as zenbuAdviceTransform } from "./transform-BzrwkEdf.mjs";
 import { fileURLToPath } from "node:url";
 //#region ../advice/src/node-loader.ts
 var import_lib = require_lib();

package/dist/{publish-source-34Hn9zb0.mjs → publish-source-Dq2c0iOw.mjs}

@@ -1,5 +1,5 @@
-import { n as loadConfig } from "./load-config-BG2tPIfF.mjs";
-import { n as init, r as push } from "./mirror-sync-EiWvdzTJ.mjs";
+import { t as loadConfig } from "./load-config-C4Oe2qZO.mjs";
+import { n as init, r as push } from "./mirror-sync-pYU6f3-c.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import { execFileSync } from "node:child_process";

package/dist/react.d.mts

@@ -1,8 +1,8 @@
-import { f as CollectionRefBrand, h as InferCollectionItem, n as connectReplica, o as ClientProxy, p as CollectionRefValue, u as CollectionState, y as SchemaShape } from "./index-UK58xuoR.mjs";
-import { c as ResolvedServiceRouter, l as ZenbuRegister, o as ResolvedDbRoot, s as ResolvedEvents } from "./registry-CioEYLI5.mjs";
-import { n as EventProxy, r as RouterProxy } from "./index-CE0iPntP.mjs";
+import { f as CollectionRefBrand, h as InferCollectionItem, n as connectReplica, o as ClientProxy, p as CollectionRefValue, u as CollectionState, y as SchemaShape } from "./index-DeDxePAa.mjs";
+import { n as EventProxy, r as RouterProxy } from "./index-C-ALz_SH.mjs";
+import { i as ZenbuRegister, n as ResolvedEvents, r as ResolvedServiceRouter, t as ResolvedDbRoot } from "./registry-CMp8FYgS.mjs";
 import * as _$react from "react";
-import { ReactNode } from "react";
+import { CSSProperties, ReactElement, ReactNode } from "react";
 
 //#region ../kyju/src/v2/react/index.d.ts
 type CollectionResult<Item> = {
@@ -57,9 +57,9 @@ declare function ZenbuProvider({
   fallback,
   errorFallback,
   children
-}: ZenbuProviderProps): _$react.ReactElement<{
+}: ZenbuProviderProps): ReactElement<{
   "data-zenbu-connecting": boolean;
-}, string | _$react.JSXElementConstructor<any>> | _$react.ReactElement<{
+}, string | _$react.JSXElementConstructor<any>> | ReactElement<{
   "data-zenbu-error": boolean;
 }, string | _$react.JSXElementConstructor<any>> | _$react.FunctionComponentElement<_$react.ProviderProps<ConnectionState | null>>;
 declare function useRpc(): RouterProxy<RegisteredServiceRouter>;
@@ -72,5 +72,54 @@ type DbClient = {
 };
 declare function useDbClient(): DbClient;
 declare function useEvents(): EventProxy<RegisteredEvents>;
+/**
+ * Mounts a registered view (separate Vite root, registered via
+ * `ViewRegistryService.register(type, …)`) inside an `<iframe>` and:
+ *
+ * 1. **Auto-inherits auth from the parent iframe's URL.** Reads `wsPort` /
+ *    `wsToken` from `window.location.search` and forwards them in the
+ *    child URL so the child's `<ZenbuProvider>` connects without the
+ *    consumer wiring anything.
+ * 2. **Mount-once src.** The iframe's `src` is set on first mount and
+ *    *never updated*. Toggling `visible` only flips `style.display` —
+ *    state inside the child (sockets, ghostty terminals, etc.) survives
+ *    visibility changes.
+ * 3. **Initial args via URL.** `args` is encoded as base64 JSON in
+ *    `?args=` on first paint so the child can render without waiting on
+ *    a postMessage handshake. Use `useViewArgs<T>()` inside the child
+ *    to read.
+ * 4. **Reactive args via postMessage.** When `args` changes after mount,
+ *    we send `{ kind: "zenbu:view-args", args }` to the iframe's
+ *    `contentWindow`. URL is *not* rewritten (iframe stays alive).
+ *
+ * Child sessions die on unmount. There is no cache: if the consumer
+ * unmounts the `<View>` element, any state inside it (e.g. PTY sockets)
+ * is gone. Caller is responsible for explicit teardown via RPC if
+ * needed.
+ */
+type ViewProps = {
+  /** Registered view type — first arg to `ViewRegistryService.register`. */type: string; /** Initial args; serialized into the child URL as base64-JSON. */
+  args?: Record<string, unknown>; /** When false, sets `style.display: none`. Iframe is NOT unmounted. */
+  visible?: boolean;
+  style?: CSSProperties;
+  className?: string;
+  onLoad?: () => void; /** Rendered while the view registry has not yet reported a URL for this type. */
+  fallback?: ReactNode;
+};
+declare function View({
+  type,
+  args,
+  visible,
+  style,
+  className,
+  onLoad,
+  fallback
+}: ViewProps): ReactElement;
+/**
+ * Read the current view args inside a child iframe rendered by `<View>`.
+ * Initial value comes from `?args=` in the iframe's URL; updates arrive
+ * via `postMessage` and re-render this hook's caller.
+ */
+declare function useViewArgs<T extends Record<string, unknown>>(): T;
 //#endregion
-export { type CollectionRefValue, DbClient, ZenbuProvider, ZenbuProviderProps, type ZenbuRegister, useCollection, useDb, useDbClient, useEvents, useRpc };
+export { type CollectionRefValue, DbClient, View, ViewProps, ZenbuProvider, ZenbuProviderProps, type ZenbuRegister, useCollection, useDb, useDbClient, useEvents, useRpc, useViewArgs };

package/dist/react.mjs

@@ -1,5 +1,5 @@
-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 { i as dbStringify, r as dbParse, t as connectReplica } from "./transport-F2hv_OEm.mjs";
+import { t as connectRpc } from "./src-Cven45mq.mjs";
 import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 //#region ../kyju/src/v2/react/index.ts
 function createKyjuReact() {
@@ -209,13 +209,12 @@ function ZenbuProvider({ wsUrl, fallback, errorFallback, children }) {
 						ws.close();
 						return;
 					}
-					const viewMatch = window.location.pathname.match(/^\/views\/([^/]+)\//);
-					const viewScope = viewMatch ? viewMatch[1] : null;
+					const viewType = window.location.pathname.match(/^\/views\/([^/]+)\//)?.[1] ?? new URLSearchParams(window.location.search).get("type");
 					let unsubReload = null;
-					if (viewScope) {
+					if (viewType) {
 						const adviceReload = events?.advice?.reload;
 						if (adviceReload?.subscribe) unsubReload = adviceReload.subscribe((data) => {
-							if (data?.scope === viewScope) location.reload();
+							if (data?.type === "*" || data?.type === viewType) location.reload();
 						});
 					}
 					cleanupRef.current = () => {
@@ -287,5 +286,117 @@ function useDbClient() {
 function useEvents() {
 	return useConnection().events;
 }
+const VIEW_ARGS_MESSAGE_KIND = "zenbu:view-args";
+const VIEW_ARGS_PARAM_LIMIT = 1500;
+function encodeViewArgs(args) {
+	if (!args) return null;
+	try {
+		return btoa(unescape(encodeURIComponent(JSON.stringify(args))));
+	} catch (err) {
+		console.warn("[zenbu/View] failed to encode args:", err);
+		return null;
+	}
+}
+function decodeViewArgs(encoded) {
+	if (!encoded) return {};
+	try {
+		return JSON.parse(decodeURIComponent(escape(atob(encoded))));
+	} catch (err) {
+		console.warn("[zenbu/View] failed to decode args:", err);
+		return {};
+	}
+}
+function buildViewUrl(baseUrl, type, encodedArgs) {
+	const trimmed = baseUrl.replace(/\/$/, "");
+	const parentParams = new URLSearchParams(window.location.search);
+	const params = new URLSearchParams();
+	const wsPort = parentParams.get("wsPort");
+	const wsToken = parentParams.get("wsToken");
+	if (wsPort) params.set("wsPort", wsPort);
+	if (wsToken) params.set("wsToken", wsToken);
+	params.set("type", type);
+	if (encodedArgs) params.set("args", encodedArgs);
+	return `${trimmed}/?${params.toString()}`;
+}
+function shallowJSONEqual(a, b) {
+	try {
+		return JSON.stringify(a) === JSON.stringify(b);
+	} catch {
+		return false;
+	}
+}
+function View({ type, args, visible = true, style, className, onLoad, fallback = null }) {
+	const url = useDb((root) => root.plugin.core.lastKnownViewRegistry.find((v) => v.type === type)?.url ?? null);
+	const iframeRef = useRef(null);
+	const initialUrlRef = useRef(null);
+	const lastArgsRef = useRef(null);
+	const loadedRef = useRef(false);
+	if (initialUrlRef.current === null && url) {
+		const encoded = encodeViewArgs(args);
+		if (encoded && encoded.length > VIEW_ARGS_PARAM_LIMIT) console.warn(`[zenbu/View] args for "${type}" exceed ${VIEW_ARGS_PARAM_LIMIT} chars in URL — consider postMessage-only updates.`);
+		lastArgsRef.current = encoded;
+		initialUrlRef.current = buildViewUrl(url, type, encoded);
+	}
+	useEffect(() => {
+		if (!iframeRef.current) return;
+		const encoded = encodeViewArgs(args);
+		if (shallowJSONEqual(encoded, lastArgsRef.current)) return;
+		lastArgsRef.current = encoded;
+		const send = () => {
+			iframeRef.current?.contentWindow?.postMessage({
+				kind: VIEW_ARGS_MESSAGE_KIND,
+				args: args ?? {}
+			}, "*");
+		};
+		if (loadedRef.current) send();
+		else {
+			const iframe = iframeRef.current;
+			const onceLoaded = () => {
+				send();
+				iframe.removeEventListener("load", onceLoaded);
+			};
+			iframe.addEventListener("load", onceLoaded);
+			return () => iframe.removeEventListener("load", onceLoaded);
+		}
+	}, [args]);
+	if (!initialUrlRef.current) return createElement("span", { "data-zenbu-view-pending": type }, fallback);
+	return createElement("iframe", {
+		ref: iframeRef,
+		src: initialUrlRef.current,
+		className,
+		style: {
+			border: "none",
+			...style,
+			display: visible ? style?.display ?? "block" : "none"
+		},
+		onLoad: () => {
+			loadedRef.current = true;
+			onLoad?.();
+		}
+	});
+}
+/**
+* Read the current view args inside a child iframe rendered by `<View>`.
+* Initial value comes from `?args=` in the iframe's URL; updates arrive
+* via `postMessage` and re-render this hook's caller.
+*/
+function useViewArgs() {
+	const [args, setArgs] = useState(() => {
+		return decodeViewArgs(new URLSearchParams(typeof window !== "undefined" ? window.location.search : "").get("args"));
+	});
+	useEffect(() => {
+		const handler = (event) => {
+			if (event.source !== window.parent) return;
+			const data = event.data;
+			if (!data || typeof data !== "object") return;
+			if (data.kind !== VIEW_ARGS_MESSAGE_KIND) return;
+			const next = data.args;
+			if (next && typeof next === "object") setArgs(next);
+		};
+		window.addEventListener("message", handler);
+		return () => window.removeEventListener("message", handler);
+	}, []);
+	return args;
+}
 //#endregion
-export { ZenbuProvider, useCollection, useDb, useDbClient, useEvents, useRpc };
+export { View, ZenbuProvider, useCollection, useDb, useDbClient, useEvents, useRpc, useViewArgs };

package/dist/registry-CMp8FYgS.d.mts

@@ -0,0 +1,47 @@
+//#region src/registry.d.ts
+/**
+ * The registry seam.
+ *
+ * `ZenbuRegister` is the empty interface that downstream apps (and
+ * core's own `pnpm link:types` output) augment via:
+ *
+ *     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
+ * `ZenbuRegister` via the `Resolved*` aliases below, so each TS program
+ * sees its own merged surface without generics at the call site.
+ *
+ * Concrete types live elsewhere:
+ *   - core's published surface: `@zenbujs/core/registry-generated`
+ *     (regenerated by `pnpm link:types`, shipped via tsdown -> dist/)
+ *   - downstream's user-side surface: `<app>/types/services.ts` etc.
+ *     (regenerated by `zen link`)
+ *
+ * registry.ts itself stays minimal on purpose: only the augmentation
+ * target + plug-and-play fallbacks. Anything more would need to be
+ * hand-maintained, and we want the link generator to be the single
+ * source of truth.
+ *
+ * Mirrors the pattern TanStack Router uses for `Register`.
+ */
+interface ZenbuRegister {}
+type ResolvedDbRoot = ZenbuRegister extends {
+  db: infer T;
+} ? T : {
+  plugin: {};
+};
+type ResolvedServiceRouter = ZenbuRegister extends {
+  rpc: infer T;
+} ? T : {};
+type ResolvedEvents = ZenbuRegister extends {
+  events: infer T;
+} ? T : {};
+//#endregion
+export { ZenbuRegister as i, ResolvedEvents as n, ResolvedServiceRouter as r, ResolvedDbRoot as t };

package/dist/registry-generated.d.mts

@@ -0,0 +1,26 @@
+import { Events } from "./events.mjs";
+import { n as SchemaRoot } from "./schema-CjrMVk36.mjs";
+import { c as DbService, d as ServerService, i as BaseWindowService, l as HttpService, n as WindowService, o as RendererHostService, r as RpcService, s as ViewRegistryService, t as UpdaterService, u as ReloaderService } from "./index-w5QyDjuf.mjs";
+
+//#region src/registry-generated.d.ts
+type ServiceBase = "evaluate" | "shutdown" | "constructor" | "effect" | "__cleanupAllEffects" | "__effectCleanups" | "ctx";
+type ExtractRpcMethods<T> = { [K in Exclude<keyof T, ServiceBase | `_${string}`> as T[K] extends ((...args: any[]) => any) ? K : never]: T[K] };
+type CoreServiceRouter = {
+  "base-window": ExtractRpcMethods<BaseWindowService>;
+  db: ExtractRpcMethods<DbService>;
+  http: ExtractRpcMethods<HttpService>;
+  reloader: ExtractRpcMethods<ReloaderService>;
+  "renderer-host": ExtractRpcMethods<RendererHostService>;
+  rpc: ExtractRpcMethods<RpcService>;
+  server: ExtractRpcMethods<ServerService>;
+  updater: ExtractRpcMethods<UpdaterService>;
+  "view-registry": ExtractRpcMethods<ViewRegistryService>;
+  window: ExtractRpcMethods<WindowService>;
+};
+type CoreEvents = Events;
+type CoreDbSections = {
+  core: SchemaRoot;
+};
+type CorePreloads = {};
+//#endregion
+export { CoreDbSections, CoreEvents, CorePreloads, CoreServiceRouter };

package/dist/registry-generated.mjs

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

package/dist/registry.d.mts

@@ -1,2 +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-CioEYLI5.mjs";
-export { CoreDbSections, CoreEvents, CorePreloads, CoreServiceRouter, Events, ResolvedDbRoot, ResolvedEvents, ResolvedServiceRouter, ZenbuRegister };
+import { i as ZenbuRegister, n as ResolvedEvents, r as ResolvedServiceRouter, t as ResolvedDbRoot } from "./registry-CMp8FYgS.mjs";
+export { ResolvedDbRoot, ResolvedEvents, ResolvedServiceRouter, ZenbuRegister };

package/dist/{reloader-DJoCB0bC.mjs → reloader-B22UiNA2.mjs}

@@ -1,6 +1,7 @@
-import { t as Service, u as runtime } from "./runtime-C95iyVn6.mjs";
-import { t as createLogger } from "./log-CyKv8hQg.mjs";
-import { a as zenbuVitePlugins } from "./vite-plugins-t4MlFcz3.mjs";
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { Service, runtime } from "./runtime.mjs";
+import { t as createLogger } from "./log-6rzaCV0I.mjs";
+import { a as zenbuVitePlugins } from "./vite-plugins-tt6KAtyE.mjs";
 import os from "node:os";
 import path, { resolve } from "node:path";
 import { createHash } from "node:crypto";
@@ -15,6 +16,7 @@ const DB_CONFIG_JSON = path.join(INTERNAL_DIR, "db.json");
 path.join(INTERNAL_DIR, "plugin-setup-state.json");
 //#endregion
 //#region src/services/reloader.ts
+var reloader_exports = /* @__PURE__ */ __exportAll({ ReloaderService: () => ReloaderService });
 const log = createLogger("reloader");
 function safeCacheSegment(value) {
 	return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "renderer";
@@ -111,9 +113,7 @@ async function startRendererServer(options) {
 	await warmupRendererEntrypoints(server, options.root);
 	return server;
 }
-var ReloaderService = class extends Service {
-	static key = "reloader";
-	static deps = {};
+var ReloaderService = class extends Service.create({ key: "reloader" }) {
 	servers = /* @__PURE__ */ new Map();
 	async create(id, root, configFile) {
 		if (this.servers.has(id)) return this.servers.get(id);
@@ -161,4 +161,4 @@ var ReloaderService = class extends Service {
 };
 runtime.register(ReloaderService, import.meta);
 //#endregion
-export { DB_CONFIG_JSON as n, INTERNAL_DIR as r, ReloaderService as t };
+export { INTERNAL_DIR as i, reloader_exports as n, DB_CONFIG_JSON as r, ReloaderService as t };