@zenbujs/core 0.0.1

package/dist/config-CdVrW85P.mjs

@@ -0,0 +1,59 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+//#region ../kyju/src/cli/config.ts
+const localRequire = createRequire(import.meta.url);
+const CONFIG_NAMES = [
+	"db.config.ts",
+	"db.config.js",
+	"db.config.mjs"
+];
+function findConfigFile(cwd) {
+	for (const name of CONFIG_NAMES) {
+		const p = path.join(cwd, name);
+		if (fs.existsSync(p)) return p;
+	}
+	throw new Error(`No db config found. Expected one of: ${CONFIG_NAMES.join(", ")}`);
+}
+async function loadConfig(configPath) {
+	const dir = path.dirname(path.resolve(configPath));
+	const mod = await loadModule(path.resolve(configPath));
+	const config = mod.default ?? mod;
+	if (!config.schema) throw new Error("db config must specify a 'schema' path");
+	return {
+		schemaPath: path.resolve(dir, config.schema),
+		outPath: path.resolve(dir, config.out ?? "./db"),
+		alias: config.alias
+	};
+}
+async function loadSchema(schemaPath) {
+	const mod = await loadModule(schemaPath);
+	const schema = mod.schema ?? mod.default;
+	if (!schema || !schema.shape) throw new Error(`Schema file must export a 'schema' (via named export or default) created with createSchema(). Got: ${typeof schema}`);
+	return schema;
+}
+/**
+* Load a user-authored TS/ESM module (config, schema, migrations entry).
+* Uses tsx's ESM loader (registered once, lazily) so the loaded module can
+* `import` from packages whose `exports` map only declares an ESM `import`
+* condition — like `@zenbujs/core/db`. The legacy CJS path was incompatible
+* with ESM-only deps because `require()` won't resolve `.mjs` files.
+*/
+async function loadModule(modulePath) {
+	await ensureTsxRegistered();
+	return import(pathToFileURL(path.resolve(modulePath)).href);
+}
+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;
+}
+//#endregion
+export { loadSchema as i, loadConfig as n, loadModule as r, findConfigFile as t };

package/dist/config-LK73dJmO.mjs

@@ -0,0 +1,2 @@
+import { n as loadConfig, t as findConfigFile } from "./config-CdVrW85P.mjs";
+export { findConfigFile, loadConfig };

package/dist/db-ByKPbnP6.mjs

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

package/dist/db-DhuAJrye.mjs

