@zenbujs/core 0.0.3 → 0.0.5

package/dist/runtime.mjs

@@ -1,2 +1,522 @@
-import { a as serviceWithDeps, i as runtime, n as ServiceRuntime, r as optional, t as Service } from "./runtime-DUFKDIe4.mjs";
-export { Service, ServiceRuntime, optional, runtime, serviceWithDeps };
+//#region src/runtime.ts
+function optional(ref) {
+	return {
+		__optional: true,
+		ref
+	};
+}
+function resolveDep(entry) {
+	if (typeof entry === "string") return {
+		key: entry,
+		optional: false
+	};
+	if (typeof entry === "object" && entry !== null && "__optional" in entry) {
+		const ref = entry.ref;
+		return {
+			key: typeof ref === "string" ? ref : ref.key,
+			optional: true
+		};
+	}
+	return {
+		key: entry.key,
+		optional: false
+	};
+}
+var Service = class {
+	static key;
+	static deps;
+	ctx;
+	/** @internal */
+	__setupCleanups = /* @__PURE__ */ new Map();
+	evaluate() {}
+	setup(key, fn) {
+		const existing = this.__setupCleanups.get(key);
+		if (existing) try {
+			existing("reload");
+		} catch (e) {
+			console.error(`[hot] setup cleanup "${key}" failed:`, e);
+		}
+		const cleanup = fn();
+		if (cleanup) this.__setupCleanups.set(key, cleanup);
+		else this.__setupCleanups.delete(key);
+	}
+	/**
+	* Run `fn` and return its result. Historically reported a boot-trace span;
+	* now a thin wrapper preserved for caller ergonomics inside service
+	* `evaluate()` bodies.
+	*/
+	trace(_name, fn, _meta) {
+		return Promise.resolve(fn());
+	}
+	traceSync(_name, fn, _meta) {
+		return fn();
+	}
+	/** @internal */
+	async __cleanupAllSetups(reason = "shutdown") {
+		for (const [key, cleanup] of this.__setupCleanups) try {
+			await cleanup(reason);
+		} catch (e) {
+			console.error(`[hot] setup cleanup "${key}" failed:`, e);
+		}
+		this.__setupCleanups.clear();
+	}
+};
+/**
+* Declare a Service base class with typed deps. The returned class has
+* `static deps = <your map>` already set, and `this.ctx` is auto-typed
+* from the dep classes — no `declare ctx` needed in the subclass.
+*
+*     export class WindowService extends serviceWithDeps({
+*       baseWindow: BaseWindowService,
+*       http: HttpService,
+*     }) {
+*       static key = "window"
+*       evaluate() {
+*         this.ctx.baseWindow  // BaseWindowService
+*         this.ctx.http        // HttpService
+*       }
+*     }
+*
+* `optional(SomeService)` is supported and produces `Instance | undefined`.
+*/
+function serviceWithDeps(deps) {
+	class ServiceWithDeps extends Service {
+		static deps = deps;
+	}
+	return ServiceWithDeps;
+}
+const SERVICE_BASE_METHODS = new Set(Object.getOwnPropertyNames(Service.prototype));
+var ServiceRuntime = class {
+	definitions = /* @__PURE__ */ new Map();
+	dependentsIndex = /* @__PURE__ */ new Map();
+	dirtyKeys = /* @__PURE__ */ new Set();
+	drainError = null;
+	draining = null;
+	registrationTokens = /* @__PURE__ */ new Map();
+	slots = /* @__PURE__ */ new Map();
+	onReconciledCallbacks = [];
+	register(ServiceClass, importMeta) {
+		const hot = importMeta?.hot ?? null;
+		const baseKey = ServiceClass.key;
+		if (!baseKey) throw new Error("Service must have a static key property");
+		const slotKey = baseKey;
+		this.definitions.set(slotKey, ServiceClass);
+		const slot = this.slots.get(slotKey);
+		if (slot) slot.ServiceClass = ServiceClass;
+		else this.slots.set(slotKey, {
+			error: null,
+			instance: null,
+			ServiceClass,
+			status: "blocked"
+		});
+		this.rebuildDependentsIndex();
+		hot?.accept();
+		const token = Symbol(slotKey);
+		this.registrationTokens.set(slotKey, token);
+		hot?.prune?.(() => {
+			this.unregister(slotKey, token);
+		});
+		this.scheduleReconcile([slotKey]);
+	}
+	getAllKeys() {
+		return [...this.slots.keys()];
+	}
+	getSlot(key) {
+		return this.slots.get(key);
+	}
+	async whenIdle() {
+		while (this.draining) await this.draining;
+		if (this.drainError) {
+			const error = this.drainError;
+			this.drainError = null;
+			throw error;
+		}
+	}
+	async reloadAll() {
+		const keys = [...this.slots.keys()];
+		if (keys.length === 0) return;
+		await this.scheduleReconcile(keys);
+		await this.whenIdle();
+	}
+	async shutdown() {
+		try {
+			await this.whenIdle();
+		} catch (error) {
+			console.error("[hot] runtime idle wait failed during shutdown:", error);
+		}
+		const keys = [...this.slots.keys()].reverse();
+		for (const key of keys) await this.teardownService(key, { removeSlot: true });
+		this.definitions.clear();
+		this.dependentsIndex.clear();
+		this.dirtyKeys.clear();
+		this.registrationTokens.clear();
+	}
+	get(ref) {
+		const slot = this.slots.get(ref.key);
+		if (!slot || slot.status !== "ready" || !slot.instance) throw new Error(`Service "${ref.key}" not ready. Is it registered and evaluated?`);
+		return slot.instance;
+	}
+	buildRouter() {
+		const router = {};
+		for (const [slotKey, slot] of this.slots) {
+			if (slot.status !== "ready" || !slot.instance) continue;
+			const proto = Object.getPrototypeOf(slot.instance);
+			const methods = {};
+			for (const name of Object.getOwnPropertyNames(proto)) {
+				if (SERVICE_BASE_METHODS.has(name)) continue;
+				if (name.startsWith("_")) continue;
+				const desc = Object.getOwnPropertyDescriptor(proto, name);
+				if (!desc || typeof desc.value !== "function") continue;
+				const instance = slot.instance;
+				methods[name] = (...args) => instance[name](...args);
+			}
+			if (Object.keys(methods).length > 0) router[slotKey] = methods;
+		}
+		return router;
+	}
+	onReconciled(cb) {
+		this.onReconciledCallbacks.push(cb);
+		return () => {
+			const idx = this.onReconciledCallbacks.indexOf(cb);
+			if (idx >= 0) this.onReconciledCallbacks.splice(idx, 1);
+		};
+	}
+	resolveDepSlot(depKey) {
+		return this.slots.get(depKey);
+	}
+	injectCtx(instance, ServiceClass) {
+		const deps = ServiceClass.deps ?? {};
+		const ctx = {};
+		for (const [name, entry] of Object.entries(deps)) {
+			const { key, optional: isOptional } = resolveDep(entry);
+			const slot = this.resolveDepSlot(key);
+			if (!slot || slot.status !== "ready" || !slot.instance) {
+				if (isOptional) {
+					ctx[name] = void 0;
+					continue;
+				}
+				throw new Error(`Dependency "${key}" not ready for "${ServiceClass.key}"`);
+			}
+			ctx[name] = slot.instance;
+		}
+		instance.ctx = ctx;
+	}
+	rebuildDependentsIndex() {
+		const next = /* @__PURE__ */ new Map();
+		for (const [slotKey, ServiceClass] of this.definitions) {
+			const deps = ServiceClass.deps ?? {};
+			for (const entry of Object.values(deps)) {
+				const { key: depKey } = resolveDep(entry);
+				const dependents = next.get(depKey) ?? /* @__PURE__ */ new Set();
+				dependents.add(slotKey);
+				next.set(depKey, dependents);
+			}
+		}
+		this.dependentsIndex = next;
+	}
+	getAffectedKeys(changedKeys) {
+		const affected = /* @__PURE__ */ new Set();
+		const visit = (key) => {
+			if (affected.has(key)) return;
+			affected.add(key);
+			for (const dependent of this.dependentsIndex.get(key) ?? []) visit(dependent);
+		};
+		for (const key of changedKeys) visit(key);
+		return [...affected].filter((key) => this.definitions.has(key));
+	}
+	listMissingDeps(ServiceClass) {
+		const deps = ServiceClass.deps ?? {};
+		const missing = [];
+		for (const entry of Object.values(deps)) {
+			const { key, optional: isOptional } = resolveDep(entry);
+			if (isOptional) continue;
+			const slot = this.resolveDepSlot(key);
+			if (!slot || slot.status !== "ready" || !slot.instance) missing.push(key);
+		}
+		return missing;
+	}
+	ensureSlot(key, ServiceClass) {
+		const existing = this.slots.get(key);
+		if (existing) return existing;
+		const slot = {
+			error: null,
+			instance: null,
+			ServiceClass,
+			status: "blocked"
+		};
+		this.slots.set(key, slot);
+		return slot;
+	}
+	async teardownService(key, options = {}) {
+		const slot = this.slots.get(key);
+		if (!slot) return;
+		const instance = slot.instance;
+		slot.instance = null;
+		slot.status = "blocked";
+		slot.error = null;
+		if (instance) await instance.__cleanupAllSetups(options.reason ?? "shutdown");
+		if (options.removeSlot) this.slots.delete(key);
+	}
+	async unregister(key, token) {
+		if (this.registrationTokens.get(key) !== token) return;
+		this.registrationTokens.delete(key);
+		this.definitions.delete(key);
+		await this.teardownService(key, { removeSlot: true });
+		this.rebuildDependentsIndex();
+		await this.scheduleReconcile([key]);
+	}
+	async scheduleReconcile(keys) {
+		for (const key of keys) this.dirtyKeys.add(key);
+		if (this.draining) return this.draining;
+		this.draining = (async () => {
+			try {
+				while (this.dirtyKeys.size > 0) {
+					const batch = [...this.dirtyKeys];
+					this.dirtyKeys.clear();
+					await this.reconcileBatch(batch);
+				}
+			} catch (error) {
+				this.drainError = error;
+				console.error("[hot] runtime reconcile failed:", error);
+			} finally {
+				this.draining = null;
+				if (this.dirtyKeys.size > 0) this.scheduleReconcile([]);
+			}
+		})();
+		return this.draining;
+	}
+	async reconcileBatch(changedKeys) {
+		const affectedKeys = this.getAffectedKeys(changedKeys);
+		if (affectedKeys.length === 0) return;
+		const affected = /* @__PURE__ */ new Map();
+		for (const key of affectedKeys) {
+			const ServiceClass = this.definitions.get(key);
+			if (ServiceClass) affected.set(key, ServiceClass);
+		}
+		const levels = this.topologicalLevels(affected);
+		for (const level of [...levels].reverse()) await Promise.all(level.map(async (key) => {
+			const slot = this.slots.get(key);
+			if (slot?.instance) await slot.instance.__cleanupAllSetups("reload");
+		}));
+		for (const level of levels) await Promise.all(level.map((key) => this.reconcileKey(key)));
+		if (affectedKeys.length > 0) for (const cb of this.onReconciledCallbacks) try {
+			cb(affectedKeys);
+		} catch (e) {
+			console.error("[hot] onReconciled callback failed:", e);
+		}
+	}
+	async reconcileKey(key) {
+		const ServiceClass = this.definitions.get(key);
+		if (!ServiceClass) return;
+		const slot = this.ensureSlot(key, ServiceClass);
+		slot.ServiceClass = ServiceClass;
+		const missingDeps = this.listMissingDeps(ServiceClass);
+		if (missingDeps.length > 0) {
+			const shouldLog = slot.instance !== null || slot.status !== "blocked";
+			await this.teardownService(key, { reason: "reload" });
+			if (shouldLog) console.log(`[hot] ${key} waiting on: ${missingDeps.join(", ")}`);
+			return;
+		}
+		let instance = slot.instance;
+		if (!instance) {
+			instance = new ServiceClass();
+			slot.instance = instance;
+		} else Object.setPrototypeOf(instance, ServiceClass.prototype);
+		slot.status = "evaluating";
+		slot.error = null;
+		try {
+			await instance.__cleanupAllSetups("reload");
+			this.injectCtx(instance, ServiceClass);
+			await instance.evaluate();
+			slot.status = "ready";
+		} catch (e) {
+			slot.status = "failed";
+			slot.error = e;
+			console.error(`[hot] ${key} failed to evaluate:`, e);
+		}
+	}
+	topologicalLevels(services) {
+		const keys = new Set(services.keys());
+		const inDegree = /* @__PURE__ */ new Map();
+		const dependents = /* @__PURE__ */ new Map();
+		for (const key of keys) {
+			inDegree.set(key, 0);
+			dependents.set(key, []);
+		}
+		for (const [slotKey, ServiceClass] of services) {
+			const deps = ServiceClass.deps ?? {};
+			let degree = 0;
+			for (const entry of Object.values(deps)) {
+				const { key: depKey, optional: isOptional } = resolveDep(entry);
+				if (keys.has(depKey)) {
+					degree++;
+					dependents.get(depKey).push(slotKey);
+				} else if (isOptional) continue;
+			}
+			inDegree.set(slotKey, degree);
+		}
+		const levels = [];
+		let queue = [...keys].filter((k) => inDegree.get(k) === 0);
+		while (queue.length > 0) {
+			levels.push(queue);
+			const next = [];
+			for (const key of queue) for (const dep of dependents.get(key)) {
+				const d = inDegree.get(dep) - 1;
+				inDegree.set(dep, d);
+				if (d === 0) next.push(dep);
+			}
+			queue = next;
+		}
+		const resolved = levels.flat();
+		if (resolved.length !== keys.size) {
+			const missing = [...keys].filter((k) => !resolved.includes(k));
+			throw new Error(`Circular dependency detected involving: ${missing.join(", ")}`);
+		}
+		return levels;
+	}
+};
+/**
+* fixme: i don't think these commments make sense
+*/
+/**
+* Devtools-only handles, attached to the global so they aren't part of the
+* public `ServiceRuntime` autocomplete surface. Same shape React DevTools
+* uses (`__REACT_DEVTOOLS_GLOBAL_HOOK__`): user code reading
+* `runtime.<...>` never lands on these methods; you only find them if you
+* specifically type `globalThis.__zenbu_dev__`. Kept here (next to the
+* runtime that owns the state) because the hook reaches into private
+* implementation details — `scheduleReconcile` stays `private` on the
+* class; the cast lives inside the encapsulation boundary.
+*/
+function installDevHook(rt) {
+	const internals = rt;
+	globalThis.__zenbu_dev__ = { reloadService: async (key) => {
+		if (!internals.definitions.has(key)) throw new Error(`No service registered for key "${key}"`);
+		await internals.scheduleReconcile([key]);
+		await rt.whenIdle();
+	} };
+}
+const runtime = (() => {
+	const existing = globalThis.__zenbu_service_runtime__;
+	if (existing) {
+		Object.setPrototypeOf(existing, ServiceRuntime.prototype);
+		installDevHook(existing);
+		return existing;
+	}
+	const fresh = new ServiceRuntime();
+	globalThis.__zenbu_service_runtime__ = fresh;
+	installDevHook(fresh);
+	return fresh;
+})();
+function getPluginRegistry() {
+	const slot = globalThis;
+	if (!slot.__zenbu_plugin_registry__) slot.__zenbu_plugin_registry__ = {
+		plugins: /* @__PURE__ */ new Map(),
+		appEntrypoint: null,
+		splashPath: null,
+		subscribers: /* @__PURE__ */ new Set()
+	};
+	else if (!slot.__zenbu_plugin_registry__.subscribers) slot.__zenbu_plugin_registry__.subscribers = /* @__PURE__ */ new Set();
+	return slot.__zenbu_plugin_registry__;
+}
+function snapshotConfig(reg) {
+	return {
+		plugins: [...reg.plugins.values()],
+		appEntrypoint: reg.appEntrypoint,
+		splashPath: reg.splashPath
+	};
+}
+function notifySubscribers(reg) {
+	if (reg.subscribers.size === 0) return;
+	const snapshot = snapshotConfig(reg);
+	for (const cb of reg.subscribers) try {
+		cb(snapshot);
+	} catch (err) {
+		console.error("[zenbu config subscriber] threw:", err);
+	}
+}
+/**
+* Register a plugin's resolved manifest. Idempotent — replaces any existing
+* entry for the same `name`. Called by the loader-emitted barrel; user code
+* normally does not call this directly.
+*/
+function registerPlugin(record) {
+	const reg = getPluginRegistry();
+	reg.plugins.set(record.name, record);
+	notifySubscribers(reg);
+}
+/**
+* Drop a plugin from the registry. Used when the loader regenerates the
+* barrel and needs to clear stale entries.
+*/
+function unregisterPlugin(name) {
+	const reg = getPluginRegistry();
+	if (!reg.plugins.delete(name)) return;
+	notifySubscribers(reg);
+}
+/**
+* Replace the entire plugin set in one shot. The loader uses this on every
+* barrel regeneration so removed plugins disappear cleanly.
+*/
+function replacePlugins(records) {
+	const reg = getPluginRegistry();
+	reg.plugins.clear();
+	for (const record of records) reg.plugins.set(record.name, record);
+	notifySubscribers(reg);
+}
+function getPlugins() {
+	return [...getPluginRegistry().plugins.values()];
+}
+function getPlugin(name) {
+	return getPluginRegistry().plugins.get(name);
+}
+/**
+* Set the renderer entrypoint directory + the absolute path to splash.html
+* inside it. Called once by the loader-emitted barrel. Consumers
+* (`view-registry`, `vite-plugins`, `setup-gate`'s splash window) read
+* via `getAppEntrypoint()` / `getSplashPath()`.
+*/
+function registerAppEntrypoint(rendererDir, splashPath) {
+	const reg = getPluginRegistry();
+	reg.appEntrypoint = rendererDir;
+	reg.splashPath = splashPath;
+	notifySubscribers(reg);
+}
+function getAppEntrypoint() {
+	return getPluginRegistry().appEntrypoint;
+}
+function getSplashPath() {
+	return getPluginRegistry().splashPath;
+}
+/**
+* Snapshot of the current resolved config — plugins + entrypoints. Cheap;
+* just walks the in-memory registry. The returned object is a fresh copy,
+* safe to retain or pass through serialization boundaries.
+*/
+function getConfig() {
+	return snapshotConfig(getPluginRegistry());
+}
+/**
+* Subscribe to config changes. The callback fires:
+*   - immediately on subscription (with the current snapshot),
+*   - after each `replacePlugins(...)` / `registerPlugin(...)` /
+*     `registerAppEntrypoint(...)` call — i.e. every time the loader
+*     regenerates the plugin barrel after a `zenbu.config.ts` edit.
+*
+* Callback exceptions are logged and swallowed so one buggy subscriber
+* can't break others. The returned function unsubscribes.
+*/
+function subscribeConfig(callback) {
+	const reg = getPluginRegistry();
+	reg.subscribers.add(callback);
+	try {
+		callback(snapshotConfig(reg));
+	} catch (err) {
+		console.error("[zenbu config subscriber] initial fire threw:", err);
+	}
+	return () => {
+		reg.subscribers.delete(callback);
+	};
+}
+//#endregion
+export { Service, ServiceRuntime, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, optional, registerAppEntrypoint, registerPlugin, replacePlugins, runtime, serviceWithDeps, subscribeConfig, unregisterPlugin };

