@zenbujs/core 0.0.4 → 0.0.5

package/dist/runtime-C95iyVn6.mjs

@@ -1,461 +0,0 @@
-//#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
-	};
-	return slot.__zenbu_plugin_registry__;
-}
-/**
-* 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) {
-	getPluginRegistry().plugins.set(record.name, record);
-}
-/**
-* Drop a plugin from the registry. Used when the loader regenerates the
-* barrel and needs to clear stale entries.
-*/
-function unregisterPlugin(name) {
-	getPluginRegistry().plugins.delete(name);
-}
-/**
-* 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);
-}
-function getPlugins() {
-	return [...getPluginRegistry().plugins.values()];
-}
-function getPlugin(name) {
-	return getPluginRegistry().plugins.get(name);
-}
-/**
-* Set the boot-window HTML path. Called once by the loader-emitted barrel.
-* Consumers (`view-registry`, `vite-plugins`) ask for it via
-* `getAppEntrypoint()`.
-*/
-function registerAppEntrypoint(htmlPath) {
-	getPluginRegistry().appEntrypoint = htmlPath;
-}
-function getAppEntrypoint() {
-	return getPluginRegistry().appEntrypoint;
-}
-//#endregion
-export { getPlugins as a, registerPlugin as c, serviceWithDeps as d, unregisterPlugin as f, getPlugin as i, replacePlugins as l, ServiceRuntime as n, optional as o, getAppEntrypoint as r, registerAppEntrypoint as s, Service as t, runtime as u };

package/dist/schema-dGK6qkfR.mjs

@@ -1,28 +0,0 @@
-import { a as f, i as createSchema } from "./schema-CIg4GzHQ.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 as t };

package/dist/server-CgzQOPSW.mjs

@@ -1,2 +0,0 @@
-import "./server-DB3Eki_G.mjs";
-export {};

package/dist/setup-gate-D8XfYY52.mjs

