@zenbujs/core 0.0.1

package/dist/monorepo-CmGPHsVm.mjs

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+//#region src/cli/commands/monorepo.ts
+const MARKER_FILE = ".zenbu-dev-link";
+const DEFAULT_MONOREPO = path.join(os.homedir(), ".zenbu", "plugins", "zenbu");
+function resolveProjectDir() {
+	const cwd = process.cwd();
+	if (fs.existsSync(path.join(cwd, "zenbu.plugin.json")) || fs.existsSync(path.join(cwd, "zenbu")) || fs.existsSync(path.join(cwd, MARKER_FILE))) return cwd;
+	console.error("zen monorepo: not in a zenbu project (no zenbu.plugin.json or zenbu/ found)");
+	process.exit(1);
+}
+function resolveMonorepoPath(explicit) {
+	const candidate = explicit || process.env.ZENBU_DEV || DEFAULT_MONOREPO;
+	const resolved = path.resolve(candidate);
+	if (!fs.existsSync(resolved)) {
+		console.error(`zen dev link: monorepo not found at ${resolved}`);
+		process.exit(1);
+	}
+	if (!fs.existsSync(path.join(resolved, "packages", "core"))) {
+		console.error(`zen monorepo link: ${resolved} doesn't look like a zenbu monorepo (missing packages/core)`);
+		process.exit(1);
+	}
+	return resolved;
+}
+async function link(argv) {
+	const projectDir = resolveProjectDir();
+	const monorepoPath = resolveMonorepoPath(argv[0]);
+	const zenbuDir = path.join(projectDir, "zenbu");
+	const markerPath = path.join(projectDir, MARKER_FILE);
+	if (fs.existsSync(markerPath)) {
+		console.log("  Already dev-linked. Run 'zen dev unlink' first to change.");
+		return;
+	}
+	if (fs.lstatSync(zenbuDir, { throwIfNoEntry: false })?.isSymbolicLink()) {
+		console.log("  zenbu/ is already a symlink. Run 'zen dev unlink' first.");
+		return;
+	}
+	let submoduleSha = "";
+	if (fs.existsSync(zenbuDir)) {
+		try {
+			submoduleSha = execFileSync("git", [
+				"-C",
+				zenbuDir,
+				"rev-parse",
+				"HEAD"
+			], { encoding: "utf8" }).trim();
+		} catch {}
+		console.log("  → removing zenbu/ submodule directory...");
+		fs.rmSync(zenbuDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	fs.writeFileSync(markerPath, JSON.stringify({
+		monorepo: monorepoPath,
+		previousSha: submoduleSha,
+		linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2) + "\n");
+	console.log(`  → linking zenbu/ -> ${monorepoPath}`);
+	fs.symlinkSync(monorepoPath, zenbuDir);
+	if (!fs.existsSync(path.join(monorepoPath, "node_modules"))) console.log("  → monorepo missing node_modules, run 'pnpm install' there first");
+	console.log(`\n  ✓ Dev-linked to ${monorepoPath}`);
+	console.log(`  Changes to the monorepo are now live in this project.`);
+	console.log(`  Run 'zen dev unlink' to restore the git submodule.\n`);
+}
+async function unlink(_argv) {
+	const projectDir = resolveProjectDir();
+	const zenbuDir = path.join(projectDir, "zenbu");
+	const markerPath = path.join(projectDir, MARKER_FILE);
+	if (!fs.existsSync(markerPath)) {
+		console.error("zen dev unlink: not dev-linked (no .zenbu-dev-link marker)");
+		process.exit(1);
+	}
+	if (fs.lstatSync(zenbuDir, { throwIfNoEntry: false })?.isSymbolicLink()) {
+		console.log("  → removing symlink...");
+		fs.unlinkSync(zenbuDir);
+	}
+	console.log("  → restoring git submodule...");
+	try {
+		execFileSync("git", [
+			"submodule",
+			"update",
+			"--init",
+			"zenbu"
+		], {
+			cwd: projectDir,
+			stdio: "inherit"
+		});
+	} catch (err) {
+		console.error("  ⚠ submodule restore failed, you may need to run 'git submodule update --init zenbu' manually");
+	}
+	fs.unlinkSync(markerPath);
+	console.log(`\n  ✓ Dev-link removed. zenbu/ restored to git submodule.\n`);
+}
+async function runMonorepo(argv) {
+	const sub = argv[0];
+	if (sub === "link") {
+		await link(argv.slice(1));
+		return;
+	}
+	if (sub === "unlink") {
+		await unlink(argv.slice(1));
+		return;
+	}
+	console.log(`
+zen monorepo — framework-internal monorepo dev tools
+
+Usage:
+  zen monorepo link [monorepo-path]   Symlink zenbu/ to a local monorepo for live editing
+  zen monorepo unlink                 Restore zenbu/ to the git submodule
+
+Environment:
+  ZENBU_DEV    Default monorepo path (fallback: ~/.zenbu/plugins/zenbu)
+`);
+}
+//#endregion
+export { runMonorepo };

package/dist/node-D4M19_mV.mjs

@@ -0,0 +1,5 @@
+import { register } from "node:module";
+//#region ../advice/src/node.ts
+register("./node-loader.mjs", import.meta.url);
+//#endregion
+export {};

package/dist/node-loader.d.mts

@@ -0,0 +1,17 @@
+//#region ../advice/src/node-loader.d.ts
+interface LoadContext {
+  conditions: string[];
+  importAttributes: Record<string, string>;
+  format?: string;
+}
+type NextLoad = (url: string, context: LoadContext) => Promise<{
+  source: string | ArrayBuffer;
+  format: string;
+}>;
+declare function load(url: string, context: LoadContext, nextLoad: NextLoad): Promise<{
+  source: string | ArrayBuffer;
+  format: string;
+  shortCircuit?: boolean;
+}>;
+//#endregion
+export { load };

package/dist/node-loader.mjs

@@ -0,0 +1,33 @@
+import { n as require_lib, t as zenbuAdviceTransform } from "./transform-DJH3vN4b.mjs";
+import { fileURLToPath } from "node:url";
+//#region ../advice/src/node-loader.ts
+var import_lib = require_lib();
+const includeRe = /\.[jt]sx?$/;
+const excludeRe = /node_modules|packages\/advice\//;
+const rootDir = (process.env.ZENBU_ADVICE_ROOT ?? process.cwd()).replace(/\\/g, "/").replace(/\/$/, "");
+async function load(url, context, nextLoad) {
+	if (!url.startsWith("file://")) return nextLoad(url, context);
+	const filePath = fileURLToPath(url);
+	const normalizedPath = filePath.replace(/\\/g, "/");
+	if (!(normalizedPath === rootDir || normalizedPath.startsWith(rootDir + "/")) || !includeRe.test(filePath) || excludeRe.test(filePath)) return nextLoad(url, context);
+	const loaded = await nextLoad(url, context);
+	const source = typeof loaded.source === "string" ? loaded.source : new TextDecoder().decode(loaded.source);
+	const parserPlugins = /\.tsx?$/.test(filePath) ? ["typescript"] : [];
+	if (/\.[jt]sx$/.test(filePath)) parserPlugins.push("jsx");
+	const result = (0, import_lib.transformSync)(source, {
+		filename: filePath,
+		plugins: [[zenbuAdviceTransform, { root: rootDir }]],
+		parserOpts: { plugins: parserPlugins },
+		sourceMaps: "inline",
+		configFile: false,
+		babelrc: false
+	});
+	if (!result?.code) return loaded;
+	return {
+		source: result.code,
+		format: loaded.format,
+		shortCircuit: true
+	};
+}
+//#endregion
+export { load };

package/dist/pause-DvAUNmKn.mjs

@@ -0,0 +1,52 @@
+//#region ../dynohot/dist/runtime/pause.js
+/**
+* Registry of fs.watch-backed watchers that need to be `.close()`'d before
+* process exit. On macOS, `fs.watch` uses FSEvents.framework on a
+* background thread; if we `_exit(0)` (or skip shutdown hooks) while
+* watchers are still armed, FSEvents will try to dispatch events into a
+* dying V8 isolate → `napi_call_function` assertion → SIGABRT. Callers
+* (dynohot's FileWatcher, the kernel's zenbu-loader-hooks) register their
+* fs watchers here and the shell invokes `closeAllWatchers()` as part of
+* shutdown.
+*/
+const WATCHER_SET_KEY = Symbol.for("dynohot.fileWatcher.closables");
+function getClosables() {
+	const g = globalThis;
+	let set = g[WATCHER_SET_KEY];
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		g[WATCHER_SET_KEY] = set;
+	}
+	return set;
+}
+/**
+* Register a closable (typically an `fs.FSWatcher`) for shutdown cleanup.
+* Returns a de-registration function — call it when the watcher is
+* closed normally, so the shutdown list doesn't grow unbounded.
+*/
+function registerWatcherClosable(watcher) {
+	const set = getClosables();
+	set.add(watcher);
+	return () => {
+		set.delete(watcher);
+	};
+}
+/**
+* Close every registered watcher. Call this synchronously immediately
+* before a hard process exit so FSEvents stops dispatching before the V8
+* isolate dies.
+*/
+async function closeAllWatchers() {
+	const set = getClosables();
+	const all = [...set];
+	set.clear();
+	await Promise.allSettled(all.map((w) => {
+		try {
+			return w.close();
+		} catch {
+			return;
+		}
+	}));
+}
+//#endregion
+export { closeAllWatchers, registerWatcherClosable };

package/dist/publish-source-BVgB62Zj.mjs

@@ -0,0 +1,131 @@
+import { a as findBuildConfig, i as push, n as init, o as loadBuildConfig } from "./mirror-sync-CodOnwkD.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import fsp from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+//#region src/cli/commands/publish-source.ts
+function resolveProjectDir() {
+	const cwd = process.cwd();
+	if (fs.existsSync(path.join(cwd, "zenbu.plugin.json"))) return cwd;
+	console.error("zen publish:source: no zenbu.plugin.json found in current directory");
+	process.exit(1);
+}
+function currentSourceSha(projectDir) {
+	try {
+		return execFileSync("git", ["rev-parse", "HEAD"], {
+			cwd: projectDir,
+			encoding: "utf8"
+		}).trim();
+	} catch {
+		return "uncommitted";
+	}
+}
+async function readStagingMeta(stagingDir) {
+	const shaPath = path.join(stagingDir, ".sha");
+	if (!fs.existsSync(stagingDir) || !fs.existsSync(shaPath)) throw new Error(`staging dir missing or incomplete: ${stagingDir}\n  run \`zen build:source\` first.`);
+	return JSON.parse(await fsp.readFile(shaPath, "utf8"));
+}
+function parseFlags(argv) {
+	let subcommand = "push";
+	if (argv[0] === "init" || argv[0] === "push") {
+		subcommand = argv[0];
+		argv = argv.slice(1);
+	}
+	const flags = {
+		subcommand,
+		force: false
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--config" || arg === "-c") flags.config = argv[++i];
+		else if (arg.startsWith("--config=")) flags.config = arg.slice(9);
+		else if (arg === "--target") flags.target = argv[++i];
+		else if (arg.startsWith("--target=")) flags.target = arg.slice(9);
+		else if (arg === "--branch") flags.branch = argv[++i];
+		else if (arg.startsWith("--branch=")) flags.branch = arg.slice(9);
+		else if (arg === "--force" || arg === "-f") flags.force = true;
+	}
+	return flags;
+}
+function expandMirrorUrl(target) {
+	if (target.startsWith("http://") || target.startsWith("https://") || target.startsWith("git@")) return target;
+	if (/^[\w.-]+\/[\w.-]+$/.test(target)) {
+		const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? null;
+		return token ? `https://x-access-token:${token}@github.com/${target}.git` : `https://github.com/${target}.git`;
+	}
+	return target;
+}
+function resolveAuthor(projectDir) {
+	try {
+		const name = execFileSync("git", ["config", "user.name"], {
+			cwd: projectDir,
+			encoding: "utf8"
+		}).trim();
+		const email = execFileSync("git", ["config", "user.email"], {
+			cwd: projectDir,
+			encoding: "utf8"
+		}).trim();
+		return {
+			name: name || void 0,
+			email: email || void 0
+		};
+	} catch {
+		return {};
+	}
+}
+function logResult(action, result, mirrorUrl) {
+	if (result.status === "noop") {
+		console.log(`\n  → ${result.reason ?? "nothing to push"}\n`);
+		return;
+	}
+	const sha = result.mirrorSha ? ` (${result.mirrorSha.slice(0, 7)})` : "";
+	console.log(`\n  ✓ ${action === "init" ? "initialized" : "pushed to"} ${mirrorUrl}${sha}\n`);
+}
+async function runPublishSource(argv) {
+	const projectDir = resolveProjectDir();
+	const flags = parseFlags(argv);
+	const config = await loadBuildConfig(flags.config ? path.resolve(projectDir, flags.config) : findBuildConfig(projectDir));
+	const target = flags.target ?? config.mirror?.target;
+	if (!target) {
+		console.error("zen publish:source: no mirror target specified (config.mirror.target or --target)");
+		process.exit(1);
+	}
+	const branch = flags.branch ?? config.mirror?.branch ?? "main";
+	const mirrorUrl = expandMirrorUrl(target);
+	const stagingDir = path.resolve(projectDir, config.out);
+	const meta = await readStagingMeta(stagingDir);
+	const head = currentSourceSha(projectDir);
+	if (head !== "uncommitted" && meta.sourceSha !== head && !flags.force) {
+		console.error(`zen publish:source: staging is stale (built from ${meta.sourceSha.slice(0, 7)}, current HEAD ${head.slice(0, 7)}).\n  run \`zen build:source\` again, or pass --force to publish staging anyway.`);
+		process.exit(1);
+	}
+	const author = resolveAuthor(projectDir);
+	console.log(`\n  zen publish:source ${flags.subcommand}`);
+	console.log(`    target:  ${target}`);
+	console.log(`    branch:  ${branch}`);
+	console.log(`    source:  ${meta.sourceSha === "uncommitted" ? "uncommitted" : meta.sourceSha.slice(0, 7)}`);
+	try {
+		const result = flags.subcommand === "init" ? await init({
+			staging: stagingDir,
+			mirrorUrl,
+			branch,
+			sourceSha: meta.sourceSha,
+			authorName: author.name,
+			authorEmail: author.email,
+			force: flags.force
+		}) : await push({
+			staging: stagingDir,
+			mirrorUrl,
+			branch,
+			sourceSha: meta.sourceSha,
+			authorName: author.name,
+			authorEmail: author.email
+		});
+		logResult(flags.subcommand, result, target);
+	} catch (err) {
+		console.error(`zen publish:source: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+}
+//#endregion
+export { runPublishSource };

package/dist/react.d.mts

@@ -0,0 +1,76 @@
+import { f as CollectionRefBrand, h as InferCollectionItem, n as connectReplica, o as ClientProxy, p as CollectionRefValue, u as CollectionState, y as SchemaShape } from "./index-CPZ5d6Hl.mjs";
+import { c as ResolvedServiceRouter, l as ZenbuRegister, o as ResolvedDbRoot, s as ResolvedEvents } from "./registry-Dh_e7HU1.mjs";
+import { n as EventProxy, r as RouterProxy } from "./index-Bhlbyrn7.mjs";
+import * as _$react from "react";
+import { ReactNode } from "react";
+
+//#region ../kyju/src/v2/react/index.d.ts
+type CollectionResult<Item> = {
+  items: Item[];
+  totalCount: number;
+  collection: CollectionState | null;
+  concat: (items: Item[]) => void;
+};
+//#endregion
+//#region src/react.d.ts
+type AnyRpc = RouterProxy<Record<string, Record<string, (...args: any[]) => any>>>;
+type AnyEvents = EventProxy<Record<string, unknown>>;
+type AnyDbClient = ClientProxy<SchemaShape>;
+type Replica = Awaited<ReturnType<typeof connectReplica>>["replica"];
+type Connection = {
+  rpc: AnyRpc;
+  events: AnyEvents;
+  db: AnyDbClient;
+  replica: Replica;
+};
+type ConnectionState = {
+  status: "connecting";
+} | {
+  status: "connected";
+  conn: Connection;
+} | {
+  status: "error";
+  error: string;
+};
+type RegisteredDbRoot = ResolvedDbRoot;
+type RegisteredServiceRouter = ResolvedServiceRouter;
+type RegisteredEvents = ResolvedEvents;
+/**
+ * Subscribe to a slice of the live DB. The selector's `root` is typed via
+ * `ZenbuRegister["db"]`, populated by `zen link`. No generic at the call site.
+ *
+ *   const count = useDb((root) => root.plugin.app.count)
+ */
+declare function useDb(): RegisteredDbRoot;
+declare function useDb<T>(selector: (root: RegisteredDbRoot) => T, isEqual?: (a: T, b: T) => boolean): T;
+declare const useCollection: <T extends {
+  collectionId: string;
+} & CollectionRefBrand<unknown>>(ref: T | null | undefined) => CollectionResult<InferCollectionItem<T>>;
+type ZenbuProviderProps = {
+  wsUrl?: string;
+  fallback?: ReactNode;
+  errorFallback?: (error: string) => ReactNode;
+  children: ReactNode;
+};
+declare function ZenbuProvider({
+  wsUrl,
+  fallback,
+  errorFallback,
+  children
+}: ZenbuProviderProps): _$react.ReactElement<{
+  "data-zenbu-connecting": boolean;
+}, string | _$react.JSXElementConstructor<any>> | _$react.ReactElement<{
+  "data-zenbu-error": boolean;
+}, string | _$react.JSXElementConstructor<any>> | _$react.FunctionComponentElement<_$react.ProviderProps<ConnectionState | null>>;
+declare function useRpc(): RouterProxy<RegisteredServiceRouter>;
+type DbClient = {
+  readRoot(): RegisteredDbRoot;
+  update(fn: (root: RegisteredDbRoot) => void | RegisteredDbRoot): Promise<void>;
+  createBlob(data: Uint8Array, hot?: boolean): Promise<string>;
+  deleteBlob(blobId: string): Promise<void>;
+  getBlobData(blobId: string): Promise<Uint8Array | null>;
+};
+declare function useDbClient(): DbClient;
+declare function useEvents(): EventProxy<RegisteredEvents>;
+//#endregion
+export { type CollectionRefValue, DbClient, ZenbuProvider, ZenbuProviderProps, type ZenbuRegister, useCollection, useDb, useDbClient, useEvents, useRpc };