package/dist/{schema-DMoSkwUx.d.mts → schema-Dl85YjXW.d.mts}

@@ -1,4 +1,4 @@
-import { m as Field, v as Schema } from "./index-CPZ5d6Hl.mjs";
+import { m as Field, v as Schema } from "./index-M_lSNBrq.mjs";
 import zod from "zod";
 
 //#region src/schema.d.ts

package/dist/schema.d.mts

@@ -1,2 +1,2 @@
-import { a as WindowPrefs, i as WindowBounds, n as SchemaRoot, o as schema, r as ViewRegistryEntry, t as CoreSchema } from "./schema-DMoSkwUx.mjs";
+import { a as WindowPrefs, i as WindowBounds, n as SchemaRoot, o as schema, r as ViewRegistryEntry, t as CoreSchema } from "./schema-Dl85YjXW.mjs";
 export { CoreSchema, SchemaRoot, ViewRegistryEntry, WindowBounds, WindowPrefs, schema };

package/dist/schema.mjs

@@ -1,2 +1,28 @@
-import { t as schema } from "./schema-dGK6qkfR.mjs";
+import { a as f, i as createSchema } from "./schema-Ca7SxXgS.mjs";
+import zod from "zod";
+//#region src/schema.ts
+const viewRegistryEntrySchema = zod.object({
+	scope: zod.string(),
+	url: zod.string(),
+	port: zod.number(),
+	icon: zod.string().optional(),
+	meta: zod.object({
+		kind: zod.string().optional(),
+		sidebar: zod.boolean().optional(),
+		bottomPanel: zod.boolean().optional(),
+		label: zod.string().optional()
+	}).optional()
+});
+const windowBoundsSchema = zod.object({
+	x: zod.number(),
+	y: zod.number(),
+	width: zod.number(),
+	height: zod.number()
+});
+const windowPrefsSchema = zod.object({ lastKnownBounds: windowBoundsSchema.optional() });
+const schema = createSchema({
+	lastKnownViewRegistry: f.array(viewRegistryEntrySchema).default([]),
+	windowPrefs: f.record(zod.string(), windowPrefsSchema).default({})
+});
+//#endregion
 export { schema };