@@ -1,140 +0,0 @@
-import { t as bootstrapEnv } from "./env-bootstrap-rj7I-59x.mjs";
-import { createRequire, register } from "node:module";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { register as register$1 } from "tsx/esm/api";
-//#region src/setup-gate.ts
-function registerLoader(specifier, opts) {
-	return register(specifier, void 0, opts);
-}
-const verbose = process.env.ZENBU_VERBOSE === "1";
-function projectArg() {
-	const arg = process.argv.find((item) => item.startsWith("--project="));
-	return arg ? path.resolve(arg.slice(10)) : null;
-}
-function appDirName(name) {
-	return name.replace(/^@/, "").replace(/[\\/]/g, "__");
-}
-function readPackageJson(packageDir) {
-	const pkgPath = path.join(packageDir, "package.json");
-	return JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-}
-function findProjectRoot(projectDir) {
-	let dir = path.resolve(projectDir);
-	while (dir !== path.dirname(dir)) {
-		if (fs.existsSync(path.join(dir, "package.json"))) return dir;
-		dir = path.dirname(dir);
-	}
-	return path.resolve(projectDir);
-}
-function resolveConfigPath(projectRoot) {
-	const candidates = [
-		"zenbu.config.ts",
-		"zenbu.config.mts",
-		"zenbu.config.js",
-		"zenbu.config.mjs"
-	];
-	for (const name of candidates) {
-		const candidate = path.join(projectRoot, name);
-		if (fs.existsSync(candidate)) return candidate;
-	}
-	throw new Error(`No zenbu config found at ${projectRoot}. Expected one of: ${candidates.join(", ")}`);
-}
-function findTsconfig(projectRoot) {
-	const candidate = path.join(projectRoot, "tsconfig.json");
-	return fs.existsSync(candidate) ? candidate : false;
-}
-function loadElectronApp() {
-	const electron = createRequire(import.meta.url)("electron");
-	if (!electron.app) throw new Error("Electron app API is unavailable; setup-gate must run inside Electron");
-	return electron.app;
-}
-async function closeRegisteredWatchers() {
-	await (await import("@zenbujs/hmr/pause")).closeAllWatchers?.();
-}
-async function registerLoaders(tsconfig, projectRoot) {
-	register$1({ tsconfig });
-	const { loadConfig } = await import("./load-config-CQG4297M.mjs");
-	const { resolved, pluginSourceFiles } = await loadConfig(projectRoot);
-	const loaderData = {
-		payload: {
-			plugins: resolved.plugins.map((p) => ({
-				name: p.name,
-				dir: p.dir,
-				services: p.services,
-				schemaPath: p.schemaPath,
-				migrationsPath: p.migrationsPath,
-				preloadPath: p.preloadPath,
-				eventsPath: p.eventsPath,
-				icons: p.icons
-			})),
-			appEntrypoint: resolved.uiEntrypointPath
-		},
-		pluginSourceFiles
-	};
-	globalThis.__zenbu_main_resolved_config__ = loaderData;
-	registerLoader(import.meta.resolve("@zenbujs/core/loaders/zenbu"), { data: loaderData });
-	process.env.ZENBU_ADVICE_ROOT = projectRoot;
-	await import("./node-CvZnTx53.mjs");
-	const dynohot = await import(pathToFileURL(createRequire(import.meta.url).resolve("@zenbujs/hmr/register")).href);
-	if (typeof dynohot.register === "function") dynohot.register({ ignore: /[/\\](?:node_modules|dist)[/\\]/ });
-}
-async function setupGate() {
-	const app = loadElectronApp();
-	await app.whenReady();
-	bootstrapEnv();
-	const bundledAppPath = app.getAppPath();
-	const appName = readPackageJson(bundledAppPath).name ?? path.basename(bundledAppPath);
-	const resolvedProjectDir = projectArg() ?? path.join(process.env.ZENBU_APPS_DIR ?? path.join(os.homedir(), ".zenbu", "apps"), appDirName(appName));
-	if (!fs.existsSync(resolvedProjectDir)) throw new Error(`setup-gate: project directory ${resolvedProjectDir} does not exist. In a shipped .app, the launcher provisions this dir before invoking setup-gate. In dev, point at an existing project with --project=.`);
-	const projectRoot = findProjectRoot(resolvedProjectDir);
-	const configPath = resolveConfigPath(projectRoot);
-	const tsconfig = findTsconfig(projectRoot);
-	process.chdir(projectRoot);
-	process.env.ZENBU_CONFIG_PATH = configPath;
-	if (!process.argv.some((arg) => arg.startsWith("--project="))) process.argv.push(`--project=${resolvedProjectDir}`);
-	if (verbose) {
-		console.log("[setup-gate] project:", resolvedProjectDir);
-		console.log("[setup-gate] config:", configPath);
-	}
-	await registerLoaders(tsconfig, projectRoot);
-	const { defaultServices } = await import("./services/default.mjs");
-	await defaultServices();
-	let shuttingDown = false;
-	const shutdown = async (exitCode = 0) => {
-		if (shuttingDown) return;
-		shuttingDown = true;
-		try {
-			await globalThis.__zenbu_service_runtime__?.shutdown();
-		} catch (err) {
-			console.error("[setup-gate] shutdown failed:", err);
-		}
-		try {
-			await closeRegisteredWatchers();
-		} catch (err) {
-			console.error("[setup-gate] closeAllWatchers failed:", err);
-		}
-		app.exit(exitCode);
-	};
-	app.on("before-quit", (event) => {
-		if (shuttingDown) return;
-		event.preventDefault();
-		shutdown(0);
-	});
-	process.on("SIGINT", () => void shutdown(0));
-	process.on("SIGTERM", () => void shutdown(0));
-	const mod = await import(`zenbu:plugins?config=${encodeURIComponent(configPath)}`, { with: { hot: "import" } });
-	if (typeof mod.default === "function") {
-		const controller = mod.default();
-		if (controller && typeof controller.main === "function") await controller.main();
-	}
-	await globalThis.__zenbu_service_runtime__?.whenIdle();
-}
-setupGate().catch((error) => {
-	console.error(error);
-	process.exit(1);
-});
-//#endregion
-export { setupGate as t };

package/dist/view-registry-2zePxTEg.mjs

@@ -1,2 +0,0 @@
-import "./renderer-host-ztaSIOGx.mjs";
-export {};

package/dist/window-S3TlTXlK.mjs

@@ -1,2 +0,0 @@
-import "./window-DUvMTons.mjs";
-export {};