@zenbujs/core 0.0.3 → 0.0.5

package/dist/http-IBcLzbYu.mjs

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

package/dist/load-build-config-DozuRhAN.mjs

@@ -1,40 +0,0 @@
-import { n as resolveBuildConfig } from "./build-config-pbv0w4oN.mjs";
-import { createRequire } from "node:module";
-import fs from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-//#region src/cli/lib/load-build-config.ts
-const localRequire = createRequire(import.meta.url);
-const CONFIG_NAMES = [
-	"zenbu.build.ts",
-	"zenbu.build.mts",
-	"zenbu.build.js",
-	"zenbu.build.mjs"
-];
-function findBuildConfig(projectDir) {
-	for (const name of CONFIG_NAMES) {
-		const candidate = path.join(projectDir, name);
-		if (fs.existsSync(candidate)) return candidate;
-	}
-	throw new Error(`No zenbu.build config found at ${projectDir}. Expected one of: ${CONFIG_NAMES.join(", ")}`);
-}
-let tsxRegistered = null;
-function ensureTsxRegistered() {
-	if (tsxRegistered) return tsxRegistered;
-	tsxRegistered = (async () => {
-		try {
-			const tsxApi = localRequire("tsx/esm/api");
-			if (typeof tsxApi.register === "function") tsxApi.register();
-		} catch {}
-	})();
-	return tsxRegistered;
-}
-async function loadBuildConfig(configPath) {
-	await ensureTsxRegistered();
-	const mod = await import(pathToFileURL(path.resolve(configPath)).href);
-	const config = mod.default ?? mod;
-	if (!config || !Array.isArray(config.include)) throw new Error(`${path.basename(configPath)} must export a config object (via defineBuildConfig) with an 'include' array.`);
-	return resolveBuildConfig(config);
-}
-//#endregion
-export { loadBuildConfig as n, findBuildConfig as t };

package/dist/reloader-BCkLjDhS.mjs

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

package/dist/renderer-host-DpvBPTHJ.mjs

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

package/dist/rpc-CqitnyR4.mjs

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

package/dist/runtime-DUFKDIe4.mjs

@@ -1,409 +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;
-	}
-};
-/**
-* 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;
-})();
-//#endregion
-export { serviceWithDeps as a, runtime as i, ServiceRuntime as n, optional as r, Service as t };

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-DjrZUbbu.mjs

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

package/dist/setup-gate-BcoqWu8S.mjs

@@ -1,110 +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
-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 configPath = path.join(projectRoot, "config.json");
-	if (!fs.existsSync(configPath)) throw new Error(`config.json not found at ${configPath}`);
-	return configPath;
-}
-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(import.meta.resolve("@zenbujs/core/loaders/zenbu"));
-	register$1({ tsconfig });
-	process.env.ZENBU_ADVICE_ROOT = projectRoot;
-	await import("./node-D4M19_mV.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-BualWgAf.mjs

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

package/dist/window-CM2a9Kyc.mjs

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

package/dist/{mirror-sync-BN59kMCG.mjs → mirror-sync-PDzxhf1w.mjs}

@@ -1,9 +1,9 @@
 import "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { execFile } from "node:child_process";
 import crypto from "node:crypto";
 import fsp from "node:fs/promises";
-import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 //#region src/cli/lib/mirror-sync.ts
 const execFile$1 = promisify(execFile);