@zenbujs/core 0.0.1

package/dist/dev-BuqklM0k.mjs

@@ -0,0 +1,85 @@
+import { existsSync, statSync } from "node:fs";
+import path, { resolve } from "node:path";
+import { spawn } from "node:child_process";
+//#region src/cli/commands/dev.ts
+/**
+* `zen dev` — launch the local app under Electron with the setup-gate as the
+* main entry. This is the entrypoint of `pnpm dev` in scaffolded apps. The
+* command is intentionally hookable: future versions can layer doctor checks,
+* environment validation, or a managed dev-server here without touching the
+* user's `package.json` scripts.
+*
+* Defaults to a foreground/blocking child so Ctrl+C in the terminal kills the
+* Electron process and `pnpm dev` exits cleanly. Pass `--detach` to spawn it
+* in the background instead (returns immediately, Electron lives until quit).
+*/
+function parseArgs(argv) {
+	let pathArg;
+	let detach = false;
+	let verbose = false;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--detach") detach = true;
+		else if (arg === "--verbose" || arg === "-v") verbose = true;
+		else if (!arg.startsWith("-") && pathArg == null) pathArg = arg;
+		else {
+			console.error(`zen dev: unknown flag "${arg}"`);
+			console.error(`valid: zen dev [path] [--detach] [--verbose]`);
+			process.exit(1);
+		}
+	}
+	const projectDir = pathArg ? resolve(process.cwd(), pathArg) : process.cwd();
+	if (!existsSync(projectDir)) {
+		console.error(`zen dev: path "${pathArg}" does not exist`);
+		process.exit(1);
+	}
+	try {
+		if (!statSync(projectDir).isDirectory()) {
+			console.error(`zen dev: path "${pathArg}" is not a directory`);
+			process.exit(1);
+		}
+	} catch {
+		console.error(`zen dev: cannot stat "${pathArg}"`);
+		process.exit(1);
+	}
+	return {
+		projectDir,
+		detach,
+		verbose
+	};
+}
+function resolveLocalElectron(projectDir) {
+	const candidates = [path.join(projectDir, "node_modules", "electron", "dist", "Electron.app", "Contents", "MacOS", "Electron"), path.join(projectDir, "node_modules", ".bin", "electron")];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+	throw new Error(`Electron is not installed in ${projectDir}. Run \`pnpm install\` in the app.`);
+}
+function ensureSetupGate(projectDir) {
+	const setupGate = path.join(projectDir, "node_modules", "@zenbujs", "core", "dist", "setup-gate.mjs");
+	if (!existsSync(setupGate)) throw new Error(`@zenbujs/core setup-gate not found at ${setupGate}. Run \`pnpm install\` in the app.`);
+}
+async function runDev(argv) {
+	const { projectDir, detach, verbose } = parseArgs(argv);
+	if (verbose) console.error("[zen dev] launching:", projectDir);
+	const electron = resolveLocalElectron(projectDir);
+	ensureSetupGate(projectDir);
+	const electronArgs = [projectDir, `--project=${projectDir}`];
+	if (detach) {
+		spawn(electron, electronArgs, {
+			cwd: projectDir,
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+		return;
+	}
+	const child = spawn(electron, electronArgs, {
+		cwd: projectDir,
+		stdio: "inherit"
+	});
+	process.on("SIGINT", () => child.kill("SIGINT"));
+	process.on("SIGTERM", () => child.kill("SIGTERM"));
+	child.on("exit", (code, signal) => {
+		process.exit(code ?? (signal ? 1 : 0));
+	});
+}
+//#endregion
+export { runDev };

package/dist/env-bootstrap-BtVME-CU.d.mts

@@ -0,0 +1,16 @@
+//#region src/env-bootstrap.d.ts
+declare function bootstrapEnv(): {
+  paths: {
+    cacheRoot: string;
+    binDir: string;
+    bunInstall: string;
+    bunPath: string;
+    pnpmHome: string;
+    pnpmPath: string;
+    gitPath: string;
+    writtenAt: number;
+  };
+  needsToolchainDownload: boolean;
+};
+//#endregion
+export { bootstrapEnv as t };

package/dist/env-bootstrap-rj7I-59x.mjs

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+//#region src/env-bootstrap.ts
+const internalDir = path.join(os.homedir(), ".zenbu", ".internal");
+const pathsJson = path.join(internalDir, "paths.json");
+function userCacheRoot() {
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Caches");
+	if (process.platform === "win32") return process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+	return process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+}
+function computePaths() {
+	const cacheRoot = path.join(userCacheRoot(), "Zenbu");
+	const binDir = path.join(cacheRoot, "bin");
+	return {
+		cacheRoot,
+		binDir,
+		bunInstall: path.join(cacheRoot, "bun"),
+		bunPath: path.join(binDir, "bun"),
+		pnpmHome: path.join(cacheRoot, "pnpm"),
+		pnpmPath: path.join(binDir, "pnpm"),
+		gitPath: path.join(binDir, "git"),
+		writtenAt: Date.now()
+	};
+}
+function bootstrapEnv() {
+	const paths = computePaths();
+	try {
+		fs.mkdirSync(paths.binDir, { recursive: true });
+	} catch {}
+	const toolchainReady = fs.existsSync(paths.bunPath) && fs.existsSync(paths.pnpmPath);
+	if (toolchainReady) {
+		process.env.BUN_INSTALL ??= paths.bunInstall;
+		process.env.PNPM_HOME ??= paths.pnpmHome;
+	}
+	const pathParts = toolchainReady ? [paths.binDir, process.env.PATH ?? ""] : [process.env.PATH ?? ""];
+	const seen = /* @__PURE__ */ new Set();
+	process.env.PATH = pathParts.flatMap((part) => part.split(path.delimiter)).filter((part) => {
+		if (!part || seen.has(part)) return false;
+		seen.add(part);
+		return true;
+	}).join(path.delimiter);
+	try {
+		fs.mkdirSync(internalDir, { recursive: true });
+		fs.writeFileSync(pathsJson, JSON.stringify(paths, null, 2));
+	} catch {}
+	return {
+		paths,
+		needsToolchainDownload: !toolchainReady
+	};
+}
+//#endregion
+export { bootstrapEnv as t };

package/dist/env-bootstrap.d.mts

@@ -0,0 +1,2 @@
+import { t as bootstrapEnv } from "./env-bootstrap-BtVME-CU.mjs";
+export { bootstrapEnv };

package/dist/env-bootstrap.mjs

@@ -0,0 +1,2 @@
+import { t as bootstrapEnv } from "./env-bootstrap-rj7I-59x.mjs";
+export { bootstrapEnv };

package/dist/http-IBcLzbYu.mjs

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

package/dist/index-Bhlbyrn7.d.mts

@@ -0,0 +1,63 @@
+import * as Effect from "effect/Effect";
+
+//#region ../zenrpc/src/types.d.ts
+type AnyRouter = {
+  [key: string]: ((...args: any[]) => any) | AnyRouter;
+};
+/**
+ * Strips Error/Effect internals from a tagged error type, keeping _tag
+ * and user-defined data fields. Excludes stack, name, cause, symbols,
+ * and function-valued properties.
+ */
+type SerializedError<E> = E extends {
+  readonly _tag: string;
+} ? { [K in keyof E as K extends symbol ? never : K extends "stack" | "name" | "cause" ? never : E[K] extends ((...args: any[]) => any) ? never : K]: E[K] } : never;
+/**
+ * Result type for Effect-returning router methods.
+ * Always wraps success in { _tag: "success", data: A }.
+ * If E has tagged errors, they're added to the discriminated union.
+ */
+type EffectResult<A, E> = [E] extends [never] ? {
+  readonly _tag: "success";
+  readonly data: A;
+} : {
+  readonly _tag: "success";
+  readonly data: A;
+} | SerializedError<E>;
+/**
+ * Recursively converts a router's methods into Promise-returning versions.
+ *
+ * The first branch is intentional and load-bearing: when a method is
+ * **already async** (`(...args) => Promise<X>`), we hand back `T[K]`
+ * unchanged — an indexed access type — so editors can resolve cmd+click /
+ * go-to-definition through the proxy back to the original service method.
+ * The non-async and Effect branches still `infer` and rebuild the signature
+ * (the call really does need to be wrapped on the wire), at the cost of
+ * breaking go-to-def on those — services that want navigability should make
+ * their RPC methods `async`.
+ */
+type RouterProxy<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => Promise<any>) ? T[K] : T[K] extends ((...args: infer A) => infer R) ? [R] extends [Effect.Effect<infer S, infer E, any>] ? (...args: A) => Promise<EffectResult<S, E>> : (...args: A) => Promise<Awaited<R>> : T[K] extends Record<string, any> ? RouterProxy<T[K]> : never };
+/**
+ * Recursively maps an event definition tree into subscribe proxies.
+ * Every node is both navigable (for nesting) and subscribable (for leaf events).
+ * In practice, only call .subscribe on leaf event nodes.
+ */
+type EventProxy<T> = { [K in keyof T]: T[K] extends Record<string, any> ? EventProxy<T[K]> & {
+  subscribe: (cb: (data: T[K]) => void) => () => void;
+} : {
+  subscribe: (cb: (data: T[K]) => void) => () => void;
+} };
+//#endregion
+//#region ../zenrpc/src/transport.d.ts
+declare function connectRpc<TServerRouter extends AnyRouter, TEvents extends Record<string, any> = Record<string, never>>(opts: {
+  version: string;
+  clientId?: string;
+  send: (data: string) => void;
+  subscribe: (cb: (data: string) => void) => () => void;
+}): Promise<{
+  server: RouterProxy<TServerRouter>;
+  events: EventProxy<TEvents>;
+  disconnect: () => void;
+}>;
+//#endregion
+export { EventProxy as n, RouterProxy as r, connectRpc as t };

