@zenbujs/core 0.0.5 → 0.0.9

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-M_lSNBrq.mjs";
-import { c as ResolvedServiceRouter, l as ZenbuRegister, o as ResolvedDbRoot, s as ResolvedEvents } from "./registry-eX6e2oql.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

@@ -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-CVF768Xs.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-eX6e2oql.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-DzEO8kJr.mjs → reloader-B22UiNA2.mjs}

@@ -1,7 +1,7 @@
 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-Do7liKi_.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";
@@ -113,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);

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

@@ -1,10 +1,10 @@
 import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
-import { Service, getAppEntrypoint, getPlugins, runtime } from "./runtime.mjs";
+import { Service, getAppEntrypoint, getPlugins, runtime, subscribeConfig } from "./runtime.mjs";
 import { o as getZodDefault } from "./schema-Ca7SxXgS.mjs";
 import { schema } from "./schema.mjs";
 import { t as createLogger } from "./log-6rzaCV0I.mjs";
-import { t as ServerService } from "./server-y3PPbh3l.mjs";
-import { i as INTERNAL_DIR, r as DB_CONFIG_JSON, t as ReloaderService } from "./reloader-DzEO8kJr.mjs";
+import { t as ServerService } from "./server-CZLMF8Dj.mjs";
+import { i as INTERNAL_DIR, r as DB_CONFIG_JSON, t as ReloaderService } from "./reloader-B22UiNA2.mjs";
 import { a as createBlob, c as makeErrorAck, g as layer$1, h as writeJsonFile, i as cleanupStaleTmpFiles, l as paths, m as validateSession, n as makeRootCache, o as createCollection, p as sendAck, r as broadcastDbUpdate, s as makeAck, t as handleWrite, u as readCollectionItemRange, v as FileSystem } from "./write-DgIRjo23.mjs";
 import { t as traceKyju } from "./trace-BaVg0rnY.mjs";
 import { a as createClient, i as dbStringify, n as createRouter, o as createEffectClient, r as dbParse, s as createReplica } from "./transport-F2hv_OEm.mjs";
@@ -15,6 +15,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import http from "node:http";
 import fsp from "node:fs/promises";
 import * as Effect from "effect/Effect";
+import { subscribe } from "@parcel/watcher";
 import * as Ref from "effect/Ref";
 import { nanoid } from "nanoid";
 //#region ../../node_modules/.pnpm/@effect+platform-node@0.104.1_@effect+cluster@0.56.4_@effect+platform@0.94.5_effect@3.2_4dd4c94e7ca0ae112861b6965a5da5f4/node_modules/@effect/platform-node/dist/esm/NodeFileSystem.js
