@zenbujs/core 0.0.5 → 0.0.8

package/dist/{runtime-pCeVzj--.d.mts → runtime-BQWntcOb.d.mts}

@@ -5,22 +5,74 @@ type SetupFn = () => SetupCleanup;
 interface ServiceSlot {
   error: unknown | null;
   instance: Service | null;
-  ServiceClass: typeof Service;
+  ServiceClass: ServiceConstructor;
   status: "blocked" | "evaluating" | "ready" | "failed";
 }
-type AnyServiceClass = abstract new (...args: any[]) => Service;
-type DepRef = AnyServiceClass | string;
-type OptionalDep<R extends DepRef = DepRef> = {
-  __optional: true;
-  ref: R;
+type AnyServiceClass = (abstract new (...args: any[]) => Service) & {
+  key: string;
 };
-type DepEntry = DepRef | OptionalDep;
-type DepInstance<D> = D extends OptionalDep<infer R> ? R extends AnyServiceClass ? InstanceType<R> | undefined : unknown : D extends AnyServiceClass ? InstanceType<D> : unknown;
+type DepEntry = AnyServiceClass | string;
+type DepInstance<D> = D extends AnyServiceClass ? InstanceType<D> : unknown;
 type ResolveCtx<TDeps> = { [K in keyof TDeps]: DepInstance<TDeps[K]> };
-declare function optional<R extends DepRef>(ref: R): OptionalDep<R>;
+/**
+ * A concrete service class registered with the runtime. Always has a
+ * `static key` (set by `Service.create`) and an optional `static deps`
+ * map. Used as the parameter type of `runtime.register`.
+ */
+type ServiceConstructor = (new (...args: any[]) => Service) & {
+  key: string;
+  deps?: Record<string, DepEntry>;
+};
 declare abstract class Service {
-  static key: string;
   static deps: Record<string, DepEntry>;
+  /**
+   * Define a Service base class. The returned abstract class has
+   * `static key`, `static deps`, and a typed `this.ctx` already set up;
+   * extend it and add your `evaluate()` body.
+   *
+   *     export class WindowService extends Service.create({
+   *       key: "window",
+   *       deps: {
+   *         baseWindow: BaseWindowService,
+   *         http: HttpService,
+   *       },
+   *     }) {
+   *       evaluate() {
+   *         this.ctx.baseWindow  // BaseWindowService
+   *         this.ctx.http        // HttpService
+   *       }
+   *     }
+   *
+   * `key` is a required field on the config object, so TypeScript errors
+   * if you forget it. `deps` is optional (defaults to no deps).
+   *
+   * For dynamic / optional access to another service, use
+   * `runtime.get(SomeService, cb)` instead of declaring it in `deps`.
+   */
+  static create<TKey extends string, TDeps extends Record<string, DepEntry> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: ResolveCtx<TDeps>; /** @internal */
+    __setupCleanups: Map<string, (reason: CleanupReason) => void | Promise<void>>;
+    evaluate(): void | Promise<void>;
+    setup(key: string, fn: SetupFn): void;
+    /**
+     * 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<T>(_name: string, fn: () => T | Promise<T>, _meta?: Record<string, unknown>): Promise<T>;
+    traceSync<T>(_name: string, fn: () => T, _meta?: Record<string, unknown>): T; /** @internal */
+    __cleanupAllSetups(reason?: CleanupReason): Promise<void>;
+  }) & {
+    key: TKey;
+    deps: Record<string, DepEntry>;
+    create<TKey extends string, TDeps extends Record<string, DepEntry> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
   ctx: any;
   /** @internal */
   __setupCleanups: Map<string, (reason: CleanupReason) => void | Promise<void>>;
@@ -36,41 +88,6 @@ declare abstract class Service {
   /** @internal */
   __cleanupAllSetups(reason?: CleanupReason): Promise<void>;
 }
-/**
- * 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`.
- */
-declare function serviceWithDeps<TDeps extends Record<string, DepEntry>>(deps: TDeps): (abstract new () => {
-  ctx: ResolveCtx<TDeps>; /** @internal */
-  __setupCleanups: Map<string, (reason: CleanupReason) => void | Promise<void>>;
-  evaluate(): void | Promise<void>;
-  setup(key: string, fn: SetupFn): void;
-  /**
-   * 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<T>(_name: string, fn: () => T | Promise<T>, _meta?: Record<string, unknown>): Promise<T>;
-  traceSync<T>(_name: string, fn: () => T, _meta?: Record<string, unknown>): T; /** @internal */
-  __cleanupAllSetups(reason?: CleanupReason): Promise<void>;
-}) & {
-  deps: Record<string, DepEntry>;
-  key: string;
-};
 declare class ServiceRuntime {
   private definitions;
   private dependentsIndex;
@@ -80,15 +97,35 @@ declare class ServiceRuntime {
   private registrationTokens;
   private slots;
   private onReconciledCallbacks;
-  register(ServiceClass: typeof Service, importMeta?: ImportMeta | null): void;
+  private subscribers;
+  register(ServiceClass: ServiceConstructor, importMeta?: ImportMeta | null): void;
   getAllKeys(): string[];
   getSlot(key: string): ServiceSlot | undefined;
   whenIdle(): Promise<void>;
   reloadAll(): Promise<void>;
+  /**
+   * Reload a single service by key. No-op if the key is not registered.
+   * Used by infrastructure that watches resources outside dynohot's
+   * import-graph (e.g. the migrations directory watcher in DbService) and
+   * needs to nudge a specific service to re-evaluate without leaning on
+   * the devtools-only `__zenbu_dev__.reloadService` hook.
+   */
+  reload(key: string): Promise<void>;
   shutdown(): Promise<void>;
+  /**
+   * Subscribe to a service. Behavior-subject style: the callback fires
+   * synchronously once with the current value (the live instance if ready,
+   * `undefined` otherwise), then again on every reconcile of that service —
+   * so you see the new instance after each HMR. Pass through `undefined`
+   * when the service tears down or unregisters.
+   *
+   * Returns an unsubscribe function. Always call it from a `setup()` cleanup
+   * (or wherever you'd otherwise leak callbacks across reloads).
+   */
   get<T extends Service>(ref: {
     key: string;
-  }): T;
+  }, cb: (instance: T | undefined) => void): () => void;
+  private fireSubscribers;
   buildRouter(): Record<string, Record<string, (...args: any[]) => any>>;
   onReconciled(cb: (changedKeys: string[]) => void): () => void;
   private resolveDepSlot;
@@ -178,4 +215,4 @@ declare function getConfig(): ConfigSnapshot;
  */
 declare function subscribeConfig(callback: (snapshot: ConfigSnapshot) => void): () => void;
 //#endregion
-export { subscribeConfig as _, ServiceRuntime as a, getPlugin as c, optional as d, registerAppEntrypoint as f, serviceWithDeps as g, runtime as h, Service as i, getPlugins as l, replacePlugins as m, ConfigSnapshot as n, getAppEntrypoint as o, registerPlugin as p, PluginRecord as r, getConfig as s, CleanupReason as t, getSplashPath as u, unregisterPlugin as v };
+export { unregisterPlugin as _, ServiceConstructor as a, getConfig as c, getSplashPath as d, registerAppEntrypoint as f, subscribeConfig as g, runtime as h, Service as i, getPlugin as l, replacePlugins as m, ConfigSnapshot as n, ServiceRuntime as o, registerPlugin as p, PluginRecord as r, getAppEntrypoint as s, CleanupReason as t, getPlugins as u };

package/dist/runtime.d.mts

@@ -1,2 +1,2 @@
-import { _ as subscribeConfig, a as ServiceRuntime, c as getPlugin, d as optional, f as registerAppEntrypoint, g as serviceWithDeps, h as runtime, i as Service, l as getPlugins, m as replacePlugins, n as ConfigSnapshot, o as getAppEntrypoint, p as registerPlugin, r as PluginRecord, s as getConfig, t as CleanupReason, u as getSplashPath, v as unregisterPlugin } from "./runtime-pCeVzj--.mjs";
-export { CleanupReason, ConfigSnapshot, PluginRecord, Service, ServiceRuntime, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, optional, registerAppEntrypoint, registerPlugin, replacePlugins, runtime, serviceWithDeps, subscribeConfig, unregisterPlugin };
+import { _ as unregisterPlugin, a as ServiceConstructor, c as getConfig, d as getSplashPath, f as registerAppEntrypoint, g as subscribeConfig, h as runtime, i as Service, l as getPlugin, m as replacePlugins, n as ConfigSnapshot, o as ServiceRuntime, p as registerPlugin, r as PluginRecord, s as getAppEntrypoint, t as CleanupReason, u as getPlugins } from "./runtime-BQWntcOb.mjs";
+export { CleanupReason, ConfigSnapshot, PluginRecord, Service, ServiceConstructor, ServiceRuntime, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, registerAppEntrypoint, registerPlugin, replacePlugins, runtime, subscribeConfig, unregisterPlugin };

package/dist/runtime.mjs

@@ -1,30 +1,50 @@
 //#region src/runtime.ts
-function optional(ref) {
-	return {
-		__optional: true,
-		ref
-	};
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5e3;
+function readShutdownTimeoutMs() {
+	const raw = process.env.ZENBU_SHUTDOWN_TIMEOUT_MS;
+	if (!raw) return DEFAULT_SHUTDOWN_TIMEOUT_MS;
+	const value = Number(raw);
+	return Number.isFinite(value) && value > 0 ? value : DEFAULT_SHUTDOWN_TIMEOUT_MS;
 }
-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
-	};
+function resolveDepKey(entry) {
+	if (typeof entry === "string") return entry;
+	return entry.key;
 }
 var Service = class {
-	static key;
-	static deps;
+	static deps = {};
+	/**
+	* Define a Service base class. The returned abstract class has
+	* `static key`, `static deps`, and a typed `this.ctx` already set up;
+	* extend it and add your `evaluate()` body.
+	*
+	*     export class WindowService extends Service.create({
+	*       key: "window",
+	*       deps: {
+	*         baseWindow: BaseWindowService,
+	*         http: HttpService,
+	*       },
+	*     }) {
+	*       evaluate() {
+	*         this.ctx.baseWindow  // BaseWindowService
+	*         this.ctx.http        // HttpService
+	*       }
+	*     }
+	*
+	* `key` is a required field on the config object, so TypeScript errors
+	* if you forget it. `deps` is optional (defaults to no deps).
+	*
+	* For dynamic / optional access to another service, use
+	* `runtime.get(SomeService, cb)` instead of declaring it in `deps`.
+	*/
+	static create(config) {
+		const { key, deps } = config;
+		const resolvedDeps = deps ?? {};
+		class ConfiguredService extends Service {
+			static key = key;
+			static deps = resolvedDeps;
+		}
+		return ConfiguredService;
+	}
 	ctx;
 	/** @internal */
 	__setupCleanups = /* @__PURE__ */ new Map();
@@ -61,30 +81,6 @@ var Service = class {
 		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();
@@ -95,11 +91,14 @@ var ServiceRuntime = class {
 	registrationTokens = /* @__PURE__ */ new Map();
 	slots = /* @__PURE__ */ new Map();
 	onReconciledCallbacks = [];
+	subscribers = /* @__PURE__ */ new Map();
 	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;
+		const slotKey = ServiceClass.key;
+		if (typeof slotKey !== "string" || slotKey.length === 0) {
+			const name = ServiceClass.name ?? "<anonymous>";
+			throw new Error(`[runtime] service "${name}" is missing \`static key\`. Define it via \`Service.create({ key: "...", ... })\`.`);
+		}
 		this.definitions.set(slotKey, ServiceClass);
 		const slot = this.slots.get(slotKey);
 		if (slot) slot.ServiceClass = ServiceClass;
@@ -138,6 +137,18 @@ var ServiceRuntime = class {
 		await this.scheduleReconcile(keys);
 		await this.whenIdle();
 	}
+	/**
+	* Reload a single service by key. No-op if the key is not registered.
+	* Used by infrastructure that watches resources outside dynohot's
+	* import-graph (e.g. the migrations directory watcher in DbService) and
+	* needs to nudge a specific service to re-evaluate without leaning on
+	* the devtools-only `__zenbu_dev__.reloadService` hook.
+	*/
+	async reload(key) {
+		if (!this.slots.has(key)) return;
+		await this.scheduleReconcile([key]);
+		await this.whenIdle();
+	}
 	async shutdown() {
 		try {
 			await this.whenIdle();
@@ -151,10 +162,49 @@ var ServiceRuntime = class {
 		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;
+	/**
+	* Subscribe to a service. Behavior-subject style: the callback fires
+	* synchronously once with the current value (the live instance if ready,
+	* `undefined` otherwise), then again on every reconcile of that service —
+	* so you see the new instance after each HMR. Pass through `undefined`
+	* when the service tears down or unregisters.
+	*
+	* Returns an unsubscribe function. Always call it from a `setup()` cleanup
+	* (or wherever you'd otherwise leak callbacks across reloads).
+	*/
+	get(ref, cb) {
+		const key = ref.key;
+		let subs = this.subscribers.get(key);
+		if (!subs) {
+			subs = /* @__PURE__ */ new Set();
+			this.subscribers.set(key, subs);
+		}
+		const wrapped = cb;
+		subs.add(wrapped);
+		const slot = this.slots.get(key);
+		const current = slot?.status === "ready" && slot.instance ? slot.instance : void 0;
+		try {
+			cb(current);
+		} catch (e) {
+			console.error(`[hot] runtime.get subscriber for "${key}" threw:`, e);
+		}
+		return () => {
+			const set = this.subscribers.get(key);
+			if (!set) return;
+			set.delete(wrapped);
+			if (set.size === 0) this.subscribers.delete(key);
+		};
+	}
+	fireSubscribers(key) {
+		const subs = this.subscribers.get(key);
+		if (!subs || subs.size === 0) return;
+		const slot = this.slots.get(key);
+		const instance = slot?.status === "ready" && slot.instance ? slot.instance : void 0;
+		for (const cb of [...subs]) try {
+			cb(instance);
+		} catch (e) {
+			console.error(`[hot] runtime.get subscriber for "${key}" threw:`, e);
+		}
 	}
 	buildRouter() {
 		const router = {};
@@ -188,15 +238,9 @@ var ServiceRuntime = class {
 		const deps = ServiceClass.deps ?? {};
 		const ctx = {};
 		for (const [name, entry] of Object.entries(deps)) {
-			const { key, optional: isOptional } = resolveDep(entry);
+			const key = resolveDepKey(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}"`);
-			}
+			if (!slot || slot.status !== "ready" || !slot.instance) throw new Error(`Dependency "${key}" not ready for "${ServiceClass.key}"`);
 			ctx[name] = slot.instance;
 		}
 		instance.ctx = ctx;
@@ -206,7 +250,7 @@ var ServiceRuntime = class {
 		for (const [slotKey, ServiceClass] of this.definitions) {
 			const deps = ServiceClass.deps ?? {};
 			for (const entry of Object.values(deps)) {
-				const { key: depKey } = resolveDep(entry);
+				const depKey = resolveDepKey(entry);
 				const dependents = next.get(depKey) ?? /* @__PURE__ */ new Set();
 				dependents.add(slotKey);
 				next.set(depKey, dependents);
@@ -228,8 +272,7 @@ var ServiceRuntime = class {
 		const deps = ServiceClass.deps ?? {};
 		const missing = [];
 		for (const entry of Object.values(deps)) {
-			const { key, optional: isOptional } = resolveDep(entry);
-			if (isOptional) continue;
+			const key = resolveDepKey(entry);
 			const slot = this.resolveDepSlot(key);
 			if (!slot || slot.status !== "ready" || !slot.instance) missing.push(key);
 		}
@@ -254,7 +297,24 @@ var ServiceRuntime = class {
 		slot.instance = null;
 		slot.status = "blocked";
 		slot.error = null;
-		if (instance) await instance.__cleanupAllSetups(options.reason ?? "shutdown");
+		if (instance) {
+			const reason = options.reason ?? "shutdown";
+			const timeoutMs = readShutdownTimeoutMs();
+			const cleanup = instance.__cleanupAllSetups(reason);
+			let timer = null;
+			const timeout = new Promise((resolve) => {
+				timer = setTimeout(() => {
+					console.error(`[hot] ${key} ${reason} cleanup timed out after ${timeoutMs}ms; forcing teardown`);
+					resolve();
+				}, timeoutMs);
+				timer.unref?.();
+			});
+			try {
+				await Promise.race([cleanup, timeout]);
+			} finally {
+				if (timer) clearTimeout(timer);
+			}
+		}
 		if (options.removeSlot) this.slots.delete(key);
 	}
 	async unregister(key, token) {
@@ -263,6 +323,7 @@ var ServiceRuntime = class {
 		this.definitions.delete(key);
 		await this.teardownService(key, { removeSlot: true });
 		this.rebuildDependentsIndex();
+		this.fireSubscribers(key);
 		await this.scheduleReconcile([key]);
 	}
 	async scheduleReconcile(keys) {
@@ -294,38 +355,33 @@ var ServiceRuntime = class {
 			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)));
+		const wasReady = /* @__PURE__ */ new Set();
+		for (const key of affectedKeys) if (this.slots.get(key)?.status === "ready") wasReady.add(key);
+		for (const level of [...levels].reverse()) await Promise.all(level.map((key) => this.teardownService(key, { reason: "reload" })));
+		for (const level of levels) await Promise.all(level.map((key) => this.reconcileKey(key, wasReady)));
+		for (const key of affectedKeys) this.fireSubscribers(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) {
+	async reconcileKey(key, wasReady) {
 		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(", ")}`);
+			if (wasReady.has(key)) 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);
+		const instance = new ServiceClass();
+		slot.instance = instance;
 		slot.status = "evaluating";
 		slot.error = null;
 		try {
-			await instance.__cleanupAllSetups("reload");
 			this.injectCtx(instance, ServiceClass);
 			await instance.evaluate();
 			slot.status = "ready";
@@ -347,11 +403,11 @@ var ServiceRuntime = class {
 			const deps = ServiceClass.deps ?? {};
 			let degree = 0;
 			for (const entry of Object.values(deps)) {
-				const { key: depKey, optional: isOptional } = resolveDep(entry);
+				const depKey = resolveDepKey(entry);
 				if (keys.has(depKey)) {
 					degree++;
 					dependents.get(depKey).push(slotKey);
-				} else if (isOptional) continue;
+				}
 			}
 			inDegree.set(slotKey, degree);
 		}
@@ -519,4 +575,4 @@ function subscribeConfig(callback) {
 	};
 }
 //#endregion
-export { Service, ServiceRuntime, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, optional, registerAppEntrypoint, registerPlugin, replacePlugins, runtime, serviceWithDeps, subscribeConfig, unregisterPlugin };
+export { Service, ServiceRuntime, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, registerAppEntrypoint, registerPlugin, replacePlugins, runtime, subscribeConfig, unregisterPlugin };

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

@@ -1,9 +1,9 @@
-import { m as Field, v as Schema } from "./index-M_lSNBrq.mjs";
+import { m as Field, v as Schema } from "./index-DeDxePAa.mjs";
 import zod from "zod";
 
 //#region src/schema.d.ts
 declare const viewRegistryEntrySchema: zod.ZodObject<{
-  scope: zod.ZodString;
+  type: zod.ZodString;
   url: zod.ZodString;
   port: zod.ZodNumber;
   icon: zod.ZodOptional<zod.ZodString>;
@@ -30,7 +30,7 @@ declare const windowPrefsSchema: zod.ZodObject<{
 }, zod.core.$strip>;
 declare const schema: Schema<{
   lastKnownViewRegistry: Field<zod.ZodArray<zod.ZodObject<{
-    scope: zod.ZodString;
+    type: zod.ZodString;
     url: zod.ZodString;
     port: zod.ZodNumber;
     icon: zod.ZodOptional<zod.ZodString>;

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-Dl85YjXW.mjs";
+import { a as WindowPrefs, i as WindowBounds, n as SchemaRoot, o as schema, r as ViewRegistryEntry, t as CoreSchema } from "./schema-CjrMVk36.mjs";
 export { CoreSchema, SchemaRoot, ViewRegistryEntry, WindowBounds, WindowPrefs, schema };

package/dist/schema.mjs

@@ -2,7 +2,7 @@ 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(),
+	type: zod.string(),
 	url: zod.string(),
 	port: zod.number(),
 	icon: zod.string().optional(),

package/dist/{server-y3PPbh3l.mjs → server-CZLMF8Dj.mjs}

@@ -7,9 +7,7 @@ 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";
-	static deps = {};
+var ServerService = class extends Service.create({ key: "server" }) {
 	server = null;
 	wss = null;
 	port = 0;

package/dist/services/default.d.mts

@@ -2,9 +2,9 @@
 /**
  * Loads and registers all built-in services. Kept separate from
  * `./index.ts` (which statically re-exports the service classes for
- * `serviceWithDeps(...)` consumers) so that `setup-gate` can import it without
- * eagerly loading every service module before `setupGate()` has had a
- * chance to bootstrap env vars and `process.chdir(projectRoot)`.
+ * `Service.withDeps(...)` consumers) so that `setup-gate` can import it
+ * without eagerly loading every service module before `setupGate()` has
+ * had a chance to bootstrap env vars and `process.chdir(projectRoot)`.
  */
 declare function defaultServices(): Promise<void>;
 //#endregion

package/dist/services/default.mjs

@@ -2,21 +2,22 @@
 /**
 * Loads and registers all built-in services. Kept separate from
 * `./index.ts` (which statically re-exports the service classes for
-* `serviceWithDeps(...)` consumers) so that `setup-gate` can import it without
-* eagerly loading every service module before `setupGate()` has had a
-* chance to bootstrap env vars and `process.chdir(projectRoot)`.
+* `Service.withDeps(...)` consumers) so that `setup-gate` can import it
+* without eagerly loading every service module before `setupGate()` has
+* had a chance to bootstrap env vars and `process.chdir(projectRoot)`.
 */
 async function defaultServices() {
-	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);
+	await import("../server-CZLMF8Dj.mjs").then((n) => n.n);
+	await import("../reloader-B22UiNA2.mjs").then((n) => n.n);
+	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.n);
+	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.c);
+	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.o);
+	await import("../base-window-BxBZ2md_.mjs").then((n) => n.r);
+	await import("../rpc-C4_NQmpT.mjs").then((n) => n.n);
+	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.i);
+	await import("../window-YFKvAM0l.mjs").then((n) => n.n);
+	await import("../advice-config-DXSIo0sg.mjs").then((n) => n.t);
+	await import("../updater-DCkz9M1c.mjs").then((n) => n.n);
 }
 //#endregion
 export { defaultServices };