package/dist/index-CPZ5d6Hl.d.mts

@@ -0,0 +1,442 @@
+import zod, { infer as __Infer } from "zod";
+import * as Effect from "effect/Effect";
+//#region ../kyju/src/v2/db/schema.d.ts
+type Field<T, HasDefault extends boolean = false> = {
+  schema: T;
+  _defaultValue: any;
+  readonly _hasDefault: HasDefault;
+};
+type BlobRef = {
+  type: "blob";
+  debugName?: string;
+};
+declare const __collectionRefBrand: unique symbol;
+type CollectionRefBrand<T = unknown> = {
+  readonly [__collectionRefBrand]: T;
+};
+type CollectionRefValue<T = unknown> = {
+  collectionId: string;
+  debugName: string;
+} & CollectionRefBrand<T>;
+type InferCollectionItem<T> = T extends CollectionRefBrand<infer Item> ? Item : unknown;
+type InferFieldType<T> = T extends BlobRef ? {
+  blobId: string;
+  debugName: string;
+} : T extends {
+  _zod: {
+    output: any;
+  };
+} ? __Infer<T> : never;
+type FieldSchema = BlobRef | {
+  _zod: {
+    output: any;
+  };
+};
+type SchemaShape = Record<string, Field<FieldSchema, boolean> | zod.ZodType | BlobRef>;
+type InferRoot<T extends SchemaShape> = { [K in keyof T]: T[K] extends BlobRef ? {
+  blobId: string;
+  debugName: string;
+} : T[K] extends Field<infer S, infer D> ? S extends BlobRef ? InferFieldType<S> : [D] extends [true] ? InferFieldType<S> : InferFieldType<S> | undefined : T[K] extends zod.ZodType<infer O> ? O : never };
+type InferSchema<S extends Schema> = S extends Schema<infer TShape> ? TShape : never;
+type Schema<TShape extends SchemaShape = SchemaShape> = {
+  shape: TShape;
+};
+declare function createSchema<TShape extends SchemaShape>(shape: TShape): Schema<TShape>;
+/**
+ * Standalone collection field — drop into a `createSchema({...})` shape next
+ * to raw zod schemas:
+ *
+ *   createSchema({
+ *     logs: collection(z.object({ id: z.string(), text: z.string() })),
+ *   })
+ *
+ * The returned value is a marked zod schema; the runtime + serializer detect
+ * the marker (`__kyjuCollectionRef`) and treat the field as a paginated kyju
+ * collection rather than plain JSON data.
+ */
+declare function collection<T extends zod.ZodType>(itemSchema: T, opts?: {
+  debugName?: string;
+}): zod.ZodType<CollectionRefValue<zod.infer<T>>>;
+/**
+ * Standalone blob field. The returned value is a `BlobRef` marker; the
+ * runtime detects `type: "blob"` and stores the field as a binary blob.
+ */
+declare function blob(opts?: {
+  debugName?: string;
+}): BlobRef;
+//#endregion
+//#region ../kyju/src/v2/shared.d.ts
+type KyjuJSON = string | number | boolean | null | KyjuJSON[] | {
+  [key: string]: KyjuJSON;
+};
+type InvalidSessionError = {
+  readonly _tag: "InvalidSessionError";
+  readonly message: string;
+};
+type VersionMismatchError = {
+  readonly _tag: "VersionMismatchError";
+  readonly message: string;
+};
+type NotFoundError = {
+  readonly _tag: "NotFoundError";
+  readonly message: string;
+};
+type ReferenceExistsError = {
+  readonly _tag: "ReferenceExistsError";
+  readonly message: string;
+};
+type KyjuError = InvalidSessionError | VersionMismatchError | NotFoundError | ReferenceExistsError;
+type ErrorTag = KyjuError["_tag"];
+type Ack<T extends {} = {}, E extends ErrorTag = never> = {
+  type: "ack";
+  requestId: string;
+  sessionId: string;
+  error?: Extract<KyjuError, {
+    _tag: E;
+  }>;
+} & T;
+type RootSetOp = {
+  type: "root.set";
+  path: string[];
+  value: KyjuJSON;
+};
+type CollectionCreateOp = {
+  type: "collection.create";
+  collectionId: string;
+  data?: KyjuJSON[];
+};
+type CollectionConcatOp = {
+  type: "collection.concat";
+  collectionId: string;
+  data: KyjuJSON[];
+  authority?: {
+    startIndex: number;
+    totalCount: number;
+  };
+};
+type CollectionDeleteOp = {
+  type: "collection.delete";
+  collectionId: string;
+};
+type BlobCreateOp = {
+  type: "blob.create";
+  blobId: string;
+  data: Uint8Array;
+  hot?: boolean;
+};
+type BlobSetOp = {
+  type: "blob.set";
+  blobId: string;
+  data: Uint8Array;
+};
+type BlobDeleteOp = {
+  type: "blob.delete";
+  blobId: string;
+};
+type WriteOp = RootSetOp | CollectionCreateOp | CollectionConcatOp | CollectionDeleteOp | BlobCreateOp | BlobSetOp | BlobDeleteOp;
+type CollectionFetchRangeOp = {
+  type: "collection.fetch-range";
+  collectionId: string;
+  range: {
+    start: number;
+    end: number;
+  };
+};
+type BlobReadOp = {
+  type: "blob.read";
+  blobId: string;
+};
+type ReadOp = CollectionFetchRangeOp | BlobReadOp;
+type BlobMetadataUpdate = {
+  type: "blob.metadataUpdate";
+  blobId: string;
+  fileSize: number;
+};
+type ReconnectUpdate = {
+  type: "reconnect";
+};
+type DbUpdateMessage = Ack | BlobMetadataUpdate | ReconnectUpdate;
+type ClientEvent = {
+  kind: "connect";
+  version: number;
+} | {
+  kind: "disconnect";
+} | {
+  kind: "subscribe-collection";
+  collectionId: string;
+} | {
+  kind: "unsubscribe-collection";
+  collectionId: string;
+} | {
+  kind: "write";
+  op: WriteOp;
+} | {
+  kind: "replicated-write";
+  op: WriteOp;
+} | {
+  kind: "read";
+  op: ReadOp;
+} | {
+  kind: "db-update";
+  message: DbUpdateMessage;
+};
+type DbSendEvent = ClientEvent & {
+  replicaId: string;
+};
+type ServerEvent = {
+  kind: "connect";
+  message: {
+    type: "connect";
+    version: number;
+    requestId: string;
+    replicaId: string;
+  };
+} | {
+  kind: "disconnect";
+  message: {
+    type: "disconnect";
+    sessionId: string;
+    requestId: string;
+  };
+  replicaId: string;
+} | {
+  kind: "subscribe-collection";
+  collectionId: string;
+  sessionId: string;
+  requestId: string;
+  replicaId: string;
+} | {
+  kind: "unsubscribe-collection";
+  collectionId: string;
+  sessionId: string;
+  requestId: string;
+  replicaId: string;
+} | {
+  kind: "write";
+  op: WriteOp;
+  sessionId: string;
+  requestId: string;
+  replicaId: string;
+} | {
+  kind: "read";
+  op: ReadOp;
+  sessionId: string;
+  requestId: string;
+  replicaId: string;
+};
+/**
+ * Replica-side collection state. The replica holds the full item set;
+ * paging is an internal storage concern of the database.
+ */
+type CollectionState = {
+  id: string;
+  totalCount: number;
+  items: KyjuJSON[];
+};
+type BlobData = {
+  kind: "hot";
+  value: Uint8Array;
+} | {
+  kind: "cold";
+};
+type ClientBlob = {
+  id: string;
+  data: BlobData;
+  fileSize: number;
+};
+type ClientState = {
+  kind: "connected";
+  sessionId: string;
+  root: KyjuJSON;
+  collections: CollectionState[];
+  blobs: ClientBlob[];
+} | {
+  kind: "disconnected";
+};
+/** @deprecated Use CollectionState */
+type CollectionWindow = CollectionState;
+//#endregion
+//#region ../kyju/src/v2/replica/replica.d.ts
+type CollectionConcatCallback = (data: {
+  collectionId: string;
+  newItems: KyjuJSON[];
+  collection: CollectionState;
+}) => void;
+type CreateReplicaArgs = {
+  send: (event: ServerEvent) => void;
+  maxPageSizeBytes: number;
+  replicaId?: string;
+};
+declare const createReplica: (args: CreateReplicaArgs) => {
+  postMessage: (event: ClientEvent) => Promise<void>;
+  postMessageEffect: (event: ClientEvent) => Effect.Effect<undefined, any, never>;
+  getState: () => ClientState;
+  _forceState: (state: ClientState) => void;
+  subscribe: (cb: (state: ClientState) => void) => (() => void);
+  replicaId: string;
+  onCollectionConcat: (collectionId: string, cb: CollectionConcatCallback) => void;
+  offCollectionConcat: (collectionId: string, cb: CollectionConcatCallback) => void;
+};
+//#endregion
+//#region ../kyju/src/v2/client/client.d.ts
+type EffectCollectionNode<Item> = {
+  concat(items: Item[]): Effect.Effect<void, KyjuError>;
+  read(range?: {
+    start: number;
+    end: number;
+  }): Effect.Effect<void, KyjuError>;
+  create(data?: Item[]): Effect.Effect<void, KyjuError>;
+  delete(): Effect.Effect<void, KyjuError>;
+  subscribe(cb: (value: {
+    collectionId: string;
+    debugName: string;
+  }) => void): () => void;
+  subscribeData(cb: (data: {
+    collection: CollectionWindow;
+    newItems: Item[];
+  }) => void): () => void;
+};
+type EffectBlobNode = {
+  read(): Effect.Effect<void, KyjuError>;
+  set(data: Uint8Array): Effect.Effect<void, KyjuError>;
+  create(data: Uint8Array, hot?: boolean): Effect.Effect<void, KyjuError>;
+  delete(): Effect.Effect<void, KyjuError>;
+};
+type EffectFieldNode<T> = T extends CollectionRefBrand<infer Item> ? EffectCollectionNode<Item> : T extends Array<infer E> ? EffectArrayFieldNode<T, E> : {
+  read(): T;
+  set(value: T): Effect.Effect<void, KyjuError>;
+  subscribe(cb: (value: T) => void): () => void;
+} & (T extends Record<string, any> ? { [K in keyof T]: EffectFieldNode<T[K]> } : {});
+type EffectArrayFieldNode<T extends Array<any>, E> = {
+  read(): T;
+  set(value: T): Effect.Effect<void, KyjuError>;
+  subscribe(cb: (value: T) => void): () => void;
+  length: number;
+  find(predicate: (item: E, index: number, arr: E[]) => boolean): EffectFieldNode<E> | undefined;
+  findIndex(predicate: (item: E, index: number, arr: E[]) => boolean): number;
+  at(index: number): EffectFieldNode<E> | undefined;
+  map<U>(fn: (item: E, index: number, arr: E[]) => U): U[];
+  filter(predicate: (item: E, index: number, arr: E[]) => boolean): E[];
+  some(predicate: (item: E, index: number, arr: E[]) => boolean): boolean;
+  every(predicate: (item: E, index: number, arr: E[]) => boolean): boolean;
+  forEach(fn: (item: E, index: number, arr: E[]) => void): void;
+  reduce<U>(fn: (acc: U, item: E, index: number, arr: E[]) => U, initial: U): U;
+  indexOf(item: E, fromIndex?: number): number;
+  includes(item: E, fromIndex?: number): boolean;
+  slice(start?: number, end?: number): E[];
+  flatMap<U>(fn: (item: E, index: number, arr: E[]) => U | U[]): U[];
+  join(separator?: string): string;
+  [Symbol.iterator](): IterableIterator<E>;
+  [index: number]: EffectFieldNode<E>;
+};
+type CollectionNode<Item> = {
+  concat(items: Item[]): Promise<void>;
+  read(range?: {
+    start: number;
+    end: number;
+  }): Promise<void>;
+  create(data?: Item[]): Promise<void>;
+  delete(): Promise<void>;
+  subscribe(cb: (value: {
+    collectionId: string;
+    debugName: string;
+  }) => void): () => void;
+  subscribeData(cb: (data: {
+    collection: CollectionWindow;
+    newItems: Item[];
+  }) => void): () => void;
+};
+type BlobNode = {
+  read(): Promise<void>;
+  set(data: Uint8Array): Promise<void>;
+  create(data: Uint8Array, hot?: boolean): Promise<void>;
+  delete(): Promise<void>;
+};
+type FieldNode<T> = T extends CollectionRefBrand<infer Item> ? CollectionNode<Item> : T extends Array<infer E> ? ArrayFieldNode<T, E> : {
+  read(): T;
+  set(value: T): Promise<void>;
+  subscribe(cb: (value: T) => void): () => void;
+} & (T extends Record<string, any> ? { [K in keyof T]: FieldNode<T[K]> } : {});
+type ArrayFieldNode<T extends Array<any>, E> = {
+  read(): T;
+  set(value: T): Promise<void>;
+  subscribe(cb: (value: T) => void): () => void;
+  length: number;
+  find(predicate: (item: E, index: number, arr: E[]) => boolean): FieldNode<E> | undefined;
+  findIndex(predicate: (item: E, index: number, arr: E[]) => boolean): number;
+  at(index: number): FieldNode<E> | undefined;
+  map<U>(fn: (item: E, index: number, arr: E[]) => U): U[];
+  filter(predicate: (item: E, index: number, arr: E[]) => boolean): E[];
+  some(predicate: (item: E, index: number, arr: E[]) => boolean): boolean;
+  every(predicate: (item: E, index: number, arr: E[]) => boolean): boolean;
+  forEach(fn: (item: E, index: number, arr: E[]) => void): void;
+  reduce<U>(fn: (acc: U, item: E, index: number, arr: E[]) => U, initial: U): U;
+  indexOf(item: E, fromIndex?: number): number;
+  includes(item: E, fromIndex?: number): boolean;
+  slice(start?: number, end?: number): E[];
+  flatMap<U>(fn: (item: E, index: number, arr: E[]) => U | U[]): U[];
+  join(separator?: string): string;
+  [Symbol.iterator](): IterableIterator<E>;
+  [index: number]: FieldNode<E>;
+};
+type ResolveField<V> = V extends Field<infer S, boolean> ? InferFieldType<S> : V extends zod.ZodType<infer O> ? O : never;
+type EffectClientProxy<Shape extends SchemaShape> = { [K in keyof Shape]: Shape[K] extends Field<BlobRef, boolean> ? EffectBlobNode : EffectFieldNode<ResolveField<Shape[K]>> } & {
+  readRoot(): InferRoot<Shape>;
+  update(fn: (root: InferRoot<Shape>) => void | InferRoot<Shape>): Effect.Effect<void, KyjuError>;
+  createBlob(data: Uint8Array, hot?: boolean): Effect.Effect<string, KyjuError>;
+  deleteBlob(blobId: string): Effect.Effect<void, KyjuError>;
+  getBlobData(blobId: string): Effect.Effect<Uint8Array | null, KyjuError>;
+};
+type ClientProxy<Shape extends SchemaShape> = { [K in keyof Shape]: Shape[K] extends Field<BlobRef, boolean> ? BlobNode : FieldNode<ResolveField<Shape[K]>> } & {
+  readRoot(): InferRoot<Shape>;
+  update(fn: (root: InferRoot<Shape>) => void | InferRoot<Shape>): Promise<void>;
+  createBlob(data: Uint8Array, hot?: boolean): Promise<string>;
+  deleteBlob(blobId: string): Promise<void>;
+  getBlobData(blobId: string): Promise<Uint8Array | null>;
+};
+//#endregion
+//#region ../kyju/src/v2/transport.d.ts
+declare function dbStringify(value: unknown): string;
+declare function dbParse(text: string): any;
+declare function createRouter(): {
+  send(event: DbSendEvent): void;
+  connection(opts: {
+    send: (event: DbSendEvent) => void;
+    postMessage: (event: ServerEvent) => Promise<void>;
+  }): {
+    receive(event: ServerEvent): Promise<void>;
+    close(): void;
+  };
+};
+declare function connectReplica<T extends SchemaShape>(opts: {
+  send: (event: ServerEvent) => void;
+  subscribe: (cb: (event: DbSendEvent) => void) => () => void;
+  maxPageSizeBytes?: number;
+}): Promise<{
+  client: ClientProxy<T>;
+  replica: ReturnType<typeof createReplica>;
+  disconnect: () => Promise<void>;
+}>;
+//#endregion
+//#region ../kyju/src/v2/db/db.d.ts
+type Db<TShape extends SchemaShape = SchemaShape> = {
+  postMessage: (event: ServerEvent) => Promise<void>;
+  reconnectClients: () => Promise<void>;
+  /**
+   * Drain the lagged-persistence queue: writes that were applied to the
+   * in-memory root cache but not yet committed to disk. Idempotent and
+   * cheap when nothing is pending. Call before clean shutdown to ensure
+   * durability of any writes that completed during this process's lifetime.
+   */
+  flush: () => Promise<void>;
+  /**
+   * Flush + release the cross-process lock at `<dbPath>/.lock`. Idempotent;
+   * safe to call from a `process.on("exit")` handler. After `close()`
+   * resolves, another process can open the same `dbPath` without conflict.
+   */
+  close: () => Promise<void>;
+  client: ClientProxy<TShape>;
+  effectClient: EffectClientProxy<TShape>;
+};
+//#endregion
+export { createSchema as S, InferSchema as _, dbStringify as a, blob as b, EffectFieldNode as c, KyjuError as d, CollectionRefBrand as f, InferRoot as g, InferCollectionItem as h, dbParse as i, FieldNode as l, Field as m, connectReplica as n, ClientProxy as o, CollectionRefValue as p, createRouter as r, CollectionNode as s, Db as t, CollectionState as u, Schema as v, collection as x, SchemaShape as y };