@@ -801,12 +802,13 @@ async function resolveDbPath(argv, app) {
 //#region src/services/http.ts
 var http_exports = /* @__PURE__ */ __exportAll({ HttpService: () => HttpService });
 const log$3 = createLogger("http");
-var HttpService = class extends Service {
-	static key = "http";
-	static deps = {
+var HttpService = class extends Service.create({
+	key: "http",
+	deps: {
 		server: ServerService,
 		reloader: ReloaderService
-	};
+	}
+}) {
 	connectedCallbacks = [];
 	disconnectedCallbacks = [];
 	activeConnections = /* @__PURE__ */ new Map();
@@ -1014,7 +1016,7 @@ function resolveConfigPath() {
 * loader-emitted barrel before any service evaluates.
 */
 async function loadAppDbField(configPath) {
-	const { loadConfig } = await import("./load-config-xMf2wxH8.mjs").then((n) => n.n);
+	const { loadConfig } = await import("./load-config-C4Oe2qZO.mjs").then((n) => n.n);
 	const { resolved } = await loadConfig(path.dirname(configPath));
 	return resolved.dbPath;
 }
@@ -1104,9 +1106,10 @@ async function discoverSections() {
 	for (const ptm of sorted) log$2.verbose(`  ${ptm.name.padEnd(28)} total=${String(ptm.totalMs).padStart(6)} resS=${String(ptm.resolveSchemaMs).padStart(5)} impS=${String(ptm.importSchemaMs).padStart(6)} resM=${String(ptm.resolveMigrationsMs).padStart(5)} impM=${String(ptm.importMigrationsMs).padStart(6)}`);
 	return sections;
 }
-var DbService = class extends Service {
-	static key = "db";
-	static deps = { http: HttpService };
+var DbService = class extends Service.create({
+	key: "db",
+	deps: { http: HttpService }
+}) {
 	db = null;
 	dbRouter = null;
 	sectionsHash = "";
@@ -1195,6 +1198,110 @@ var DbService = class extends Service {
 		this.setup("kyju-close-on-cleanup", () => async () => {
 			await this.close();
 		});
+		this.setup("migrations-watcher", () => {
+			const subs = [];
+			let closed = false;
+			let pendingTimer = null;
+			let inFlight = null;
+			let queued = false;
+			const triggerReload = async () => {
+				if (closed) return;
+				if (inFlight) {
+					queued = true;
+					return;
+				}
+				inFlight = runtime.reload("db").catch((err) => {
+					log$2.error("migrations-watcher reload failed:", err);
+				});
+				try {
+					await inFlight;
+				} finally {
+					inFlight = null;
+					if (queued && !closed) {
+						queued = false;
+						scheduleReload();
+					}
+				}
+			};
+			const scheduleReload = () => {
+				if (closed) return;
+				if (pendingTimer) clearTimeout(pendingTimer);
+				pendingTimer = setTimeout(() => {
+					pendingTimer = null;
+					triggerReload();
+				}, 100);
+			};
+			(async () => {
+				for (const plugin of getPlugins()) {
+					const migPath = plugin.migrationsPath;
+					if (!migPath) continue;
+					let isDir = false;
+					try {
+						isDir = (await fsp.stat(migPath)).isDirectory();
+					} catch {
+						continue;
+					}
+					if (!isDir) continue;
+					const journalPath = path.join(migPath, "meta", "_journal.json");
+					try {
+						const sub = await subscribe(migPath, (err, events) => {
+							if (err || closed) return;
+							for (const event of events) {
+								if (event.path === journalPath) {
+									scheduleReload();
+									return;
+								}
+								if (path.dirname(event.path) !== migPath) continue;
+								if (event.type === "update") continue;
+								const ext = path.extname(event.path);
+								if (ext === ".ts" || ext === ".js" || ext === ".mjs") {
+									scheduleReload();
+									return;
+								}
+							}
+						});
+						if (closed) {
+							await sub.unsubscribe().catch(() => {});
+							return;
+						}
+						subs.push(sub);
+					} catch (err) {
+						log$2.error(`migrations-watcher subscribe failed for ${plugin.name}: ${err instanceof Error ? err.message : String(err)}`);
+					}
+				}
+			})().catch((err) => {
+				log$2.error("migrations-watcher setup failed:", err);
+			});
+			return async () => {
+				closed = true;
+				if (pendingTimer) {
+					clearTimeout(pendingTimer);
+					pendingTimer = null;
+				}
+				const toClose = subs.splice(0);
+				await Promise.all(toClose.map((s) => s.unsubscribe().catch(() => {})));
+			};
+		});
+		this.setup("plugin-set-watcher", () => {
+			const fingerprint = (snap) => JSON.stringify([...snap.plugins].map((p) => ({
+				name: p.name,
+				schemaPath: p.schemaPath ?? null,
+				migrationsPath: p.migrationsPath ?? null
+			})).sort((a, b) => a.name.localeCompare(b.name)));
+			let lastHash = null;
+			return subscribeConfig((snap) => {
+				const hash = fingerprint(snap);
+				if (lastHash === null) {
+					lastHash = hash;
+					return;
+				}
+				if (hash === lastHash) return;
+				lastHash = hash;
+				runtime.reload("db").catch((err) => {
+					log$2.error("plugin-set-watcher reload failed:", err);
+				});
+			});
+		});
 		this.setup("ws-transport", () => {
 			const onConnected = (id, ws) => {
 				const dbConn = this.dbRouter.connection({
@@ -1236,68 +1343,69 @@ runtime.register(DbService, import.meta);
 //#region src/services/view-registry.ts
 var view_registry_exports = /* @__PURE__ */ __exportAll({ ViewRegistryService: () => ViewRegistryService });
 const log$1 = createLogger("view-registry");
-var ViewRegistryService = class extends Service {
-	static key = "view-registry";
-	static deps = {
+var ViewRegistryService = class extends Service.create({
+	key: "view-registry",
+	deps: {
 		reloader: ReloaderService,
 		db: DbService
-	};
+	}
+}) {
 	views = /* @__PURE__ */ new Map();
 	manifestIcons = /* @__PURE__ */ new Map();
-	async register(scope, root, configFile, meta) {
-		log$1.verbose(`register("${scope}", root="${root}", config="${configFile}")`);
-		const existing = this.views.get(scope);
+	async register(type, root, configFile, meta) {
+		log$1.verbose(`register("${type}", root="${root}", config="${configFile}")`);
+		const existing = this.views.get(type);
 		if (existing) {
-			log$1.verbose(`"${scope}" already exists at ${existing.url}`);
+			log$1.verbose(`"${type}" already exists at ${existing.url}`);
 			return existing;
 		}
-		log$1.verbose(`creating reloader for "${scope}"...`);
-		const reloaderEntry = await this.ctx.reloader.create(scope, root, configFile);
+		log$1.verbose(`creating reloader for "${type}"...`);
+		const reloaderEntry = await this.ctx.reloader.create(type, root, configFile);
 		log$1.verbose(`reloader created: ${reloaderEntry.url} (port ${reloaderEntry.port})`);
 		const entry = {
-			scope,
+			type,
 			url: reloaderEntry.url,
 			port: reloaderEntry.port,
 			ownsServer: true,
 			meta
 		};
-		this.views.set(scope, entry);
+		this.views.set(type, entry);
 		await this.syncToDb();
-		log$1.verbose(`"${scope}" registered at ${entry.url}`);
+		log$1.verbose(`"${type}" registered at ${entry.url}`);
 		return entry;
 	}
-	registerAlias(scope, reloaderId, pathPrefix, meta) {
-		const existing = this.views.get(scope);
+	registerAlias(type, reloaderId, pathPrefix, meta) {
+		const existing = this.views.get(type);
 		if (existing) return existing;
 		const reloaderEntry = this.ctx.reloader.get(reloaderId);
-		if (!reloaderEntry) throw new Error(`Reloader "${reloaderId}" not found for alias "${scope}"`);
+		if (!reloaderEntry) throw new Error(`Reloader "${reloaderId}" not found for alias "${type}"`);
 		const entry = {
-			scope,
+			type,
 			url: `${reloaderEntry.url}${pathPrefix}`,
 			port: reloaderEntry.port,
 			ownsServer: false,
 			meta
 		};
-		this.views.set(scope, entry);
+		this.views.set(type, entry);
 		this.syncToDb();
 		return entry;
 	}
-	async unregister(scope) {
-		const entry = this.views.get(scope);
+	async unregister(type) {
+		const entry = this.views.get(type);
 		if (!entry) return;
-		if (entry.ownsServer) await this.ctx.reloader.remove(scope);
-		this.views.delete(scope);
+		if (entry.ownsServer) await this.ctx.reloader.remove(type);
+		this.views.delete(type);
 		await this.syncToDb();
 	}
-	get(scope) {
-		return this.views.get(scope);
+	get(type) {
+		return this.views.get(type);
 	}
 	evaluate() {
 		this.loadManifestIcons();
 		this.syncToDb();
 		this.setup("view-registry-cleanup", () => {
 			return async () => {
-				for (const [scope, entry] of this.views) if (entry.ownsServer) await this.ctx.reloader.remove(scope);
+				for (const [type, entry] of this.views) if (entry.ownsServer) await this.ctx.reloader.remove(type);
 				this.views.clear();
 				await this.syncToDb();
 			};
@@ -1307,16 +1415,16 @@ var ViewRegistryService = class extends Service {
 		this.manifestIcons.clear();
 		for (const plugin of getPlugins()) {
 			if (!plugin.icons) continue;
-			for (const [scope, svg] of Object.entries(plugin.icons)) this.manifestIcons.set(scope, svg);
+			for (const [type, svg] of Object.entries(plugin.icons)) this.manifestIcons.set(type, svg);
 		}
 	}
 	async syncToDb() {
 		const client = this.ctx.db.effectClient;
 		const snapshot = [...this.views.values()].map((e) => ({
-			scope: e.scope,
+			type: e.type,
 			url: e.url,
 			port: e.port,
-			icon: this.manifestIcons.get(e.scope),
+			icon: this.manifestIcons.get(e.type),
 			meta: e.meta
 		}));
 		await Effect.runPromise(client.update((root) => {
@@ -1361,12 +1469,13 @@ async function resolveRendererRoot() {
 		configFile: await pathExists(viteConfig) ? viteConfig : false
 	};
 }
-var RendererHostService = class extends Service {
-	static key = "renderer-host";
-	static deps = {
+var RendererHostService = class extends Service.create({
+	key: "renderer-host",
+	deps: {
 		reloader: ReloaderService,
 		viewRegistry: ViewRegistryService
-	};
+	}
+}) {
 	url = "";
 	port = 0;
 	async evaluate() {

package/dist/{rpc-JfGv-Wuw.mjs → rpc-C4_NQmpT.mjs}

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