@zenbujs/core 0.0.1

package/dist/setup-gate-BeD6WS6d.mjs

@@ -0,0 +1,110 @@
+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("./pause-DvAUNmKn.mjs")).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("dynohot/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/setup-gate-BqOzm7zp.d.mts

@@ -0,0 +1,4 @@
+//#region src/setup-gate.d.ts
+declare function setupGate(): Promise<void>;
+//#endregion
+export { setupGate as t };

package/dist/setup-gate.d.mts

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

package/dist/setup-gate.mjs

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

package/dist/src-pELM4_iH.mjs

@@ -0,0 +1,376 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { nanoid } from "nanoid";
+import * as Exit from "effect/Exit";
+import * as Cause from "effect/Cause";
+//#region ../zenrpc/src/protocol.ts
+const serialize = (msg) => JSON.stringify(msg);
+const deserialize = (data) => JSON.parse(data);
+//#endregion
+//#region ../zenrpc/src/execute.ts
+const resolveMethod = (router, path) => {
+	let current = router;
+	for (const segment of path) {
+		current = current[segment];
+		if (current === void 0) throw new Error(`Method not found: ${path.join(".")}`);
+	}
+	if (typeof current !== "function") throw new Error(`Not a function: ${path.join(".")}`);
+	return current;
+};
+const serializeTaggedError = (error) => {
+	const result = { _tag: error._tag };
+	for (const key of Object.keys(error)) {
+		if (key === "stack" || key === "name" || key === "cause" || key === "_tag") continue;
+		const value = error[key];
+		if (typeof value === "function" || typeof value === "symbol") continue;
+		result[key] = value;
+	}
+	return result;
+};
+const isTaggedError = (value) => value !== null && typeof value === "object" && "_tag" in value && typeof value._tag === "string";
+/**
+* Executes a router method and sends the response.
+* Handles plain sync/async returns and Effect returns:
+* - Effect success → { type: "response", result: { _tag: "success", data } }
+* - Effect tagged error → { type: "response", result: { _tag: errorTag, ...fields } }
+* - Effect defect → { type: "error-response" }
+* - Plain return → { type: "response", result }
+* - Thrown error → { type: "error-response" }
+*/
+const executeMethod = async (args) => {
+	try {
+		const returnValue = args.method(...args.methodArgs);
+		if (Effect.isEffect(returnValue)) {
+			const exit = await (args.runtime ? (e) => args.runtime.runPromiseExit(e) : Effect.runPromiseExit)(returnValue);
+			if (Exit.isSuccess(exit)) {
+				args.send(serialize({
+					type: "response",
+					id: args.id,
+					result: {
+						_tag: "success",
+						data: exit.value
+					}
+				}));
+				return;
+			}
+			const failure = Cause.failureOption(exit.cause);
+			if (Option.isSome(failure) && isTaggedError(failure.value)) {
+				args.send(serialize({
+					type: "response",
+					id: args.id,
+					result: serializeTaggedError(failure.value)
+				}));
+				return;
+			}
+			let message;
+			if (Option.isSome(failure)) message = failure.value instanceof Error ? failure.value.message : String(failure.value);
+			else {
+				const defect = Cause.dieOption(exit.cause);
+				if (Option.isSome(defect)) message = defect.value instanceof Error ? defect.value.message : String(defect.value);
+				else message = "Unknown error";
+			}
+			args.send(serialize({
+				type: "error-response",
+				id: args.id,
+				error: { message }
+			}));
+		} else {
+			const result = await returnValue;
+			args.send(serialize({
+				type: "response",
+				id: args.id,
+				result
+			}));
+		}
+	} catch (err) {
+		console.error(`[zenrpc] method execution failed:`, err);
+		args.send(serialize({
+			type: "error-response",
+			id: args.id,
+			error: { message: err instanceof Error ? err.message : String(err) }
+		}));
+	}
+};
+//#endregion
+//#region ../zenrpc/src/server.ts
+const createEmitProxy = (send, currentPath = []) => new Proxy(() => {}, {
+	get(_target, prop) {
+		if (typeof prop === "symbol") return void 0;
+		return createEmitProxy(send, [...currentPath, prop]);
+	},
+	apply(_target, _thisArg, args) {
+		send(currentPath, args[0]);
+	}
+});
+const createServer = (options) => {
+	const clients = /* @__PURE__ */ new Map();
+	const sendTo = (clientId) => (data) => options.send(data, clientId);
+	const postMessage = (data, clientId) => {
+		const msg = deserialize(data);
+		switch (msg.type) {
+			case "handshake":
+				if (msg.version !== options.version) {
+					options.send(serialize({
+						type: "handshake-ack",
+						ok: false,
+						error: `Version mismatch: expected ${options.version}, got ${msg.version}`
+					}), clientId);
+					return;
+				}
+				clients.set(clientId, { clientId });
+				options.send(serialize({
+					type: "handshake-ack",
+					ok: true
+				}), clientId);
+				break;
+			case "request":
+				if (!clients.get(clientId)) {
+					options.send(serialize({
+						type: "error-response",
+						id: msg.id,
+						error: { message: "Not connected" }
+					}), clientId);
+					return;
+				}
+				try {
+					const ctx = { clientId };
+					executeMethod({
+						method: resolveMethod(options.router(() => ctx), msg.path),
+						methodArgs: msg.args,
+						id: msg.id,
+						send: sendTo(clientId),
+						runtime: options.runtime
+					});
+				} catch (err) {
+					console.error(`[zenrpc] request handler failed for ${msg.path?.join(".")}:`, err);
+					options.send(serialize({
+						type: "error-response",
+						id: msg.id,
+						error: { message: err instanceof Error ? err.message : String(err) }
+					}), clientId);
+				}
+				break;
+		}
+	};
+	const removeClient = (clientId) => {
+		clients.delete(clientId);
+	};
+	const emit = createEmitProxy((path, data) => {
+		const msg = serialize({
+			type: "event",
+			path,
+			data
+		});
+		for (const [clientId] of clients) options.send(msg, clientId);
+	});
+	const emitTo = (clientId) => createEmitProxy((path, data) => {
+		if (!clients.has(clientId)) return;
+		options.send(serialize({
+			type: "event",
+			path,
+			data
+		}), clientId);
+	});
+	return {
+		postMessage,
+		removeClient,
+		emit,
+		emitTo
+	};
+};
+//#endregion
+//#region ../zenrpc/src/pending.ts
+const createPendingRequests = () => {
+	const pending = /* @__PURE__ */ new Map();
+	return {
+		add: (id) => new Promise((resolve, reject) => {
+			pending.set(id, {
+				resolve,
+				reject
+			});
+		}),
+		resolve: (id, value) => {
+			const entry = pending.get(id);
+			if (entry) {
+				pending.delete(id);
+				entry.resolve(value);
+			}
+		},
+		reject: (id, error) => {
+			const entry = pending.get(id);
+			if (entry) {
+				pending.delete(id);
+				entry.reject(error);
+			}
+		},
+		rejectAll: (error) => {
+			for (const [id, entry] of pending) entry.reject(error);
+			pending.clear();
+		},
+		has: (id) => pending.has(id),
+		size: () => pending.size
+	};
+};
+//#endregion
+//#region ../zenrpc/src/proxy.ts
+const createProxy = (deps) => {
+	const makeProxy = (currentPath) => {
+		return new Proxy(function() {}, {
+			get(_target, prop, _receiver) {
+				if (typeof prop === "symbol") return void 0;
+				return makeProxy([...currentPath, prop]);
+			},
+			apply(_target, _thisArg, args) {
+				const id = nanoid();
+				const promise = deps.pending.add(id);
+				deps.send(serialize({
+					type: "request",
+					id,
+					path: currentPath,
+					args
+				}));
+				return promise;
+			}
+		});
+	};
+	return makeProxy([]);
+};
+//#endregion
+//#region ../zenrpc/src/client.ts
+const createEventListeners = () => {
+	const listeners = /* @__PURE__ */ new Map();
+	return {
+		add(path, cb) {
+			let set = listeners.get(path);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				listeners.set(path, set);
+			}
+			set.add(cb);
+			return () => {
+				set.delete(cb);
+				if (set.size === 0) listeners.delete(path);
+			};
+		},
+		dispatch(path, data) {
+			listeners.get(path)?.forEach((cb) => cb(data));
+		}
+	};
+};
+const createClient = (options) => {
+	const pending = createPendingRequests();
+	const eventListeners = createEventListeners();
+	let connected = false;
+	let handshakeResolve = null;
+	let handshakeReject = null;
+	const handshakePromise = new Promise((resolve, reject) => {
+		handshakeResolve = resolve;
+		handshakeReject = reject;
+	});
+	options.send(serialize({
+		type: "handshake",
+		clientId: options.clientId,
+		version: options.version
+	}));
+	const postMessage = (data) => {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			console.error("[zenrpc] failed to deserialize:", data, e);
+			return;
+		}
+		switch (msg.type) {
+			case "handshake-ack":
+				if (msg.ok) {
+					connected = true;
+					handshakeResolve?.();
+				} else handshakeReject?.(new Error(msg.error ?? "Handshake rejected"));
+				break;
+			case "response":
+				pending.resolve(msg.id, msg.result);
+				break;
+			case "error-response": {
+				const errMsg = msg.error?.message ?? JSON.stringify(msg);
+				pending.reject(msg.id, new Error(errMsg));
+				break;
+			}
+			case "event":
+				eventListeners.dispatch(msg.path.join("."), msg.data);
+				break;
+		}
+	};
+	return {
+		postMessage,
+		server: createProxy({
+			send: options.send,
+			pending
+		}),
+		eventListeners,
+		ready: handshakePromise,
+		get connected() {
+			return connected;
+		}
+	};
+};
+//#endregion
+//#region ../zenrpc/src/events.ts
+const createEventProxy = (listeners, currentPath = []) => new Proxy({}, { get(_target, prop) {
+	if (typeof prop === "symbol") return void 0;
+	if (prop === "subscribe") {
+		const key = currentPath.join(".");
+		return (cb) => listeners.add(key, cb);
+	}
+	return createEventProxy(listeners, [...currentPath, prop]);
+} });
+//#endregion
+//#region ../zenrpc/src/transport.ts
+function createRpcRouter() {
+	const routes = /* @__PURE__ */ new Map();
+	return {
+		send(data, clientId) {
+			routes.get(clientId)?.(data);
+		},
+		connection(opts) {
+			const clientId = nanoid();
+			routes.set(clientId, opts.send);
+			return {
+				clientId,
+				receive(data) {
+					opts.postMessage(data, clientId);
+				},
+				close() {
+					routes.delete(clientId);
+					opts.removeClient(clientId);
+				}
+			};
+		}
+	};
+}
+async function connectRpc(opts) {
+	const clientId = opts.clientId ?? nanoid();
+	let postMessage = null;
+	const buffer = [];
+	const unsub = opts.subscribe((data) => {
+		if (postMessage) postMessage(data);
+		else buffer.push(data);
+	});
+	const rpc = createClient({
+		version: opts.version,
+		clientId,
+		send: opts.send
+	});
+	postMessage = rpc.postMessage;
+	for (const data of buffer) rpc.postMessage(data);
+	await rpc.ready;
+	const events = createEventProxy(rpc.eventListeners);
+	return {
+		server: rpc.server,
+		events,
+		disconnect: () => {
+			unsub();
+		}
+	};
+}
+//#endregion
+export { createRpcRouter as n, createServer as r, connectRpc as t };

package/dist/trace-DCB7qFzT.mjs

@@ -0,0 +1,10 @@
+//#region ../kyju/src/v2/trace.ts
+/**
+* No-op trace helpers preserved for ergonomic call-site shape inside kyju
+* internals. Historically wrapped operations in a boot-trace span; now just
+* runs `fn`/the passed Effect verbatim with zero observability overhead.
+*/
+const traceKyju = (_name, eff, _meta) => eff;
+const traceKyjuSync = (_name, fn, _meta) => fn();
+//#endregion
+export { traceKyjuSync as n, traceKyju as t };