package/dist/{server-BXwZEQ-n.mjs → server-y3PPbh3l.mjs}

@@ -1,9 +1,11 @@
-import { i as runtime, t as Service } from "./runtime-DUFKDIe4.mjs";
-import { t as createLogger } from "./log-CyKv8hQg.mjs";
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { Service, runtime } from "./runtime.mjs";
+import { t as createLogger } from "./log-6rzaCV0I.mjs";
 import http from "node:http";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { WebSocketServer } from "ws";
 //#region src/services/server.ts
+var server_exports = /* @__PURE__ */ __exportAll({ ServerService: () => ServerService });
 const log = createLogger("server");
 var ServerService = class extends Service {
 	static key = "server";
@@ -63,4 +65,4 @@ var ServerService = class extends Service {
 };
 runtime.register(ServerService, import.meta);
 //#endregion
-export { ServerService as t };
+export { server_exports as n, ServerService as t };

package/dist/services/default.mjs

@@ -7,16 +7,16 @@
 * chance to bootstrap env vars and `process.chdir(projectRoot)`.
 */
 async function defaultServices() {
-	await import("../server-DjrZUbbu.mjs");
-	await import("../reloader-BCkLjDhS.mjs");
-	await import("../renderer-host-DpvBPTHJ.mjs");
-	await import("../http-IBcLzbYu.mjs");
-	await import("../db-ByKPbnP6.mjs");
-	await import("../base-window-DEIAk618.mjs");
-	await import("../rpc-CqitnyR4.mjs");
-	await import("../view-registry-BualWgAf.mjs");
-	await import("../window-CM2a9Kyc.mjs");
-	await import("../advice-config-Cy133IQP.mjs");
+	await import("../server-y3PPbh3l.mjs").then((n) => n.n);
+	await import("../reloader-DzEO8kJr.mjs").then((n) => n.n);
+	await import("../renderer-host-Cau9JK0v.mjs").then((n) => n.n);
+	await import("../renderer-host-Cau9JK0v.mjs").then((n) => n.c);
+	await import("../renderer-host-Cau9JK0v.mjs").then((n) => n.o);
+	await import("../base-window-BbFRRhKP.mjs").then((n) => n.r);
+	await import("../rpc-JfGv-Wuw.mjs").then((n) => n.n);
+	await import("../renderer-host-Cau9JK0v.mjs").then((n) => n.i);
+	await import("../window-o2NGUsIb.mjs").then((n) => n.n);
+	await import("../advice-config-QYB2qEd_.mjs").then((n) => n.t);
 }
 //#endregion
 export { defaultServices };

package/dist/services/index.d.mts

@@ -1,11 +1,11 @@
-import { c as EffectFieldNode, d as KyjuError, l as FieldNode, r as createRouter, t as Db } from "../index-CPZ5d6Hl.mjs";
-import { n as Service, t as CleanupReason } from "../runtime-CjqDr8Yf.mjs";
-import { o as ResolvedDbRoot, s as ResolvedEvents } from "../registry-Dh_e7HU1.mjs";
+import { i as Service, t as CleanupReason } from "../runtime-pCeVzj--.mjs";
+import { c as EffectFieldNode, d as KyjuError, l as FieldNode, r as createRouter, t as Db } from "../index-M_lSNBrq.mjs";
+import { o as ResolvedDbRoot, s as ResolvedEvents } from "../registry-eX6e2oql.mjs";
 import http from "node:http";
 import { WebSocket, WebSocketServer } from "ws";
 import { ViteDevServer } from "vite";
 import * as Effect from "effect/Effect";
-import { BaseWindow } from "electron";
+import { BaseWindow, WebPreferences } from "electron";
 import * as _$stream from "stream";
 
 //#region src/services/server.d.ts
@@ -260,6 +260,10 @@ declare class WindowService extends WindowService_base {
     scope: string;
     windowId?: string;
     query?: Record<string, string | number | boolean | null | undefined>;
+    view?: {
+      backgroundColor?: string;
+      webPreferences?: WebPreferences;
+    };
   }): Promise<{
     windowId: string;
   }>;

