@zenbujs/core 0.0.1

package/dist/renderer-host-Bg8QdeeH.mjs

@@ -0,0 +1,1508 @@
+import { i as runtime, t as Service } from "./runtime-DUFKDIe4.mjs";
+import { o as getZodDefault } from "./schema-CIg4GzHQ.mjs";
+import { t as schema } from "./schema-dGK6qkfR.mjs";
+import { t as createLogger } from "./log-CyKv8hQg.mjs";
+import { t as ServerService } from "./server-BXwZEQ-n.mjs";
+import { n as DB_CONFIG_JSON, r as INTERNAL_DIR, t as ReloaderService } from "./reloader-lLAJ3lqg.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-9dRFczGJ.mjs";
+import { t as traceKyju } from "./trace-DCB7qFzT.mjs";
+import { a as createClient, i as dbStringify, n as createRouter, o as createEffectClient, r as dbParse, s as createReplica } from "./transport-BMSzG2-F.mjs";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import http from "node:http";
+import fsp from "node:fs/promises";
+import * as Effect from "effect/Effect";
+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
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category layer
+*/
+const layer = layer$1;
+//#endregion
+//#region ../kyju/src/v2/db/handlers/connect.ts
+const handleConnect = (ctx, event, latch) => latch.whenOpen(Effect.gen(function* () {
+	const msg = event.message;
+	const { replicaId } = msg;
+	if (msg.version !== 0) {
+		ctx.dbSend({
+			kind: "db-update",
+			replicaId,
+			message: makeErrorAck({
+				requestId: msg.requestId,
+				_tag: "VersionMismatchError",
+				message: `Expected version 0, got ${msg.version}`
+			})
+		});
+		return;
+	}
+	const sessionId = nanoid();
+	const root = yield* ctx.rootCache.read();
+	const session = {
+		sessionId,
+		replicaId,
+		subscriptions: /* @__PURE__ */ new Set(),
+		send: (event) => ctx.dbSend({
+			...event,
+			replicaId
+		})
+	};
+	yield* Ref.update(ctx.sessionsRef, (sessions) => {
+		const next = new Map(sessions);
+		next.set(sessionId, session);
+		return next;
+	});
+	sendAck({
+		session,
+		ack: makeAck({
+			requestId: msg.requestId,
+			sessionId,
+			data: { root }
+		})
+	});
+}));
+//#endregion
+//#region ../kyju/src/v2/db/handlers/disconnect.ts
+const handleDisconnect = (ctx, event) => Effect.gen(function* () {
+	const msg = event.message;
+	const session = (yield* Ref.get(ctx.sessionsRef)).get(msg.sessionId);
+	if (!session) {
+		ctx.dbSend({
+			kind: "db-update",
+			replicaId: event.replicaId,
+			message: makeErrorAck({
+				requestId: msg.requestId,
+				sessionId: msg.sessionId,
+				_tag: "InvalidSessionError",
+				message: "Invalid session"
+			})
+		});
+		return yield* Effect.fail("INVALID_SESSION");
+	}
+	yield* Ref.update(ctx.sessionsRef, (s) => {
+		const next = new Map(s);
+		next.delete(msg.sessionId);
+		return next;
+	});
+	sendAck({
+		session,
+		ack: makeAck({
+			requestId: msg.requestId,
+			sessionId: msg.sessionId
+		})
+	});
+});
+//#endregion
+//#region ../kyju/src/v2/db/handlers/subscribe.ts
+const handleSubscribe = (ctx, event) => Effect.gen(function* () {
+	const session = yield* validateSession(ctx, event.sessionId, event.requestId, event.replicaId);
+	yield* ctx.collectionMutex.withPermits(1)(Effect.gen(function* () {
+		const collectionDir = paths.collection({
+			config: ctx.config,
+			collectionId: event.collectionId
+		});
+		if (!(yield* ctx.fs.exists(collectionDir))) yield* createCollection({
+			fs: ctx.fs,
+			config: ctx.config,
+			collectionId: event.collectionId
+		});
+		session.subscriptions.add(event.collectionId);
+		const { items, totalCount } = yield* readCollectionItemRange({
+			fs: ctx.fs,
+			config: ctx.config,
+			collectionId: event.collectionId
+		});
+		sendAck({
+			session,
+			ack: makeAck({
+				requestId: event.requestId,
+				sessionId: event.sessionId,
+				data: {
+					items,
+					totalCount
+				}
+			})
+		});
+	}));
+});
+//#endregion
+//#region ../kyju/src/v2/db/handlers/unsubscribe.ts
+const handleUnsubscribe = (ctx, event) => Effect.gen(function* () {
+	const session = yield* validateSession(ctx, event.sessionId, event.requestId, event.replicaId);
+	session.subscriptions.delete(event.collectionId);
+	sendAck({
+		session,
+		ack: makeAck({
+			requestId: event.requestId,
+			sessionId: event.sessionId
+		})
+	});
+});
+//#endregion
+//#region ../kyju/src/v2/db/handlers/read.ts
+const handleRead = (ctx, event) => Effect.gen(function* () {
+	const session = yield* validateSession(ctx, event.sessionId, event.requestId, event.replicaId);
+	const readOp = event.op;
+	switch (readOp.type) {
+		case "collection.fetch-range":
+			yield* ctx.collectionMutex.withPermits(1)(Effect.gen(function* () {
+				const collectionDir = paths.collection({
+					config: ctx.config,
+					collectionId: readOp.collectionId
+				});
+				if (!(yield* ctx.fs.exists(collectionDir))) {
+					sendAck({
+						session,
+						ack: makeErrorAck({
+							requestId: event.requestId,
+							sessionId: event.sessionId,
+							_tag: "NotFoundError",
+							message: `Collection ${readOp.collectionId} not found`
+						})
+					});
+					return;
+				}
+				const { items, totalCount } = yield* readCollectionItemRange({
+					fs: ctx.fs,
+					config: ctx.config,
+					collectionId: readOp.collectionId,
+					start: readOp.range.start,
+					end: readOp.range.end
+				});
+				sendAck({
+					session,
+					ack: makeAck({
+						requestId: event.requestId,
+						sessionId: event.sessionId,
+						data: {
+							items,
+							totalCount
+						}
+					})
+				});
+			}));
+			return;
+		case "blob.read":
+			yield* ctx.blobMutex.withPermits(1)(Effect.gen(function* () {
+				if (!(yield* ctx.fs.exists(paths.blob({
+					config: ctx.config,
+					blobId: readOp.blobId
+				})))) {
+					sendAck({
+						session,
+						ack: makeErrorAck({
+							requestId: event.requestId,
+							sessionId: event.sessionId,
+							_tag: "NotFoundError",
+							message: `Blob ${readOp.blobId} not found`
+						})
+					});
+					return;
+				}
+				const data = yield* ctx.fs.readFile(paths.blobData({
+					config: ctx.config,
+					blobId: readOp.blobId
+				}));
+				sendAck({
+					session,
+					ack: makeAck({
+						requestId: event.requestId,
+						sessionId: event.sessionId,
+						data: { data }
+					})
+				});
+			}));
+			return;
+	}
+});
+//#endregion
+//#region ../kyju/src/v2/db/handlers/plugins.ts
+const runPlugins = (ctx, postMessageEffect, plugins) => Effect.gen(function* () {
+	const sessionId = nanoid();
+	const root = yield* ctx.rootCache.read();
+	const replica = createReplica({
+		send: (event) => {
+			Effect.runPromise(postMessageEffect(event));
+		},
+		maxPageSizeBytes: ctx.config.maxPageSize
+	});
+	const session = {
+		sessionId,
+		replicaId: replica.replicaId,
+		subscriptions: /* @__PURE__ */ new Set(),
+		send: (event) => {
+			replica.postMessage(event);
+		}
+	};
+	yield* Ref.update(ctx.sessionsRef, (s) => {
+		const next = new Map(s);
+		next.set(sessionId, session);
+		return next;
+	});
+	replica._forceState({
+		kind: "connected",
+		sessionId,
+		root,
+		collections: [],
+		blobs: []
+	});
+	const client = createClient(replica);
+	for (const plugin of plugins) {
+		if (!plugin.onBeforeStart) continue;
+		yield* traceKyju("kyju:db.plugin.onBeforeStart", Effect.promise(() => plugin.onBeforeStart({
+			client,
+			pluginPath: ["_plugins", plugin.name]
+		})), { plugin: plugin.name });
+	}
+	return replica;
+});
+//#endregion
+//#region ../kyju/src/v2/migrations.ts
+/**
+* Returns true if `current` is "structurally equivalent" to `oldDefault`,
+* tolerating extra keys on objects that `oldDefault` didn't know about.
+*
+* Why this exists: when an alter op carries a `default` change, apply()
+* uses this to decide whether the current DB value is "still the stale
+* default" and therefore safe to overwrite with the new one. Strict
+* equality would skip the overwrite whenever an intermediate migration
+* (via a custom `migrate()`) enriched entries with new schema fields —
+* which is common. That bug left users stuck on old defaults indefinitely.
+*
+* For objects: every key in `oldDefault` must be present and match in
+* `current`; `current` is allowed to have *additional* keys (enrichment
+* artifacts). For arrays: same length + elementwise subset match. For
+* primitives: strict equality.
+*/
+function isDefaultSubsetMatch(current, oldDefault) {
+	if (oldDefault === null || oldDefault === void 0) return current === oldDefault;
+	if (typeof oldDefault !== "object") return current === oldDefault;
+	if (Array.isArray(oldDefault)) {
+		if (!Array.isArray(current) || current.length !== oldDefault.length) return false;
+		return oldDefault.every((item, i) => isDefaultSubsetMatch(current[i], item));
+	}
+	if (typeof current !== "object" || current === null || Array.isArray(current)) return false;
+	for (const key of Object.keys(oldDefault)) {
+		if (!(key in current)) return false;
+		if (!isDefaultSubsetMatch(current[key], oldDefault[key])) return false;
+	}
+	return true;
+}
+function applyOperations(data, ops) {
+	const result = { ...data };
+	for (const op of ops) switch (op.op) {
+		case "add":
+			if (op.kind === "collection") {
+				if (!(op.key in result)) result[op.key] = {
+					collectionId: nanoid(),
+					debugName: op.debugName ?? op.key
+				};
+			} else if (op.kind === "blob") {
+				if (!(op.key in result)) result[op.key] = {
+					blobId: nanoid(),
+					debugName: op.debugName ?? op.key
+				};
+			} else if (op.hasDefault) {
+				if (!(op.key in result)) result[op.key] = op.default;
+			} else if (!(op.key in result)) result[op.key] = void 0;
+			break;
+		case "remove":
+			delete result[op.key];
+			break;
+		case "alter":
+			if (op.changes.default) {
+				const current = result[op.key];
+				const oldDefault = op.changes.default.from;
+				if (isDefaultSubsetMatch(current, oldDefault)) result[op.key] = op.changes.default.to;
+			}
+			break;
+	}
+	return result;
+}
+//#endregion
+//#region ../kyju/src/v2/core-plugins/migration.ts
+const migrationPlugin = (migrations) => ({
+	name: "kyjuMigrator",
+	onBeforeStart: async ({ client, pluginPath }) => {
+		const targetVersion = migrations.length;
+		const pluginState = (client.readRoot() ?? {})?._plugins?.kyjuMigrator ?? {};
+		const currentVersion = typeof pluginState === "object" && pluginState !== null ? pluginState.version ?? 0 : 0;
+		if (currentVersion >= targetVersion) return;
+		for (let v = currentVersion; v < targetVersion; v++) {
+			const migration = migrations[v];
+			const ops = migration.operations ?? [];
+			const removeOps = ops.filter((o) => o.op === "remove" && (o.kind === "collection" || o.kind === "blob"));
+			for (const op of removeOps) await client[op.key]?.delete?.();
+			const currentRoot = client.readRoot();
+			const apply = (data) => applyOperations(data, ops);
+			let newRoot;
+			if (migration.migrate) newRoot = migration.migrate(currentRoot, { apply });
+			else newRoot = apply(currentRoot);
+			await client.update(() => newRoot);
+			const addCollectionOps = ops.filter((o) => o.op === "add" && o.kind === "collection");
+			for (const op of addCollectionOps) await client[op.key]?.create?.();
+			const addBlobOps = ops.filter((o) => o.op === "add" && o.kind === "blob");
+			for (const op of addBlobOps) await client[op.key]?.create?.(new Uint8Array(0));
+			if (migration.afterMigrate) await migration.afterMigrate({ client });
+			await client.update((r) => {
+				let target = r;
+				for (const segment of pluginPath) {
+					if (!target[segment]) target[segment] = {};
+					target = target[segment];
+				}
+				target.version = v + 1;
+			});
+		}
+	}
+});
+const sectionMigrationPlugin = (sections) => ({
+	name: "sectionMigrator",
+	onBeforeStart: async ({ client, pluginPath }) => {
+		for (const section of sections) {
+			const { name, migrations } = section;
+			const targetVersion = migrations.length;
+			const pluginState = (client.readRoot() ?? {})?._plugins?.sectionMigrator?.[name] ?? {};
+			const currentVersion = typeof pluginState === "object" && pluginState !== null ? pluginState.version ?? 0 : 0;
+			if (currentVersion >= targetVersion) continue;
+			for (let v = currentVersion; v < targetVersion; v++) {
+				const migration = migrations[v];
+				const ops = migration.operations ?? [];
+				const removeOps = ops.filter((o) => o.op === "remove" && (o.kind === "collection" || o.kind === "blob"));
+				for (const op of removeOps) await client.plugin?.[name]?.[op.key]?.delete?.();
+				const sectionData = client.readRoot()?.plugin?.[name] ?? {};
+				const apply = (data) => applyOperations(data, ops);
+				let newSectionData;
+				if (migration.migrate) newSectionData = migration.migrate(sectionData, { apply });
+				else newSectionData = apply(sectionData);
+				await client.update((r) => {
+					if (!r.plugin) r.plugin = {};
+					r.plugin[name] = newSectionData;
+				});
+				const addCollectionOps = ops.filter((o) => o.op === "add" && o.kind === "collection");
+				for (const op of addCollectionOps) await client.plugin?.[name]?.[op.key]?.create?.();
+				const addBlobOps = ops.filter((o) => o.op === "add" && o.kind === "blob");
+				for (const op of addBlobOps) await client.plugin?.[name]?.[op.key]?.create?.(new Uint8Array(0));
+				if (migration.afterMigrate) {
+					const sectionClient = client.plugin?.[name];
+					await migration.afterMigrate({ client: sectionClient });
+				}
+				await client.update((r) => {
+					let target = r;
+					for (const segment of [...pluginPath, name]) {
+						if (!target[segment]) target[segment] = {};
+						target = target[segment];
+					}
+					target.version = v + 1;
+				});
+			}
+		}
+	}
+});
+//#endregion
+//#region ../kyju/src/v2/db/db.ts
+var DbLockedError = class extends Error {
+	constructor(dbPath, holder) {
+		super(`Database at ${dbPath} is locked by pid ${holder.pid} on host ${holder.hostname} (started ${holder.startedAt}).\nkyju refuses to open a second concurrent writer to avoid clobbering its flushes.\nQuit the running process and try again, or remove ${path.join(dbPath, ".lock")} if you're sure no process is using this DB.`);
+		this.name = "DbLockedError";
+	}
+};
+function lockPath(dbPath) {
+	return path.join(dbPath, ".lock");
+}
+function isPidAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err.code !== "ESRCH";
+	}
+}
+async function readLock(dbPath) {
+	try {
+		const raw = await fs.promises.readFile(lockPath(dbPath), "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+async function acquireLock(dbPath) {
+	await fs.promises.mkdir(dbPath, { recursive: true });
+	const existing = await readLock(dbPath);
+	if (existing) {
+		const sameHost = existing.hostname === os.hostname();
+		if (!(sameHost && existing.pid === process.pid)) {
+			if (!sameHost || isPidAlive(existing.pid)) throw new DbLockedError(dbPath, existing);
+		}
+	}
+	const nonce = nanoid();
+	const payload = {
+		pid: process.pid,
+		hostname: os.hostname(),
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		nonce
+	};
+	await fs.promises.writeFile(lockPath(dbPath), JSON.stringify(payload));
+	return nonce;
+}
+async function releaseLock(dbPath, ourNonce) {
+	const current = await readLock(dbPath);
+	if (!current || current.nonce !== ourNonce) return;
+	try {
+		await fs.promises.unlink(lockPath(dbPath));
+	} catch {}
+}
+/**
+* Sync release for the `process.on("exit")` path. Async callbacks don't
+* run during process exit (the event loop is already torn down), so
+* we have no choice but to use sync fs here. Mirrors `releaseLock`'s
+* nonce check exactly.
+*/
+function releaseLockOnExit(dbPath, ourNonce) {
+	let current = null;
+	try {
+		current = JSON.parse(fs.readFileSync(lockPath(dbPath), "utf8"));
+	} catch {
+		return;
+	}
+	if (!current || current.nonce !== ourNonce) return;
+	try {
+		fs.unlinkSync(lockPath(dbPath));
+	} catch {}
+}
+const DEFAULT_CONFIG = {
+	rootName: "root",
+	collectionsDirName: "collections",
+	collectionIndexName: "index",
+	pagesDirName: "pages",
+	pageIndexName: "index",
+	pageDataName: "data",
+	blobsDirName: "blobs",
+	blobIndexName: "index",
+	blobDataName: "data"
+};
+const buildSchemaRoot = function* (fs, config, schema) {
+	const root = {};
+	for (const [key, entry] of Object.entries(schema.shape)) {
+		const fs_obj = entry && typeof entry === "object" && "schema" in entry ? entry.schema : entry;
+		if (fs_obj.__kyjuCollectionRef) {
+			const dn = fs_obj._debugName;
+			root[key] = {
+				collectionId: "",
+				debugName: typeof dn === "string" ? dn : key
+			};
+		} else if (fs_obj.type === "blob" || entry?.type === "blob") {
+			const blobId = nanoid();
+			root[key] = {
+				blobId,
+				debugName: fs_obj.debugName ?? entry?.debugName ?? key
+			};
+			yield* createBlob({
+				fs,
+				config,
+				blobId,
+				data: new Uint8Array(0)
+			});
+		} else if (entry._hasDefault) root[key] = entry._defaultValue;
+		else {
+			const def = getZodDefault(entry);
+			if (def.hasDefault) root[key] = def.value;
+		}
+	}
+	return root;
+};
+const finalizeAndWriteRoot = function* (fs, config, root) {
+	const pendingCollections = [];
+	const initNestedCollections = (obj) => {
+		if (obj == null || typeof obj !== "object") return obj;
+		if (Array.isArray(obj)) return obj.map(initNestedCollections);
+		if (typeof obj.collectionId === "string" && typeof obj.debugName === "string" && !obj.collectionId) {
+			const collectionId = nanoid();
+			pendingCollections.push({ collectionId });
+			return {
+				...obj,
+				collectionId
+			};
+		}
+		const result = {};
+		for (const [k, v] of Object.entries(obj)) result[k] = initNestedCollections(v);
+		return result;
+	};
+	const finalRoot = initNestedCollections(root);
+	for (const { collectionId } of pendingCollections) yield* createCollection({
+		fs,
+		config,
+		collectionId
+	});
+	yield* writeJsonFile({
+		fs,
+		config,
+		path: paths.root({ config }),
+		data: finalRoot
+	});
+};
+const initializeDbIfNeeded = (fs, config, schema) => Effect.gen(function* () {
+	const rootPath = paths.root({ config });
+	if (yield* fs.exists(rootPath)) return;
+	yield* fs.makeDirectory(config.dbPath, { recursive: true });
+	yield* finalizeAndWriteRoot(fs, config, yield* buildSchemaRoot(fs, config, schema));
+});
+const initializeSectionedDbIfNeeded = (fs, config, sections) => Effect.gen(function* () {
+	const rootPath = paths.root({ config });
+	if (yield* fs.exists(rootPath)) return;
+	yield* fs.makeDirectory(config.dbPath, { recursive: true });
+	const sectionsData = {};
+	for (const section of sections) sectionsData[section.name] = yield* buildSchemaRoot(fs, config, section.schema);
+	yield* finalizeAndWriteRoot(fs, config, { plugin: sectionsData });
+});
+const createDbEffect = (userConfig) => Effect.gen(function* () {
+	const fs = yield* FileSystem;
+	const config = {
+		...DEFAULT_CONFIG,
+		dbPath: userConfig.path,
+		tmpDir: path.join(userConfig.path, ".tmp"),
+		maxPageSize: userConfig.maxPageSize ?? 1024 * 1024,
+		checkReferences: userConfig.checkReferences ?? false
+	};
+	const lockNonce = yield* Effect.tryPromise({
+		try: () => acquireLock(config.dbPath),
+		catch: (e) => e
+	});
+	yield* fs.makeDirectory(config.tmpDir, { recursive: true });
+	yield* traceKyju("kyju:db.init.dir-setup", Effect.gen(function* () {
+		if (userConfig.sections) {
+			const names = userConfig.sections.map((s) => s.name);
+			const dupes = names.filter((n, i) => names.indexOf(n) !== i);
+			if (dupes.length > 0) throw new Error(`Duplicate section names: ${[...new Set(dupes)].join(", ")}`);
+			yield* initializeSectionedDbIfNeeded(fs, config, userConfig.sections);
+		} else if (userConfig.schema) yield* initializeDbIfNeeded(fs, config, userConfig.schema);
+	}));
+	yield* traceKyju("kyju:db.init.tmp-cleanup", cleanupStaleTmpFiles(fs, config.tmpDir).pipe(Effect.catchAll((err) => {
+		console.error("[kyju:db] tmp sweep failed (non-fatal):", err);
+		return Effect.void;
+	})));
+	const sessionsRef = yield* Ref.make(/* @__PURE__ */ new Map());
+	const rootMutex = yield* Effect.makeSemaphore(1);
+	const collectionMutex = yield* Effect.makeSemaphore(1);
+	const blobMutex = yield* Effect.makeSemaphore(1);
+	const latch = yield* Effect.makeLatch(false);
+	const rootCache = yield* traceKyju("kyju:db.init.make-cache", makeRootCache(fs, config, rootMutex));
+	const ctx = {
+		fs,
+		config,
+		sessionsRef,
+		rootMutex,
+		collectionMutex,
+		blobMutex,
+		dbSend: userConfig.send,
+		rootCache
+	};
+	const postMessageEffect = (event) => Effect.gen(function* () {
+		switch (event.kind) {
+			case "connect": return yield* handleConnect(ctx, event, latch);
+			case "disconnect": return yield* handleDisconnect(ctx, event);
+			case "subscribe-collection": return yield* handleSubscribe(ctx, event);
+			case "unsubscribe-collection": return yield* handleUnsubscribe(ctx, event);
+			case "write": return yield* handleWrite(ctx, event);
+			case "read": return yield* handleRead(ctx, event);
+		}
+	}).pipe(Effect.catchAll((err) => {
+		console.error("[kyju:db] unhandled error in postMessage handler:", err);
+		return Effect.void;
+	}));
+	const reconnectClientsEffect = Effect.gen(function* () {
+		broadcastDbUpdate({
+			sessions: yield* Ref.get(sessionsRef),
+			message: { type: "reconnect" }
+		});
+	});
+	let plugins;
+	if (userConfig.sections) plugins = [sectionMigrationPlugin(userConfig.sections), ...userConfig.plugins ?? []];
+	else plugins = [migrationPlugin(userConfig.migrations ?? []), ...userConfig.plugins ?? []];
+	const localReplica = yield* traceKyju("kyju:db.init.run-plugins", runPlugins(ctx, postMessageEffect, plugins));
+	yield* latch.open;
+	yield* traceKyju("kyju:db.init.final-flush", rootCache.flush());
+	const client = createClient(localReplica);
+	const effectClient = createEffectClient(localReplica);
+	let closed = false;
+	const onProcessExit = () => {
+		if (closed) return;
+		closed = true;
+		releaseLockOnExit(config.dbPath, lockNonce);
+	};
+	process.once("exit", onProcessExit);
+	const close = async () => {
+		if (closed) return;
+		closed = true;
+		try {
+			await Effect.runPromise(rootCache.flush());
+		} catch (err) {
+			console.error("[kyju:db.close] final flush failed:", err);
+		}
+		process.off("exit", onProcessExit);
+		await releaseLock(config.dbPath, lockNonce);
+	};
+	return {
+		postMessage: (event) => Effect.runPromise(postMessageEffect(event)),
+		reconnectClients: () => Effect.runPromise(reconnectClientsEffect),
+		flush: () => Effect.runPromise(rootCache.flush()),
+		close,
+		client,
+		effectClient
+	};
+});
+const createDb = async (config) => {
+	return Effect.runPromise(createDbEffect(config).pipe(Effect.provide(layer)));
+};
+//#endregion
+//#region ../kyju/src/cli/loader.ts
+function pad(n, width = 4) {
+	return String(n).padStart(width, "0");
+}
+function readJournalFromDir(dir) {
+	const journalPath = path.join(dir, "meta", "_journal.json");
+	if (!fs.existsSync(journalPath)) return {
+		version: "1",
+		entries: []
+	};
+	return JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+}
+/**
+* Load migrations from a kyju output directory by reading the journal
+* and dynamically importing each migration file in order.
+*/
+async function loadMigrationsFromDir(dir) {
+	const absDir = path.resolve(dir);
+	const journal = readJournalFromDir(absDir);
+	if (journal.entries.length === 0) return [];
+	const migrations = [];
+	for (const entry of journal.entries) {
+		const base = `${pad(entry.idx)}_${entry.tag}`;
+		const candidates = [
+			".ts",
+			".js",
+			".mjs"
+		];
+		let filePath = null;
+		for (const ext of candidates) {
+			const candidate = path.join(absDir, base + ext);
+			if (fs.existsSync(candidate)) {
+				filePath = candidate;
+				break;
+			}
+		}
+		if (!filePath) throw new Error(`Migration file not found for entry ${entry.idx} (${entry.tag}) in ${absDir}`);
+		const mod = await import(pathToFileURL(filePath).href);
+		const migration = mod.default ?? mod;
+		migrations.push(migration);
+	}
+	return migrations;
+}
+//#endregion
+//#region src/shared/db-registry.ts
+const DEFAULT_REGISTRY = {
+	defaultDbPath: null,
+	dbs: []
+};
+function normalize(p) {
+	return path.resolve(p);
+}
+async function ensureDir() {
+	await fsp.mkdir(INTERNAL_DIR, { recursive: true });
+}
+async function loadRegistry() {
+	let raw;
+	try {
+		const text = await fsp.readFile(DB_CONFIG_JSON, "utf8");
+		raw = JSON.parse(text);
+	} catch {
+		return { ...DEFAULT_REGISTRY };
+	}
+	if (!raw || typeof raw !== "object") return { ...DEFAULT_REGISTRY };
+	const obj = raw;
+	if (typeof obj.dbPath === "string" && obj.defaultDbPath === void 0 && obj.dbs === void 0) {
+		const p = normalize(obj.dbPath);
+		const upgraded = {
+			defaultDbPath: p,
+			dbs: [{
+				path: p,
+				lastUsedAt: Date.now()
+			}]
+		};
+		await saveRegistry(upgraded);
+		return upgraded;
+	}
+	return {
+		defaultDbPath: typeof obj.defaultDbPath === "string" ? normalize(obj.defaultDbPath) : null,
+		dbs: Array.isArray(obj.dbs) ? obj.dbs.filter((e) => !!e && typeof e === "object" && typeof e.path === "string").map((e) => ({
+			path: normalize(e.path),
+			lastUsedAt: typeof e.lastUsedAt === "number" ? e.lastUsedAt : 0
+		})) : []
+	};
+}
+async function saveRegistry(reg) {
+	await ensureDir();
+	await fsp.writeFile(DB_CONFIG_JSON, JSON.stringify(reg, null, 2));
+}
+async function addDb(absPath) {
+	const p = normalize(absPath);
+	await fsp.mkdir(p, { recursive: true });
+	const reg = await loadRegistry();
+	const now = Date.now();
+	const existing = reg.dbs.find((e) => e.path === p);
+	if (existing) existing.lastUsedAt = now;
+	else reg.dbs.push({
+		path: p,
+		lastUsedAt: now
+	});
+	await saveRegistry(reg);
+	return reg;
+}
+const FLAG_PREFIX = "--zen-db-path=";
+/**
+* Resolve the active DB path. The app's `config.json` is the single source of
+* truth: every project that uses Zenbu must declare `"db": "<path>"` (relative
+* to `config.json` or absolute). The only override is `--zen-db-path=<x>` for
+* one-off dev runs (e.g. `zen --db /tmp/scratch .`). There is no global
+* fallback by design — we don't want a project's data location to depend on
+* the developer's machine state.
+*
+* The recently-used registry at `~/.zenbu/.internal/db.json` is *only* a
+* convenience index for `zen db list / pick` navigation; it does not drive
+* resolution.
+*
+* Always mkdir -p before returning so DbService can hand the path straight to
+* kyju without an extra existence check.
+*/
+async function resolveDbPath(argv, app) {
+	for (const arg of argv) if (arg.startsWith(FLAG_PREFIX)) {
+		const p = normalize(arg.slice(14));
+		await fsp.mkdir(p, { recursive: true });
+		return {
+			path: p,
+			source: "flag"
+		};
+	}
+	if (!app.configDb || typeof app.configDb !== "string") throw new Error(`Zenbu config is missing the required "db" field at ${app.configPath}.\nAdd a relative or absolute path, e.g. \`{ "db": "./.zenbu/db", "plugins": [...] }\`.`);
+	const resolved = normalize(path.isAbsolute(app.configDb) ? app.configDb : path.resolve(app.configDir, app.configDb));
+	await fsp.mkdir(resolved, { recursive: true });
+	return {
+		path: resolved,
+		source: "config"
+	};
+}
+//#endregion
+//#region src/services/http.ts
+const log$3 = createLogger("http");
+var HttpService = class extends Service {
+	static key = "http";
+	static deps = {
+		server: ServerService,
+		reloader: ReloaderService
+	};
+	connectedCallbacks = [];
+	disconnectedCallbacks = [];
+	activeConnections = /* @__PURE__ */ new Map();
+	requestHandlers = /* @__PURE__ */ new Map();
+	get port() {
+		return this.ctx.server.port;
+	}
+	get authToken() {
+		return this.ctx.server.authToken;
+	}
+	addRequestHandler(prefix, handler) {
+		this.requestHandlers.set(prefix, handler);
+		return () => {
+			this.requestHandlers.delete(prefix);
+		};
+	}
+	onConnected(cb) {
+		this.connectedCallbacks.push(cb);
+		return () => {
+			this.connectedCallbacks = this.connectedCallbacks.filter((f) => f !== cb);
+		};
+	}
+	onDisconnected(cb) {
+		this.disconnectedCallbacks.push(cb);
+		return () => {
+			this.disconnectedCallbacks = this.disconnectedCallbacks.filter((f) => f !== cb);
+		};
+	}
+	evaluate() {
+		this.connectedCallbacks = [];
+		this.disconnectedCallbacks = [];
+		const { server } = this.ctx;
+		performance.now();
+		this.setup("proxy", () => {
+			const viteAgent = new http.Agent({
+				keepAlive: true,
+				maxSockets: 20
+			});
+			const handler = (req, res) => {
+				const url = req.url ?? "/";
+				for (const [prefix, routeHandler] of this.requestHandlers) if (url.startsWith(prefix)) {
+					routeHandler(req, res);
+					return;
+				}
+				const coreEntry = this.ctx.reloader.get("app");
+				if (!coreEntry) {
+					res.writeHead(503);
+					res.end("Vite server not ready");
+					return;
+				}
+				const reloaderUrl = coreEntry.url.replace(/\/$/, "");
+				const target = new URL(url, reloaderUrl);
+				const proxyHeaders = {
+					...req.headers,
+					host: target.host
+				};
+				const proxyReq = http.request(target, {
+					method: req.method,
+					headers: proxyHeaders,
+					agent: viteAgent
+				}, (proxyRes) => {
+					res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+					proxyRes.pipe(res);
+				});
+				proxyReq.on("error", () => {
+					res.writeHead(502);
+					res.end("Bad Gateway");
+				});
+				req.pipe(proxyReq);
+			};
+			server.server.on("request", handler);
+			return () => {
+				server.server.off("request", handler);
+				viteAgent.destroy();
+			};
+		});
+		this.setup("vite-hmr-proxy", () => {
+			return server.addUpgradeHandler((req, socket, head) => {
+				const protocols = req.headers["sec-websocket-protocol"];
+				if (!protocols || !protocols.includes("vite-hmr")) return false;
+				const coreEntry = this.ctx.reloader.get("app");
+				if (!coreEntry) {
+					socket.destroy();
+					return true;
+				}
+				const target = new URL(coreEntry.url);
+				const proxyReq = http.request({
+					hostname: target.hostname,
+					port: target.port,
+					path: req.url,
+					method: req.method,
+					headers: {
+						...req.headers,
+						host: target.host
+					}
+				});
+				proxyReq.on("upgrade", (_res, proxySocket, proxyHead) => {
+					socket.write(`HTTP/1.1 101 Switching Protocols\r\n` + Object.entries(_res.headers).map(([k, v]) => `${k}: ${v}`).join("\r\n") + "\r\n\r\n");
+					if (proxyHead.length) socket.write(proxyHead);
+					proxySocket.pipe(socket).pipe(proxySocket);
+				});
+				proxyReq.on("error", () => socket.destroy());
+				proxyReq.end(head);
+				return true;
+			});
+		});
+		this.setup("ws-dispatch", () => {
+			const onConnection = (ws, req) => {
+				const id = nanoid();
+				this.activeConnections.set(id, ws);
+				for (const cb of this.connectedCallbacks) cb(id, ws);
+				ws.on("close", () => {
+					this.activeConnections.delete(id);
+					for (const cb of this.disconnectedCallbacks) cb(id);
+				});
+			};
+			server.wss.on("connection", onConnection);
+			return () => {
+				server.wss.off("connection", onConnection);
+			};
+		});
+		log$3.verbose(`service ready on port ${this.port}`);
+	}
+};
+runtime.register(HttpService, import.meta);
+//#endregion
+//#region src/services/db.ts
+const log$2 = createLogger("db");
+/**
+* Walk up from this file's location until we hit the @zenbujs/core
+* package.json. Same trick as `loaders/zenbu.ts` and `vite-plugins.ts`;
+* worth deduping into a shared helper once we have a fourth caller.
+*/
+async function findCorePackageRoot() {
+	const here = path.dirname(fileURLToPath(import.meta.url));
+	let dir = path.resolve(here, "..", "..");
+	while (dir !== path.dirname(dir)) {
+		const pkg = path.join(dir, "package.json");
+		try {
+			if (JSON.parse(await fsp.readFile(pkg, "utf8")).name === "@zenbujs/core") return dir;
+		} catch {}
+		dir = path.dirname(dir);
+	}
+	return path.resolve(here, "..", "..");
+}
+/**
+* Build the core's DB section from the schema in this package + any
+* migrations shipped in `<core>/migrations/`. Loaded via tsx (registered
+* by setup-gate before the runtime services boot), so the source `.ts`
+* files in the published package are imported directly with no extra
+* compile step.
+*
+* If the migrations directory is missing (e.g. before the first
+* `npm run db:generate` runs in the core package), the section degrades
+* to `migrations: []` — same behavior as before this builder existed.
+*/
+async function buildCoreSection() {
+	const corePackageRoot = await findCorePackageRoot();
+	const migrationsDir = path.join(corePackageRoot, "migrations");
+	let migrations = [];
+	try {
+		await fsp.access(migrationsDir);
+		migrations = await loadMigrationsFromDir(migrationsDir);
+	} catch {}
+	return {
+		name: "core",
+		schema,
+		migrations
+	};
+}
+async function resolveManifestModulePath(baseDir, specifier) {
+	const resolved = path.resolve(baseDir, specifier);
+	const candidates = path.extname(resolved) ? [resolved] : [
+		resolved,
+		`${resolved}.ts`,
+		`${resolved}.js`,
+		`${resolved}.mjs`,
+		path.join(resolved, "index.ts"),
+		path.join(resolved, "index.js"),
+		path.join(resolved, "index.mjs")
+	];
+	for (const candidate of candidates) try {
+		const stat = await fsp.stat(candidate);
+		if (stat.isFile() || stat.isDirectory()) return candidate;
+	} catch {}
+	throw new Error(`Could not resolve module entry for "${specifier}" from "${baseDir}"`);
+}
+async function importFreshModule(modulePath) {
+	return import(pathToFileURL(modulePath).href);
+}
+async function resolveConfigPath$1() {
+	if (process.env.ZENBU_CONFIG_PATH) return process.env.ZENBU_CONFIG_PATH;
+	const jsonc = path.join(os.homedir(), ".zenbu", "config.jsonc");
+	try {
+		await fsp.access(jsonc);
+		return jsonc;
+	} catch {
+		return path.join(os.homedir(), ".zenbu", "config.json");
+	}
+}
+async function loadAppConfig(configPath) {
+	let raw;
+	try {
+		raw = parseJsonc$2(await fsp.readFile(configPath, "utf8"));
+	} catch (err) {
+		throw new Error(`Failed to read Zenbu config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (!raw || typeof raw !== "object") throw new Error(`Zenbu config at ${configPath} is not a JSON object`);
+	const obj = raw;
+	const plugins = Array.isArray(obj.plugins) ? obj.plugins.filter((p) => typeof p === "string") : [];
+	return {
+		db: typeof obj.db === "string" ? obj.db : "",
+		plugins
+	};
+}
+function parseJsonc$2(str) {
+	let result = "";
+	let i = 0;
+	while (i < str.length) if (str[i] === "\"") {
+		let j = i + 1;
+		while (j < str.length) if (str[j] === "\\") j += 2;
+		else if (str[j] === "\"") {
+			j++;
+			break;
+		} else j++;
+		result += str.slice(i, j);
+		i = j;
+	} else if (str[i] === "/" && str[i + 1] === "/") {
+		i += 2;
+		while (i < str.length && str[i] !== "\n") i++;
+	} else if (str[i] === "/" && str[i + 1] === "*") {
+		i += 2;
+		while (i < str.length && !(str[i] === "*" && str[i + 1] === "/")) i++;
+		i += 2;
+	} else {
+		result += str[i];
+		i++;
+	}
+	return JSON.parse(result.replace(/,\s*([\]}])/g, "$1"));
+}
+async function discoverSections(configPath) {
+	const resolvedConfigPath = configPath ?? await resolveConfigPath$1();
+	let config = { plugins: [] };
+	try {
+		config = parseJsonc$2(await fsp.readFile(resolvedConfigPath, "utf8"));
+	} catch (error) {
+		log$2.error(`failed to read plugin config at ${resolvedConfigPath}: ${error instanceof Error ? error.message : String(error)}`);
+		return [];
+	}
+	const perPluginTimings = [];
+	const tasks = config.plugins.map(async (manifestPath) => {
+		const pluginStart = Date.now();
+		let manifestMs = 0;
+		let resolveSchemaMs = 0;
+		let importSchemaMs = 0;
+		let resolveMigrationsMs = 0;
+		let importMigrationsMs = 0;
+		let pluginName = path.basename(path.dirname(manifestPath));
+		try {
+			const t0 = Date.now();
+			const raw = await fsp.readFile(manifestPath, "utf8");
+			manifestMs = Date.now() - t0;
+			const manifest = JSON.parse(raw);
+			pluginName = manifest.name ?? pluginName;
+			if (!manifest.name || !manifest.schema) {
+				log$2.error(`skipping manifest without name/schema: ${manifestPath}`);
+				return null;
+			}
+			const baseDir = path.dirname(path.resolve(manifestPath));
+			const schemaChain = (async () => {
+				const s0 = Date.now();
+				const schemaPath = await resolveManifestModulePath(baseDir, manifest.schema);
+				resolveSchemaMs = Date.now() - s0;
+				const s1 = Date.now();
+				const schemaModule = await importFreshModule(schemaPath);
+				importSchemaMs = Date.now() - s1;
+				return {
+					schemaPath,
+					schemaModule
+				};
+			})();
+			const migrationsChain = manifest.migrations ? (async () => {
+				try {
+					const m0 = Date.now();
+					const migrationsPath = await resolveManifestModulePath(baseDir, manifest.migrations);
+					resolveMigrationsMs = Date.now() - m0;
+					const m1 = Date.now();
+					const stat = await fsp.stat(migrationsPath);
+					let migrations;
+					if (stat.isDirectory()) migrations = await loadMigrationsFromDir(migrationsPath);
+					else {
+						const migModule = await importFreshModule(migrationsPath);
+						migrations = migModule.migrations ?? migModule.default ?? [];
+					}
+					importMigrationsMs = Date.now() - m1;
+					return {
+						migrations,
+						failed: false
+					};
+				} catch (error) {
+					log$2.error(`failed to load migrations from ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+					return {
+						migrations: [],
+						failed: true
+					};
+				}
+			})() : Promise.resolve({
+				migrations: [],
+				failed: false
+			});
+			const [schemaResult, migrationsResult] = await Promise.all([schemaChain, migrationsChain]);
+			if (migrationsResult.failed) return null;
+			const schema = schemaResult.schemaModule.schema ?? schemaResult.schemaModule.default;
+			if (!schema?.shape) {
+				log$2.error(`schema module did not export a valid schema: ${schemaResult.schemaPath}`);
+				return null;
+			}
+			return {
+				name: manifest.name,
+				schema,
+				migrations: migrationsResult.migrations
+			};
+		} catch (error) {
+			log$2.error(`failed to load section from ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+			return null;
+		} finally {
+			perPluginTimings.push({
+				name: pluginName,
+				manifestMs,
+				resolveSchemaMs,
+				importSchemaMs,
+				resolveMigrationsMs,
+				importMigrationsMs,
+				totalMs: Date.now() - pluginStart
+			});
+		}
+	});
+	const sections = (await Promise.all(tasks)).filter((s) => s !== null);
+	const sorted = [...perPluginTimings].sort((a, b) => b.totalMs - a.totalMs);
+	const sum = (k) => perPluginTimings.reduce((acc, p) => acc + p[k], 0);
+	log$2.verbose("per-plugin breakdown (ms, parallel):");
+	log$2.verbose(`  ${"plugin".padEnd(28)} ${"total".padStart(6)} ${"man".padStart(5)} ${"resS".padStart(5)} ${"impS".padStart(6)} ${"resM".padStart(5)} ${"impM".padStart(6)}`);
+	for (const p of sorted) log$2.verbose(`  ${p.name.padEnd(28)} ${String(p.totalMs).padStart(6)} ${String(p.manifestMs).padStart(5)} ${String(p.resolveSchemaMs).padStart(5)} ${String(p.importSchemaMs).padStart(6)} ${String(p.resolveMigrationsMs).padStart(5)} ${String(p.importMigrationsMs).padStart(6)}`);
+	log$2.verbose(`  ${"SUM(cpu)".padEnd(28)} ${String(sum("totalMs")).padStart(6)} ${String(sum("manifestMs")).padStart(5)} ${String(sum("resolveSchemaMs")).padStart(5)} ${String(sum("importSchemaMs")).padStart(6)} ${String(sum("resolveMigrationsMs")).padStart(5)} ${String(sum("importMigrationsMs")).padStart(6)}`);
+	log$2.verbose(`  (wall time: look at db.discover-sections span — should be ~max(totalMs) not SUM)`);
+	return sections;
+}
+var DbService = class extends Service {
+	static key = "db";
+	static deps = { http: HttpService };
+	db = null;
+	dbRouter = null;
+	sectionsHash = "";
+	_dbPath = null;
+	/**
+	* Resolved DB path. Throws if accessed before `evaluate()` has run — the
+	* service contract guarantees deps are evaluated before dependents, so any
+	* access from a dependent service or RPC handler is safe.
+	*/
+	get dbPath() {
+		if (this._dbPath === null) throw new Error("DbService.dbPath accessed before evaluate()");
+		return this._dbPath;
+	}
+	get client() {
+		return this.db.client;
+	}
+	get effectClient() {
+		return this.db.effectClient;
+	}
+	/**
+	* Drain kyju's lagged-persistence queue. Safe to call anytime; idempotent
+	* when nothing is pending. Used by service teardown (effect cleanup) so
+	* shutdown / hot-reload don't lose in-memory writes.
+	*/
+	async flush() {
+		if (!this.db) return;
+		try {
+			await this.db.flush();
+		} catch (err) {
+			log$2.error("flush failed:", err);
+		}
+	}
+	/**
+	* Flush + release the kyju cross-process lock at `<dbPath>/.lock`.
+	* Called on service teardown so a subsequent process can open the DB
+	* without seeing a stale lock. Idempotent.
+	*/
+	async close() {
+		if (!this.db) return;
+		try {
+			await this.db.close();
+		} catch (err) {
+			log$2.error("close failed:", err);
+		}
+	}
+	async evaluate() {
+		const configPath = await resolveConfigPath$1();
+		const configDir = path.dirname(configPath);
+		const appConfig = await loadAppConfig(configPath);
+		const [coreSec, pluginSections, resolved] = await Promise.all([
+			this.trace("build-core-section", () => buildCoreSection()),
+			this.trace("discover-sections", () => discoverSections(configPath)),
+			resolveDbPath(process.argv, {
+				configDb: appConfig.db,
+				configDir,
+				configPath
+			})
+		]);
+		const sections = [coreSec, ...pluginSections];
+		const sectionsHash = JSON.stringify(sections.map((s) => ({
+			name: s.name,
+			v: s.migrations.length
+		})));
+		const dbPath = resolved.path;
+		if (!this.db || this.sectionsHash !== sectionsHash || this._dbPath !== dbPath) {
+			if (this.db) try {
+				await this.db.close();
+			} catch (err) {
+				log$2.error("close of previous db failed:", err);
+			}
+			this.dbRouter = createRouter();
+			this.db = await this.trace("create-db", () => createDb({
+				sections,
+				path: dbPath,
+				send: (event) => this.dbRouter.send(event)
+			}));
+			this.sectionsHash = sectionsHash;
+			this._dbPath = dbPath;
+			addDb(dbPath).catch((err) => {
+				log$2.error("failed to bump registry lastUsedAt:", err);
+			});
+			log$2.verbose(`ready at ${dbPath} (source: ${resolved.source}, sections: ${sections.map((s) => `${s.name}@v${s.migrations.length}`).join(", ")})`);
+		}
+		const { http } = this.ctx;
+		const wsDbConnections = /* @__PURE__ */ new Map();
+		this.setup("kyju-close-on-cleanup", () => async () => {
+			await this.close();
+		});
+		this.setup("ws-transport", () => {
+			const onConnected = (id, ws) => {
+				const dbConn = this.dbRouter.connection({
+					send: (event) => {
+						if (ws.readyState === ws.OPEN) ws.send(dbStringify({
+							ch: "db",
+							data: event
+						}));
+					},
+					postMessage: this.db.postMessage
+				});
+				wsDbConnections.set(id, dbConn);
+				ws.on("message", async (raw) => {
+					const msg = dbParse(String(raw));
+					if (msg.ch === "db") await dbConn.receive(msg.data);
+				});
+			};
+			const onDisconnected = (id) => {
+				const conn = wsDbConnections.get(id);
+				if (conn) {
+					conn.close();
+					wsDbConnections.delete(id);
+				}
+			};
+			const unsubConnected = http.onConnected(onConnected);
+			const unsubDisconnected = http.onDisconnected(onDisconnected);
+			for (const [id, ws] of http.activeConnections) onConnected(id, ws);
+			return () => {
+				unsubConnected();
+				unsubDisconnected();
+				for (const conn of wsDbConnections.values()) conn.close();
+				wsDbConnections.clear();
+			};
+		});
+	}
+};
+runtime.register(DbService, import.meta);
+//#endregion
+//#region src/services/view-registry.ts
+const log$1 = createLogger("view-registry");
+var ViewRegistryService = class extends Service {
+	static key = "view-registry";
+	static 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);
+		if (existing) {
+			log$1.verbose(`"${scope}" 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(`reloader created: ${reloaderEntry.url} (port ${reloaderEntry.port})`);
+		const entry = {
+			scope,
+			url: reloaderEntry.url,
+			port: reloaderEntry.port,
+			ownsServer: true,
+			meta
+		};
+		this.views.set(scope, entry);
+		await this.syncToDb();
+		log$1.verbose(`"${scope}" registered at ${entry.url}`);
+		return entry;
+	}
+	registerAlias(scope, reloaderId, pathPrefix, meta) {
+		const existing = this.views.get(scope);
+		if (existing) return existing;
+		const reloaderEntry = this.ctx.reloader.get(reloaderId);
+		if (!reloaderEntry) throw new Error(`Reloader "${reloaderId}" not found for alias "${scope}"`);
+		const entry = {
+			scope,
+			url: `${reloaderEntry.url}${pathPrefix}`,
+			port: reloaderEntry.port,
+			ownsServer: false,
+			meta
+		};
+		this.views.set(scope, entry);
+		this.syncToDb();
+		return entry;
+	}
+	async unregister(scope) {
+		const entry = this.views.get(scope);
+		if (!entry) return;
+		if (entry.ownsServer) await this.ctx.reloader.remove(scope);
+		this.views.delete(scope);
+		await this.syncToDb();
+	}
+	get(scope) {
+		return this.views.get(scope);
+	}
+	evaluate() {
+		this.loadManifestIcons().catch((err) => {});
+		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);
+				this.views.clear();
+				await this.syncToDb();
+			};
+		});
+	}
+	async loadManifestIcons() {
+		this.manifestIcons.clear();
+		try {
+			const configPath = await resolveConfigPath();
+			let raw;
+			try {
+				raw = await fsp.readFile(configPath, "utf8");
+			} catch {
+				return;
+			}
+			const config = parseJsonc$1(raw);
+			for (const manifestPath of config.plugins ?? []) try {
+				const manifestRaw = await fsp.readFile(manifestPath, "utf8");
+				const icons = JSON.parse(manifestRaw).icons ?? {};
+				for (const [scope, svg] of Object.entries(icons)) this.manifestIcons.set(scope, svg);
+			} catch {}
+		} catch {}
+	}
+	async syncToDb() {
+		const client = this.ctx.db.effectClient;
+		const snapshot = [...this.views.values()].map((e) => ({
+			scope: e.scope,
+			url: e.url,
+			port: e.port,
+			icon: this.manifestIcons.get(e.scope),
+			meta: e.meta
+		}));
+		await Effect.runPromise(client.update((root) => {
+			root.plugin.core.lastKnownViewRegistry = snapshot;
+		})).catch((err) => {});
+	}
+};
+async function resolveConfigPath() {
+	if (process.env.ZENBU_CONFIG_PATH) return process.env.ZENBU_CONFIG_PATH;
+	const jsonc = path.join(os.homedir(), ".zenbu", "config.jsonc");
+	try {
+		await fsp.access(jsonc);
+		return jsonc;
+	} catch {
+		return path.join(os.homedir(), ".zenbu", "config.json");
+	}
+}
+function parseJsonc$1(str) {
+	let result = "";
+	let i = 0;
+	while (i < str.length) if (str[i] === "\"") {
+		let j = i + 1;
+		while (j < str.length) if (str[j] === "\\") j += 2;
+		else if (str[j] === "\"") {
+			j++;
+			break;
+		} else j++;
+		result += str.slice(i, j);
+		i = j;
+	} else if (str[i] === "/" && str[i + 1] === "/") {
+		i += 2;
+		while (i < str.length && str[i] !== "\n") i++;
+	} else if (str[i] === "/" && str[i + 1] === "*") {
+		i += 2;
+		while (i < str.length && !(str[i] === "*" && str[i + 1] === "/")) i++;
+		i += 2;
+	} else {
+		result += str[i];
+		i++;
+	}
+	return JSON.parse(result.replace(/,\s*([\]}])/g, "$1"));
+}
+runtime.register(ViewRegistryService, import.meta);
+//#endregion
+//#region src/services/renderer-host.ts
+const log = createLogger("renderer-host");
+async function pathExists(filePath) {
+	try {
+		await fsp.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function parseJsonc(str) {
+	let result = "";
+	let i = 0;
+	while (i < str.length) if (str[i] === "\"") {
+		let j = i + 1;
+		while (j < str.length) if (str[j] === "\\") j += 2;
+		else if (str[j] === "\"") {
+			j++;
+			break;
+		} else j++;
+		result += str.slice(i, j);
+		i = j;
+	} else if (str[i] === "/" && str[i + 1] === "/") {
+		i += 2;
+		while (i < str.length && str[i] !== "\n") i++;
+	} else if (str[i] === "/" && str[i + 1] === "*") {
+		i += 2;
+		while (i < str.length && !(str[i] === "*" && str[i + 1] === "/")) i++;
+		i += 2;
+	} else {
+		result += str[i];
+		i++;
+	}
+	return JSON.parse(result.replace(/,\s*([\]}])/g, "$1"));
+}
+async function resolveRendererRoot() {
+	const configPath = process.env.ZENBU_CONFIG_PATH;
+	if (!configPath) throw new Error("ZENBU_CONFIG_PATH is required to resolve the app renderer");
+	const config = parseJsonc(await fsp.readFile(configPath, "utf8"));
+	const configDir = path.dirname(configPath);
+	for (const manifestRel of config.plugins ?? []) {
+		const resolvedManifest = path.isAbsolute(manifestRel) ? manifestRel : path.resolve(configDir, manifestRel);
+		try {
+			const manifest = JSON.parse(await fsp.readFile(resolvedManifest, "utf8"));
+			if (!manifest.uiEntrypoint) continue;
+			const projectDir = path.dirname(resolvedManifest);
+			const rendererDir = path.resolve(projectDir, manifest.uiEntrypoint);
+			const viteConfig = path.join(projectDir, "vite.config.ts");
+			const configFile = await pathExists(viteConfig) ? viteConfig : false;
+			if (!await pathExists(rendererDir)) continue;
+			return {
+				rendererRoot: rendererDir,
+				configFile
+			};
+		} catch {}
+	}
+	const rendererDir = path.resolve(configDir, "src", "renderer");
+	const viteConfig = path.join(configDir, "vite.config.ts");
+	if (await pathExists(rendererDir)) return {
+		rendererRoot: rendererDir,
+		configFile: await pathExists(viteConfig) ? viteConfig : false
+	};
+	throw new Error(`No renderer entrypoint found. Add uiEntrypoint to the app plugin manifest or create ${rendererDir}.`);
+}
+var RendererHostService = class extends Service {
+	static key = "renderer-host";
+	static deps = {
+		reloader: ReloaderService,
+		viewRegistry: ViewRegistryService
+	};
+	url = "";
+	port = 0;
+	async evaluate() {
+		const { rendererRoot, configFile } = await resolveRendererRoot();
+		const entry = await this.ctx.reloader.create("app", rendererRoot, configFile);
+		this.url = entry.url;
+		this.port = entry.port;
+		this.ctx.viewRegistry.registerAlias("app", "app", "", {
+			kind: "app",
+			label: "App"
+		});
+		log.verbose(`ready at ${this.url}`);
+	}
+};
+runtime.register(RendererHostService, import.meta);
+//#endregion
+export { resolveManifestModulePath as a, discoverSections as i, ViewRegistryService as n, HttpService as o, DbService as r, RendererHostService as t };