@zenbujs/core 0.0.9 → 0.0.12

package/dist/runtime.mjs

@@ -1,578 +1,2 @@
-//#region src/runtime.ts
-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 resolveDepKey(entry) {
-	if (typeof entry === "string") return entry;
-	return entry.key;
-}
-var Service = class {
-	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();
-	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();
-	}
-};
-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 = [];
-	subscribers = /* @__PURE__ */ new Map();
-	register(ServiceClass, importMeta) {
-		const hot = importMeta?.hot ?? null;
-		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;
-		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();
-	}
-	/**
-	* 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();
-		} 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();
-	}
-	/**
-	* 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 = {};
-		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 = resolveDepKey(entry);
-			const slot = this.resolveDepSlot(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;
-	}
-	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 depKey = resolveDepKey(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 = resolveDepKey(entry);
-			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) {
-			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) {
-		if (this.registrationTokens.get(key) !== token) return;
-		this.registrationTokens.delete(key);
-		this.definitions.delete(key);
-		await this.teardownService(key, { removeSlot: true });
-		this.rebuildDependentsIndex();
-		this.fireSubscribers(key);
-		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);
-		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, 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) {
-			await this.teardownService(key, { reason: "reload" });
-			if (wasReady.has(key)) console.log(`[hot] ${key} waiting on: ${missingDeps.join(", ")}`);
-			return;
-		}
-		const instance = new ServiceClass();
-		slot.instance = instance;
-		slot.status = "evaluating";
-		slot.error = null;
-		try {
-			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 depKey = resolveDepKey(entry);
-				if (keys.has(depKey)) {
-					degree++;
-					dependents.get(depKey).push(slotKey);
-				}
-			}
-			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, registerAppEntrypoint, registerPlugin, replacePlugins, runtime, subscribeConfig, unregisterPlugin };
+import { a as getConfig, c as getSplashPath, d as replacePlugins, f as runtime, i as getAppEntrypoint, l as registerAppEntrypoint, m as unregisterPlugin, n as Service, o as getPlugin, p as subscribeConfig, r as ServiceRuntime, s as getPlugins, t as CORE_PLUGIN_NAME, u as registerPlugin } from "./runtime-DYUONc3S.mjs";
+export { CORE_PLUGIN_NAME, Service, ServiceRuntime, getAppEntrypoint, getConfig, getPlugin, getPlugins, getSplashPath, registerAppEntrypoint, registerPlugin, replacePlugins, runtime, subscribeConfig, unregisterPlugin };

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

@@ -1,5 +1,7 @@
-import { m as Field, v as Schema } from "./index-DeDxePAa.mjs";
+import { m as Field, v as InferSchemaRoot, y as Schema } from "./index-FaexRVl_.mjs";
+import * as _$zod from "zod";
 import zod from "zod";
+import * as _$zod_v4_core0 from "zod/v4/core";
 
 //#region src/schema.d.ts
 declare const viewRegistryEntrySchema: zod.ZodObject<{
@@ -29,34 +31,20 @@ declare const windowPrefsSchema: zod.ZodObject<{
   }, zod.core.$strip>>;
 }, zod.core.$strip>;
 declare const schema: Schema<{
-  lastKnownViewRegistry: Field<zod.ZodArray<zod.ZodObject<{
-    type: zod.ZodString;
-    url: zod.ZodString;
-    port: zod.ZodNumber;
-    icon: zod.ZodOptional<zod.ZodString>;
-    meta: zod.ZodOptional<zod.ZodObject<{
-      kind: zod.ZodOptional<zod.ZodString>;
-      sidebar: zod.ZodOptional<zod.ZodBoolean>;
-      bottomPanel: zod.ZodOptional<zod.ZodBoolean>;
-      label: zod.ZodOptional<zod.ZodString>;
-    }, zod.core.$strip>>;
-  }, zod.core.$strip>>, true>;
-  windowPrefs: Field<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
-    lastKnownBounds: zod.ZodOptional<zod.ZodObject<{
-      x: zod.ZodNumber;
-      y: zod.ZodNumber;
-      width: zod.ZodNumber;
-      height: zod.ZodNumber;
-    }, zod.core.$strip>>;
-  }, zod.core.$strip>>, true>;
+  /**
+   *
+   * this needs to be changed, and we probably
+   * should have an api for reading in memory state
+   * on the service so we don't need to do these hacks
+   *
+   * */
+  lastKnownViewRegistry: Field<_$zod.ZodArray<_$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>>, true>;
+  windowPrefs: Field<_$zod.ZodRecord<_$zod.ZodType<string | number | symbol, unknown, _$zod_v4_core0.$ZodTypeInternals<string | number | symbol, unknown>>, _$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>>, true>;
 }>;
 type ViewRegistryEntry = zod.infer<typeof viewRegistryEntrySchema>;
 type WindowBounds = zod.infer<typeof windowBoundsSchema>;
 type WindowPrefs = zod.infer<typeof windowPrefsSchema>;
-type SchemaRoot = {
-  lastKnownViewRegistry: ViewRegistryEntry[];
-  windowPrefs: Record<string, WindowPrefs>;
-};
+type SchemaRoot = InferSchemaRoot<typeof schema>;
 type CoreSchema = typeof schema.shape;
 //#endregion
 export { WindowPrefs as a, WindowBounds as i, SchemaRoot as n, schema as o, ViewRegistryEntry as r, CoreSchema as t };

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

package/dist/schema.mjs

@@ -1,4 +1,4 @@
-import { a as f, i as createSchema } from "./schema-Ca7SxXgS.mjs";
+import { a as f, i as createSchema } from "./schema-C6k0SroY.mjs";
 import zod from "zod";
 //#region src/schema.ts
 const viewRegistryEntrySchema = zod.object({
@@ -21,8 +21,15 @@ const windowBoundsSchema = zod.object({
 });
 const windowPrefsSchema = zod.object({ lastKnownBounds: windowBoundsSchema.optional() });
 const schema = createSchema({
+	/**
+	*
+	* this needs to be changed, and we probably
+	* should have an api for reading in memory state
+	* on the service so we don't need to do these hacks
+	*
+	* */
 	lastKnownViewRegistry: f.array(viewRegistryEntrySchema).default([]),
 	windowPrefs: f.record(zod.string(), windowPrefsSchema).default({})
 });
 //#endregion
-export { schema };
+export { schema as default, schema };

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

@@ -1,6 +1,6 @@
 import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
-import { Service, runtime } from "./runtime.mjs";
-import { t as createLogger } from "./log-6rzaCV0I.mjs";
+import { f as runtime, n as Service } from "./runtime-DYUONc3S.mjs";
+import { t as createLogger } from "./log-BkRqDwwB.mjs";
 import http from "node:http";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { WebSocketServer } from "ws";

package/dist/services/default.d.mts

@@ -1,10 +1,6 @@
 //#region src/services/default.d.ts
 /**
- * Loads and registers all built-in services. Kept separate from
- * `./index.ts` (which statically re-exports the service classes for
- * `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)`.
+ * parallelize? i forgor is it serial no matter what?
  */
 declare function defaultServices(): Promise<void>;
 //#endregion