package/dist/services/index.mjs

@@ -1,7 +1,7 @@
-import { t as ServerService } from "../server-BXwZEQ-n.mjs";
-import { t as ReloaderService } from "../reloader-lLAJ3lqg.mjs";
-import { n as ViewRegistryService, o as HttpService, r as DbService, t as RendererHostService } from "../renderer-host-Bg8QdeeH.mjs";
-import { n as MAIN_WINDOW_ID, t as BaseWindowService } from "../base-window-BUt8pwbw.mjs";
-import { t as RpcService } from "../rpc-BwwQK6hD.mjs";
-import { t as WindowService } from "../window-CmmpCVX6.mjs";
+import { t as ServerService } from "../server-y3PPbh3l.mjs";
+import { t as ReloaderService } from "../reloader-DzEO8kJr.mjs";
+import { a as DbService, r as ViewRegistryService, s as HttpService, t as RendererHostService } from "../renderer-host-Cau9JK0v.mjs";
+import { n as MAIN_WINDOW_ID, t as BaseWindowService } from "../base-window-BbFRRhKP.mjs";
+import { t as RpcService } from "../rpc-JfGv-Wuw.mjs";
+import { t as WindowService } from "../window-o2NGUsIb.mjs";
 export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, ViewRegistryService, WindowService };

package/dist/setup-gate.d.mts

@@ -1,2 +1,2 @@
-import { t as setupGate } from "./setup-gate-BqOzm7zp.mjs";
+import { t as setupGate } from "./setup-gate-Dcy8gGPJ.mjs";
 export { setupGate };