@@ -0,0 +1,531 @@
+import fs, { existsSync, readFileSync } from "node:fs";
+import os, { homedir } from "node:os";
+import path, { join, resolve } from "node:path";
+import fsp from "node:fs/promises";
+//#region src/cli/lib/db-registry.ts
+const INTERNAL_DIR = path.join(os.homedir(), ".zenbu", ".internal");
+const DB_CONFIG_JSON = path.join(INTERNAL_DIR, "db.json");
+const DEFAULT_REGISTRY = {
+	defaultDbPath: null,
+	dbs: []
+};
+function normalize(p) {
+	return path.resolve(p);
+}
+async function ensureDir() {
+	await fsp.mkdir(INTERNAL_DIR, { recursive: true });
+}
+async function loadRegistry() {
+	let raw;
+	try {
+		raw = JSON.parse(await fsp.readFile(DB_CONFIG_JSON, "utf8"));
+	} catch {
+		return { ...DEFAULT_REGISTRY };
+	}
+	if (!raw || typeof raw !== "object") return { ...DEFAULT_REGISTRY };
+	const obj = raw;
+	return {
+		defaultDbPath: typeof obj.defaultDbPath === "string" ? normalize(obj.defaultDbPath) : null,
+		dbs: Array.isArray(obj.dbs) ? obj.dbs.filter((entry) => !!entry && typeof entry === "object" && typeof entry.path === "string").map((entry) => ({
+			path: normalize(entry.path),
+			lastUsedAt: typeof entry.lastUsedAt === "number" ? entry.lastUsedAt : 0
+		})) : []
+	};
+}
+async function saveRegistry(registry) {
+	await ensureDir();
+	await fsp.writeFile(DB_CONFIG_JSON, JSON.stringify(registry, null, 2));
+}
+async function addDb(absPath) {
+	const p = normalize(absPath);
+	await fsp.mkdir(p, { recursive: true });
+	const registry = await loadRegistry();
+	const existing = registry.dbs.find((entry) => entry.path === p);
+	if (existing) existing.lastUsedAt = Date.now();
+	else registry.dbs.push({
+		path: p,
+		lastUsedAt: Date.now()
+	});
+	await saveRegistry(registry);
+	return registry;
+}
+async function removeDb(absPath) {
+	const p = normalize(absPath);
+	const registry = await loadRegistry();
+	registry.dbs = registry.dbs.filter((entry) => entry.path !== p);
+	if (registry.defaultDbPath === p) registry.defaultDbPath = null;
+	await saveRegistry(registry);
+	return registry;
+}
+async function setDefault(absPath) {
+	const p = normalize(absPath);
+	await fsp.mkdir(p, { recursive: true });
+	const registry = await loadRegistry();
+	if (!registry.dbs.some((entry) => entry.path === p)) registry.dbs.push({
+		path: p,
+		lastUsedAt: Date.now()
+	});
+	registry.defaultDbPath = p;
+	await saveRegistry(registry);
+	return registry;
+}
+//#endregion
+//#region src/cli/lib/runtime.ts
+const RUNTIME_JSON = join(homedir(), ".zenbu", ".internal", "runtime.json");
+function readRuntimeConfig() {
+	if (!existsSync(RUNTIME_JSON)) return null;
+	try {
+		const data = JSON.parse(readFileSync(RUNTIME_JSON, "utf-8"));
+		if (typeof data.wsPort !== "number" || typeof data.wsToken !== "string" || typeof data.pid !== "number") return null;
+		try {
+			process.kill(data.pid, 0);
+		} catch {
+			return null;
+		}
+		return {
+			wsPort: data.wsPort,
+			wsToken: data.wsToken,
+			dbPath: data.dbPath,
+			pid: data.pid
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/cli/lib/picker.ts
+const ESC = "\x1B[";
+const HIDE_CURSOR = `${ESC}?25l`;
+const SHOW_CURSOR = `${ESC}?25h`;
+const CLEAR_LINE = `${ESC}2K`;
+const UP = (n) => `${ESC}${n}A`;
+const tty = () => process.stdout.isTTY && process.stdin.isTTY;
+const c = {
+	reset: () => tty() ? "\x1B[0m" : "",
+	dim: (s) => tty() ? `\x1b[2m${s}\x1b[0m` : s,
+	bold: (s) => tty() ? `\x1b[1m${s}\x1b[0m` : s,
+	green: (s) => tty() ? `\x1b[32m${s}\x1b[0m` : s,
+	cyan: (s) => tty() ? `\x1b[36m${s}\x1b[0m` : s,
+	yellow: (s) => tty() ? `\x1b[33m${s}\x1b[0m` : s,
+	magenta: (s) => tty() ? `\x1b[35m${s}\x1b[0m` : s
+};
+function tildify(p) {
+	const home = os.homedir();
+	if (p === home) return "~";
+	if (p.startsWith(home + "/")) return "~" + p.slice(home.length);
+	return p;
+}
+function relTime(ms) {
+	if (!ms) return "—";
+	const diff = Date.now() - ms;
+	if (diff < 0) return "in the future";
+	const s = Math.round(diff / 1e3);
+	if (s < 45) return "just now";
+	const m = Math.round(s / 60);
+	if (m < 60) return `${m}m ago`;
+	const h = Math.round(m / 60);
+	if (h < 24) return `${h}h ago`;
+	const d = Math.round(h / 24);
+	if (d < 30) return `${d}d ago`;
+	const mo = Math.round(d / 30);
+	if (mo < 12) return `${mo}mo ago`;
+	return `${Math.round(mo / 12)}y ago`;
+}
+/**
+* Arrow-key list picker. Returns the chosen index or null if user aborted
+* (Esc / Ctrl-C). Falls back to a stdin number prompt when stdout isn't a
+* TTY so piping/CI doesn't hang.
+*/
+async function pickOne(title, options, initialIndex = 0) {
+	if (options.length === 0) return null;
+	if (!tty()) return await numberPrompt(title, options, initialIndex);
+	const stdin = process.stdin;
+	const stdout = process.stdout;
+	let idx = Math.max(0, Math.min(initialIndex, options.length - 1));
+	const render = (first) => {
+		if (!first) stdout.write(UP(options.length + 1));
+		stdout.write(`${CLEAR_LINE}${title}\n`);
+		for (let i = 0; i < options.length; i++) {
+			const opt = options[i];
+			const selected = i === idx;
+			const arrow = selected ? c.cyan("›") : " ";
+			const label = selected ? c.bold(opt.label) : opt.label;
+			const detail = opt.detail ? ` ${c.dim(opt.detail)}` : "";
+			stdout.write(`${CLEAR_LINE}${arrow} ${label}${detail}\n`);
+		}
+	};
+	stdout.write(HIDE_CURSOR);
+	render(true);
+	return new Promise((resolve) => {
+		const wasRaw = stdin.isRaw;
+		stdin.setRawMode?.(true);
+		stdin.resume();
+		stdin.setEncoding("utf8");
+		const cleanup = (result) => {
+			stdin.off("data", onData);
+			stdin.setRawMode?.(wasRaw ?? false);
+			stdin.pause();
+			stdout.write(SHOW_CURSOR);
+			resolve(result);
+		};
+		const onData = (data) => {
+			if (data === "" || data === "\x1B") return cleanup(null);
+			if (data === "\r" || data === "\n") return cleanup(idx);
+			if (data === "\x1B[A" || data === "k") {
+				idx = (idx - 1 + options.length) % options.length;
+				render(false);
+				return;
+			}
+			if (data === "\x1B[B" || data === "j") {
+				idx = (idx + 1) % options.length;
+				render(false);
+				return;
+			}
+			const n = Number(data);
+			if (Number.isInteger(n) && n >= 1 && n <= options.length) {
+				idx = n - 1;
+				render(false);
+			}
+		};
+		stdin.on("data", onData);
+	});
+}
+async function numberPrompt(title, options, initialIndex) {
+	process.stdout.write(`${title}\n`);
+	for (let i = 0; i < options.length; i++) {
+		const opt = options[i];
+		const detail = opt.detail ? ` ${opt.detail}` : "";
+		process.stdout.write(`  ${i + 1}. ${opt.label}${detail}\n`);
+	}
+	process.stdout.write(`Choose [1-${options.length}] (default ${initialIndex + 1}): `);
+	return new Promise((resolve) => {
+		let buf = "";
+		process.stdin.setEncoding("utf8");
+		process.stdin.resume();
+		const onData = (data) => {
+			buf += data;
+			const nl = buf.indexOf("\n");
+			if (nl === -1) return;
+			process.stdin.off("data", onData);
+			process.stdin.pause();
+			const trimmed = buf.slice(0, nl).trim();
+			if (!trimmed) return resolve(initialIndex);
+			const n = Number(trimmed);
+			if (!Number.isInteger(n) || n < 1 || n > options.length) return resolve(null);
+			resolve(n - 1);
+		};
+		process.stdin.on("data", onData);
+	});
+}
+async function readLine(prompt) {
+	process.stdout.write(prompt);
+	return new Promise((resolve) => {
+		let buf = "";
+		process.stdin.setEncoding("utf8");
+		process.stdin.resume();
+		const onData = (data) => {
+			buf += data;
+			const nl = buf.indexOf("\n");
+			if (nl === -1) return;
+			process.stdin.off("data", onData);
+			process.stdin.pause();
+			resolve(buf.slice(0, nl).trimEnd() || null);
+		};
+		process.stdin.on("data", onData);
+	});
+}
+//#endregion
+//#region src/cli/commands/db.ts
+const ADD_NEW_VALUE = "__add_new__";
+function printUsage(exitCode = 0) {
+	console.log(`
+Usage:
+  zen db                      Interactive picker for the default DB
+  zen db list                 List known DB paths
+  zen db add <path>           Register a path (mkdir -p) without launching
+  zen db default [<path>]     Set the default DB (interactive when omitted)
+  zen db remove [<path>]      Drop a path from the registry (interactive when omitted)
+  zen db generate [...]       Diff a schema against the last snapshot and
+                              write a new migration. Default: walks up from
+                              cwd to the nearest zenbu.plugin.json and reads
+                              "schema" + "migrations" from it. Flags:
+                                --manifest <path>     override manifest path
+                                --schema <path>       schema file (bypasses
+                                                      manifest discovery; must
+                                                      be paired with --migrations)
+                                --migrations <path>   migrations output dir
+                                                      (paired with --schema)
+                                --name <tag>          custom migration name
+                                --custom              generate editable migrate()
+                                --amend               replace the last migration
+`);
+	process.exit(exitCode);
+}
+function annotate(e, defaultPath, activePath) {
+	const tags = [];
+	const rawTags = [];
+	if (e.path === defaultPath) {
+		tags.push(c.green("default"));
+		rawTags.push("default");
+	}
+	if (activePath && e.path === activePath) {
+		tags.push(c.cyan("running"));
+		rawTags.push("running");
+	}
+	return {
+		tags,
+		rawTags
+	};
+}
+async function runList() {
+	const reg = await loadRegistry();
+	const activePath = readRuntimeConfig()?.dbPath ?? null;
+	if (reg.dbs.length === 0) {
+		console.log("No DBs registered yet. Run `zen db add <path>` or `zen --db <path>`.");
+		return;
+	}
+	const rows = [...reg.dbs].sort((a, b) => b.lastUsedAt - a.lastUsedAt).map((e) => {
+		const { tags } = annotate(e, reg.defaultDbPath, activePath);
+		return {
+			path: tildify(e.path),
+			time: relTime(e.lastUsedAt),
+			tags: tags.join(" ")
+		};
+	});
+	const pathW = Math.max(...rows.map((r) => r.path.length), 4);
+	const timeW = Math.max(...rows.map((r) => r.time.length), 9);
+	console.log("");
+	console.log(`  ${c.dim("path".padEnd(pathW))}  ${c.dim("last used".padEnd(timeW))}`);
+	for (const r of rows) console.log(`  ${r.path.padEnd(pathW)}  ${c.dim(r.time.padEnd(timeW))}  ${r.tags}`);
+	console.log("");
+}
+async function runAdd(argv) {
+	const target = argv[0];
+	if (!target) {
+		console.error("zen db add: missing <path>");
+		process.exit(1);
+	}
+	const abs = resolve(process.cwd(), target);
+	await addDb(abs);
+	console.log(`added ${tildify(abs)}`);
+}
+async function pickDefault() {
+	const reg = await loadRegistry();
+	const activePath = readRuntimeConfig()?.dbPath ?? null;
+	const sorted = [...reg.dbs].sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+	const options = sorted.map((e) => {
+		const { rawTags } = annotate(e, reg.defaultDbPath, activePath);
+		return {
+			value: e.path,
+			label: tildify(e.path),
+			detail: [relTime(e.lastUsedAt), ...rawTags].filter(Boolean).join(" · ")
+		};
+	});
+	options.push({
+		value: ADD_NEW_VALUE,
+		label: c.magenta("+ Add a new path…")
+	});
+	const idx = await pickOne("Choose default DB:", options, Math.max(0, sorted.findIndex((e) => e.path === reg.defaultDbPath)));
+	if (idx === null) {
+		console.log("aborted");
+		return;
+	}
+	const chosen = options[idx].value;
+	let target;
+	if (chosen === ADD_NEW_VALUE) {
+		const input = await readLine("New DB path: ");
+		if (!input) {
+			console.log("aborted");
+			return;
+		}
+		target = resolve(process.cwd(), input.replace(/^~/, process.env.HOME ?? "~"));
+	} else target = chosen;
+	await setDefault(target);
+	console.log(`default = ${tildify(target)}`);
+	if (activePath && activePath !== target) console.log(c.yellow(`note: app is currently running on ${tildify(activePath)}; quit and relaunch to pick up the new default.`));
+}
+async function runDefault(argv) {
+	if (argv.length === 0) {
+		await pickDefault();
+		return;
+	}
+	const abs = resolve(process.cwd(), argv[0]);
+	await setDefault(abs);
+	console.log(`default = ${tildify(abs)}`);
+	const running = readRuntimeConfig();
+	if (running?.dbPath && running.dbPath !== abs) console.log(c.yellow(`note: app is currently running on ${tildify(running.dbPath)}; quit and relaunch to pick up the new default.`));
+}
+async function runRemove(argv) {
+	let abs = null;
+	if (argv.length > 0) abs = resolve(process.cwd(), argv[0]);
+	else {
+		const reg = await loadRegistry();
+		if (reg.dbs.length === 0) {
+			console.log("registry is empty");
+			return;
+		}
+		const options = reg.dbs.map((e) => ({
+			value: e.path,
+			label: tildify(e.path),
+			detail: relTime(e.lastUsedAt)
+		}));
+		const idx = await pickOne("Remove which DB?", options, 0);
+		if (idx === null) {
+			console.log("aborted");
+			return;
+		}
+		abs = options[idx].value;
+	}
+	if (!(await loadRegistry()).dbs.some((e) => e.path === abs)) {
+		console.error(`zen db remove: ${tildify(abs)} not in registry`);
+		process.exit(1);
+	}
+	await removeDb(abs);
+	console.log(`removed ${tildify(abs)}`);
+}
+async function runDb(argv) {
+	const [sub, ...rest] = argv;
+	if (!sub) {
+		await pickDefault();
+		return;
+	}
+	if (sub === "help" || sub === "--help" || sub === "-h") printUsage();
+	switch (sub) {
+		case "list":
+		case "ls":
+			await runList();
+			return;
+		case "add":
+			await runAdd(rest);
+			return;
+		case "default":
+			await runDefault(rest);
+			return;
+		case "remove":
+		case "rm":
+			await runRemove(rest);
+			return;
+		case "generate":
+		case "gen":
+			await runGenerate(rest);
+			return;
+		default:
+			console.error(`zen db: unknown subcommand "${sub}"`);
+			printUsage(1);
+	}
+}
+/**
+* Drive the embedded migration generator. Two input modes:
+*
+*   • Manifest mode (default for plugins). Walks up from cwd to the
+*     nearest `zenbu.plugin.json` and reads `schema` + `migrations` from
+*     it — same paths `discoverSections` consumes at runtime, so there's
+*     one source of truth per plugin.
+*
+*   • Direct mode (`--schema <path> --migrations <path>`). Skips manifest
+*     discovery entirely. Used for schemas that aren't a zenbu plugin —
+*     notably `@zenbujs/core`'s framework schema, which is invoked through
+*     a `db:generate` script in `packages/core/package.json`. Composable
+*     for any future internal section without growing privileged flags
+*     into the CLI.
+*
+* Resolution order: direct mode wins when both paths are given; otherwise
+* `--manifest`; otherwise the walk-up. Mixing direct + manifest is an
+* error (the user almost certainly meant one or the other).
+*/
+function findManifest(from) {
+	let dir = path.resolve(from);
+	while (true) {
+		const candidate = path.join(dir, "zenbu.plugin.json");
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+function parseGenerateArgs(argv) {
+	const out = {
+		manifest: null,
+		schema: null,
+		migrationsOut: null,
+		custom: false,
+		amend: false
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--manifest" && i + 1 < argv.length) out.manifest = argv[++i];
+		else if (arg.startsWith("--manifest=")) out.manifest = arg.slice(11);
+		else if (arg === "--schema" && i + 1 < argv.length) out.schema = argv[++i];
+		else if (arg.startsWith("--schema=")) out.schema = arg.slice(9);
+		else if (arg === "--migrations" && i + 1 < argv.length) out.migrationsOut = argv[++i];
+		else if (arg.startsWith("--migrations=")) out.migrationsOut = arg.slice(13);
+		else if (arg === "--name" && i + 1 < argv.length) out.name = argv[++i];
+		else if (arg.startsWith("--name=")) out.name = arg.slice(7);
+		else if (arg === "--custom") out.custom = true;
+		else if (arg === "--amend") out.amend = true;
+	}
+	return out;
+}
+async function runGenerate(argv) {
+	const flags = parseGenerateArgs(argv);
+	const { generateMigration } = await import("./cli-BLbQQIVB.mjs");
+	if (flags.schema || flags.migrationsOut) {
+		if (!flags.schema || !flags.migrationsOut) {
+			console.error("zen db generate: --schema and --migrations must be passed together.");
+			process.exit(1);
+		}
+		if (flags.manifest) {
+			console.error("zen db generate: --manifest is incompatible with --schema/--migrations; pick one input mode.");
+			process.exit(1);
+		}
+		const schemaPath = resolve(process.cwd(), flags.schema);
+		const outPath = resolve(process.cwd(), flags.migrationsOut);
+		console.log(`Schema:  ${schemaPath}`);
+		console.log(`Output:  ${outPath}`);
+		await generateMigration({
+			schemaPath,
+			outPath,
+			name: flags.name,
+			custom: flags.custom,
+			amend: flags.amend
+		});
+		return;
+	}
+	const manifestPath = flags.manifest ? resolve(process.cwd(), flags.manifest) : findManifest(process.cwd());
+	if (!manifestPath) {
+		console.error("zen db generate: no zenbu.plugin.json found in cwd or any parent.");
+		console.error("                 Run from inside the plugin, pass --manifest <path>,");
+		console.error("                 or use --schema <path> --migrations <path> directly.");
+		process.exit(1);
+	}
+	let manifest;
+	try {
+		manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+	} catch (err) {
+		console.error(`zen db generate: failed to parse ${manifestPath}: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+	if (!manifest.schema) {
+		console.error(`zen db generate: ${manifestPath} is missing the required "schema" field.`);
+		process.exit(1);
+	}
+	if (!manifest.migrations) {
+		console.error(`zen db generate: ${manifestPath} is missing the required "migrations" field`);
+		console.error(`                 (the directory the generator writes migrations into).`);
+		process.exit(1);
+	}
+	const baseDir = path.dirname(manifestPath);
+	const schemaPath = path.resolve(baseDir, manifest.schema);
+	const outPath = path.resolve(baseDir, manifest.migrations);
+	console.log(`Plugin: ${manifest.name ?? path.basename(baseDir)}`);
+	console.log(`Manifest: ${manifestPath}`);
+	await generateMigration({
+		schemaPath,
+		outPath,
+		name: flags.name,
+		custom: flags.custom,
+		amend: flags.amend
+	});
+}
+//#endregion
+export { runDb };

package/dist/db.d.mts

@@ -0,0 +1,16 @@
+import { S as createSchema, _ as InferSchema$1, a as dbStringify, b as blob, f as CollectionRefBrand$1, g as InferRoot$1, i as dbParse, n as connectReplica, o as ClientProxy, p as CollectionRefValue$1, s as CollectionNode$1, v as Schema$1, x as collection, y as SchemaShape$1 } from "./index-CPZ5d6Hl.mjs";
+import { z as z$1 } from "zod";
+
+//#region src/db.d.ts
+declare const z: typeof z$1;
+type Schema<TShape extends SchemaShape$1 = SchemaShape$1> = Schema$1<TShape>;
+type SchemaShape = SchemaShape$1;
+type InferSchema<S extends Schema$1> = InferSchema$1<S>;
+type InferRoot<T extends SchemaShape$1> = InferRoot$1<T>;
+type CollectionRefBrand<T = unknown> = CollectionRefBrand$1<T>;
+type CollectionRefValue<T = unknown> = CollectionRefValue$1<T>;
+type CollectionNode<T = unknown> = CollectionNode$1<T>;
+type DbClient<T extends SchemaShape$1 = SchemaShape$1> = ClientProxy<T>;
+declare const connectDb: typeof connectReplica;
+//#endregion
+export { CollectionNode, CollectionRefBrand, CollectionRefValue, DbClient, InferRoot, InferSchema, Schema, SchemaShape, blob, collection, connectDb, createSchema, dbParse, dbStringify, z };

package/dist/db.mjs

@@ -0,0 +1,16 @@
+import { i as createSchema, n as blob, r as collection } from "./schema-CIg4GzHQ.mjs";
+import { i as dbStringify, r as dbParse, t as connectReplica } from "./transport-BMSzG2-F.mjs";
+import { z as z$1 } from "zod";
+//#region src/db.ts
+/**
+* Public DB surface for plugin authors. The underlying engine (kyju) is an
+* internal detail; only the names re-exported here are part of `@zenbujs/core`'s
+* stable contract. The user authors schemas with raw zod plus two named
+* extensions (`collection`, `blob`); they never import `zod` themselves —
+* `z` is re-exported here so there's exactly one zod instance in play and
+* type identities never drift across versions.
+*/
+const z = z$1;
+const connectDb = connectReplica;
+//#endregion
+export { blob, collection, connectDb, createSchema, dbParse, dbStringify, z };