package/dist/index-FtE8MXJ_.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { t as bootstrapEnv } from "./env-bootstrap-BtVME-CU.mjs";
+import { t as setupGate } from "./setup-gate-BqOzm7zp.mjs";
+import { a as runtime, i as optional, n as Service, o as serviceWithDeps, r as ServiceRuntime, t as CleanupReason } from "./runtime-CjqDr8Yf.mjs";
+import { n as SchemaRoot, o as schema, t as CoreSchema } from "./schema-DMoSkwUx.mjs";
+import { i as CoreServiceRouter, n as CoreEvents, r as CorePreloads, t as CoreDbSections } from "./registry-Dh_e7HU1.mjs";
+export { CleanupReason, CoreDbSections, CoreEvents, CorePreloads, CoreSchema, SchemaRoot as CoreSchemaRoot, CoreServiceRouter, Service, ServiceRuntime, bootstrapEnv, schema as coreSchema, optional, runtime, serviceWithDeps, setupGate };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { t as bootstrapEnv } from "./env-bootstrap-rj7I-59x.mjs";
+import { t as setupGate } from "./setup-gate-BeD6WS6d.mjs";
+import { a as serviceWithDeps, i as runtime, n as ServiceRuntime, r as optional, t as Service } from "./runtime-DUFKDIe4.mjs";
+import { t as schema } from "./schema-dGK6qkfR.mjs";
+export { Service, ServiceRuntime, bootstrapEnv, schema as coreSchema, optional, runtime, serviceWithDeps, setupGate };