@zenbujs/core 0.0.1

package/dist/schema-CIg4GzHQ.mjs

@@ -0,0 +1,100 @@
+import zod from "zod";
+//#region ../kyju/src/v2/db/schema.ts
+const NO_DEFAULT = Symbol.for("kyju.NO_DEFAULT");
+function wrapField(zodSchema) {
+	return Object.assign({
+		schema: zodSchema,
+		_defaultValue: NO_DEFAULT,
+		_hasDefault: false
+	}, {
+		default: (value) => ({
+			schema: zodSchema,
+			_defaultValue: value,
+			_hasDefault: true
+		}),
+		nullable: () => wrapField(zodSchema.nullable())
+	});
+}
+const COLLECTION_REF_MARKER = "__kyjuCollectionRef";
+const f = new Proxy({
+	collection: (_itemSchema, opts) => {
+		const schema = zod.custom((val) => val != null && typeof val === "object" && "collectionId" in val && "debugName" in val);
+		schema[COLLECTION_REF_MARKER] = true;
+		schema._debugName = opts?.debugName;
+		schema._itemSchema = _itemSchema;
+		return schema;
+	},
+	blob: (opts) => ({
+		schema: {
+			type: "blob",
+			debugName: opts?.debugName
+		},
+		_defaultValue: NO_DEFAULT,
+		_hasDefault: false
+	})
+}, { get(target, prop, receiver) {
+	if (prop in target) return Reflect.get(target, prop, receiver);
+	if (typeof prop === "symbol") return void 0;
+	const original = zod[prop];
+	if (typeof original === "function") return (...args) => wrapField(original(...args));
+	return wrapField(original);
+} });
+function createSchema(shape) {
+	return { shape };
+}
+/**
+* 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.
+*/
+function collection(itemSchema, opts) {
+	const schema = zod.custom((val) => val != null && typeof val === "object" && "collectionId" in val && "debugName" in val);
+	schema[COLLECTION_REF_MARKER] = true;
+	schema._debugName = opts?.debugName;
+	schema._itemSchema = itemSchema;
+	return schema;
+}
+/**
+* Standalone blob field. The returned value is a `BlobRef` marker; the
+* runtime detects `type: "blob"` and stores the field as a binary blob.
+*/
+function blob(opts) {
+	return {
+		type: "blob",
+		debugName: opts?.debugName
+	};
+}
+/**
+* Detect a default-value wrapper on a zod schema (`z.string().default("x")`).
+* Returns `{ hasDefault: true, value }` when the schema is a `ZodDefault` (or
+* legacy zod 3 `_def.typeName === "ZodDefault"`), `{ hasDefault: false }`
+* otherwise. Used by the runtime + migration generator to read defaults from
+* raw zod schemas without going through the `Field` wrapper.
+*/
+function getZodDefault(schema) {
+	if (!schema || typeof schema !== "object") return {
+		hasDefault: false,
+		value: void 0
+	};
+	const def = schema.def ?? schema._def;
+	if (def?.type === "default" || def?.typeName === "ZodDefault") {
+		const dv = def.defaultValue;
+		return {
+			hasDefault: true,
+			value: typeof dv === "function" ? dv() : dv
+		};
+	}
+	return {
+		hasDefault: false,
+		value: void 0
+	};
+}
+//#endregion
+export { f as a, createSchema as i, blob as n, getZodDefault as o, collection as r, NO_DEFAULT as t };

package/dist/schema-DMoSkwUx.d.mts

@@ -0,0 +1,62 @@
+import { m as Field, v as Schema } from "./index-CPZ5d6Hl.mjs";
+import zod from "zod";
+
+//#region src/schema.d.ts
+declare const viewRegistryEntrySchema: zod.ZodObject<{
+  scope: zod.ZodString;
+  url: zod.ZodString;
+  port: zod.ZodNumber;
+  icon: zod.ZodOptional<zod.ZodString>;
+  meta: zod.ZodOptional<zod.ZodObject<{
+    kind: zod.ZodOptional<zod.ZodString>;
+    sidebar: zod.ZodOptional<zod.ZodBoolean>;
+    bottomPanel: zod.ZodOptional<zod.ZodBoolean>;
+    label: zod.ZodOptional<zod.ZodString>;
+  }, zod.core.$strip>>;
+}, zod.core.$strip>;
+declare const windowBoundsSchema: zod.ZodObject<{
+  x: zod.ZodNumber;
+  y: zod.ZodNumber;
+  width: zod.ZodNumber;
+  height: zod.ZodNumber;
+}, zod.core.$strip>;
+declare const windowPrefsSchema: zod.ZodObject<{
+  lastKnownBounds: zod.ZodOptional<zod.ZodObject<{
+    x: zod.ZodNumber;
+    y: zod.ZodNumber;
+    width: zod.ZodNumber;
+    height: zod.ZodNumber;
+  }, zod.core.$strip>>;
+}, zod.core.$strip>;
+declare const schema: Schema<{
+  lastKnownViewRegistry: Field<zod.ZodArray<zod.ZodObject<{
+    scope: zod.ZodString;
+    url: zod.ZodString;
+    port: zod.ZodNumber;
+    icon: zod.ZodOptional<zod.ZodString>;
+    meta: zod.ZodOptional<zod.ZodObject<{
+      kind: zod.ZodOptional<zod.ZodString>;
+      sidebar: zod.ZodOptional<zod.ZodBoolean>;
+      bottomPanel: zod.ZodOptional<zod.ZodBoolean>;
+      label: zod.ZodOptional<zod.ZodString>;
+    }, zod.core.$strip>>;
+  }, zod.core.$strip>>, true>;
+  windowPrefs: Field<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+    lastKnownBounds: zod.ZodOptional<zod.ZodObject<{
+      x: zod.ZodNumber;
+      y: zod.ZodNumber;
+      width: zod.ZodNumber;
+      height: zod.ZodNumber;
+    }, zod.core.$strip>>;
+  }, zod.core.$strip>>, true>;
+}>;
+type ViewRegistryEntry = zod.infer<typeof viewRegistryEntrySchema>;
+type WindowBounds = zod.infer<typeof windowBoundsSchema>;
+type WindowPrefs = zod.infer<typeof windowPrefsSchema>;
+type SchemaRoot = {
+  lastKnownViewRegistry: ViewRegistryEntry[];
+  windowPrefs: Record<string, WindowPrefs>;
+};
+type CoreSchema = typeof schema.shape;
+//#endregion
+export { WindowPrefs as a, WindowBounds as i, SchemaRoot as n, schema as o, ViewRegistryEntry as r, CoreSchema as t };

package/dist/schema-dGK6qkfR.mjs

@@ -0,0 +1,28 @@
+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/schema.d.mts

@@ -0,0 +1,2 @@
+import { a as WindowPrefs, i as WindowBounds, n as SchemaRoot, o as schema, r as ViewRegistryEntry, t as CoreSchema } from "./schema-DMoSkwUx.mjs";
+export { CoreSchema, SchemaRoot, ViewRegistryEntry, WindowBounds, WindowPrefs, schema };

package/dist/schema.mjs

@@ -0,0 +1,2 @@
+import { t as schema } from "./schema-dGK6qkfR.mjs";
+export { schema };

package/dist/server-BXwZEQ-n.mjs

@@ -0,0 +1,66 @@
+import { i as runtime, t as Service } from "./runtime-DUFKDIe4.mjs";
+import { t as createLogger } from "./log-CyKv8hQg.mjs";
+import http from "node:http";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { WebSocketServer } from "ws";
+//#region src/services/server.ts
+const log = createLogger("server");
+var ServerService = class extends Service {
+	static key = "server";
+	static deps = {};
+	server = null;
+	wss = null;
+	port = 0;
+	authToken = randomBytes(32).toString("base64url");
+	upgradeHandlers = [];
+	addUpgradeHandler(handler) {
+		this.upgradeHandlers.push(handler);
+		return () => {
+			this.upgradeHandlers = this.upgradeHandlers.filter((h) => h !== handler);
+		};
+	}
+	async evaluate() {
+		if (!this.server) {
+			this.server = http.createServer();
+			this.wss = new WebSocketServer({ noServer: true });
+			this.server.on("upgrade", (req, socket, head) => {
+				for (const handler of this.upgradeHandlers) if (handler(req, socket, head)) return;
+				if (!this.isAuthorizedUpgrade(req)) {
+					socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
+					socket.destroy();
+					return;
+				}
+				this.wss.handleUpgrade(req, socket, head, (ws) => {
+					this.wss.emit("connection", ws, req);
+				});
+			});
+			this.port = await new Promise((resolve) => {
+				this.server.listen(0, () => {
+					const addr = this.server.address();
+					resolve(typeof addr === "object" && addr ? addr.port : 0);
+				});
+			});
+			log.verbose(`listening on port ${this.port}`);
+		}
+		this.setup("server-cleanup", () => {
+			return () => {
+				this.wss?.close();
+				this.server?.close();
+				this.server?.closeAllConnections();
+				this.server = null;
+				this.wss = null;
+			};
+		});
+	}
+	isAuthorizedUpgrade(req) {
+		const rawUrl = req.url ?? "/";
+		const token = new URL(rawUrl, "http://127.0.0.1").searchParams.get("token");
+		if (!token) return false;
+		const expected = Buffer.from(this.authToken);
+		const actual = Buffer.from(token);
+		return actual.length === expected.length && timingSafeEqual(actual, expected);
+	}
+};
+runtime.register(ServerService, import.meta);
+//#endregion
+export { ServerService as t };

package/dist/server-DjrZUbbu.mjs

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

package/dist/services/default.d.mts

@@ -0,0 +1,11 @@
+//#region src/services/default.d.ts
+/**
+ * Loads and registers all built-in services. Kept separate from
+ * `./index.ts` (which statically re-exports the service classes for
+ * `serviceWithDeps(...)` consumers) so that `setup-gate` can import it without
+ * eagerly loading every service module before `setupGate()` has had a
+ * chance to bootstrap env vars and `process.chdir(projectRoot)`.
+ */
+declare function defaultServices(): Promise<void>;
+//#endregion
+export { defaultServices };

package/dist/services/default.mjs

@@ -0,0 +1,22 @@
+//#region src/services/default.ts
+/**
+* Loads and registers all built-in services. Kept separate from
+* `./index.ts` (which statically re-exports the service classes for
+* `serviceWithDeps(...)` consumers) so that `setup-gate` can import it without
+* eagerly loading every service module before `setupGate()` has had a
+* chance to bootstrap env vars and `process.chdir(projectRoot)`.
+*/
+async function defaultServices() {
+	await import("../server-DjrZUbbu.mjs");
+	await import("../reloader-BCkLjDhS.mjs");
+	await import("../renderer-host-DpvBPTHJ.mjs");
+	await import("../http-IBcLzbYu.mjs");
+	await import("../db-ByKPbnP6.mjs");
+	await import("../base-window-DEIAk618.mjs");
+	await import("../rpc-CqitnyR4.mjs");
+	await import("../view-registry-BualWgAf.mjs");
+	await import("../window-CM2a9Kyc.mjs");
+	await import("../advice-config-Cy133IQP.mjs");
+}
+//#endregion
+export { defaultServices };

package/dist/services/index.d.mts

@@ -0,0 +1,276 @@
+import { c as EffectFieldNode, d as KyjuError, l as FieldNode, r as createRouter, t as Db } from "../index-CPZ5d6Hl.mjs";
+import { n as Service, t as CleanupReason } from "../runtime-CjqDr8Yf.mjs";
+import { o as ResolvedDbRoot, s as ResolvedEvents } from "../registry-Dh_e7HU1.mjs";
+import http from "node:http";
+import { WebSocket, WebSocketServer } from "ws";
+import { ViteDevServer } from "vite";
+import * as Effect from "effect/Effect";
+import { BaseWindow } from "electron";
+import * as _$stream from "stream";
+
+//#region src/services/server.d.ts
+type UpgradeHandler = (req: http.IncomingMessage, socket: _$stream.Duplex, head: Buffer) => boolean;
+declare class ServerService extends Service {
+  static key: string;
+  static deps: {};
+  server: http.Server | null;
+  wss: WebSocketServer | null;
+  port: number;
+  authToken: string;
+  private upgradeHandlers;
+  addUpgradeHandler(handler: UpgradeHandler): () => void;
+  evaluate(): Promise<void>;
+  private isAuthorizedUpgrade;
+}
+//#endregion
+//#region src/services/reloader.d.ts
+interface ReloaderEntry {
+  id: string;
+  root: string;
+  url: string;
+  port: number;
+  viteServer: ViteDevServer;
+}
+declare class ReloaderService extends Service {
+  static key: string;
+  static deps: {};
+  private servers;
+  create(id: string, root: string, configFile?: string | false): Promise<ReloaderEntry>;
+  get(id: string): ReloaderEntry | undefined;
+  remove(id: string): Promise<void>;
+  evaluate(): void;
+}
+//#endregion
+//#region src/services/http.d.ts
+type ConnectedCallback = (id: string, ws: WebSocket) => void;
+type DisconnectedCallback = (id: string) => void;
+type RequestHandler = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+declare class HttpService extends Service {
+  static key: string;
+  static deps: {
+    server: typeof ServerService;
+    reloader: typeof ReloaderService;
+  };
+  ctx: {
+    server: ServerService;
+    reloader: ReloaderService;
+  };
+  connectedCallbacks: ConnectedCallback[];
+  disconnectedCallbacks: DisconnectedCallback[];
+  activeConnections: Map<string, WebSocket>;
+  private requestHandlers;
+  get port(): number;
+  get authToken(): string;
+  addRequestHandler(prefix: string, handler: RequestHandler): () => void;
+  onConnected(cb: ConnectedCallback): () => void;
+  onDisconnected(cb: DisconnectedCallback): () => void;
+  evaluate(): void;
+}
+//#endregion
+//#region src/services/db.d.ts
+type EffectSectionProxy<S> = { [K in keyof S]: EffectFieldNode<S[K]> };
+type SectionProxy<S> = { [K in keyof S]: FieldNode<S[K]> };
+type Root = ResolvedDbRoot;
+type Plugin$1 = Root extends {
+  plugin: infer P;
+} ? P : never;
+type SectionedEffectClient = {
+  readRoot(): Root;
+  update(fn: (root: Root) => void | Root): 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>;
+  plugin: { [K in keyof Plugin$1]: EffectSectionProxy<Plugin$1[K]> };
+};
+type SectionedClient = {
+  readRoot(): Root;
+  update(fn: (root: Root) => void | Root): Promise<void>;
+  createBlob(data: Uint8Array, hot?: boolean): Promise<string>;
+  deleteBlob(blobId: string): Promise<void>;
+  getBlobData(blobId: string): Promise<Uint8Array | null>;
+  plugin: { [K in keyof Plugin$1]: SectionProxy<Plugin$1[K]> };
+};
+declare class DbService extends Service {
+  static key: string;
+  static deps: {
+    http: typeof HttpService;
+  };
+  ctx: {
+    http: HttpService;
+  };
+  db: Db | null;
+  dbRouter: ReturnType<typeof createRouter> | null;
+  private sectionsHash;
+  private _dbPath;
+  /**
+   * Resolved DB path. Throws if accessed before `evaluate()` has run — the
+   * service contract guarantees deps are evaluated before dependents, so any
+   * access from a dependent service or RPC handler is safe.
+   */
+  get dbPath(): string;
+  get client(): SectionedClient;
+  get effectClient(): SectionedEffectClient;
+  /**
+   * Drain kyju's lagged-persistence queue. Safe to call anytime; idempotent
+   * when nothing is pending. Used by service teardown (effect cleanup) so
+   * shutdown / hot-reload don't lose in-memory writes.
+   */
+  flush(): Promise<void>;
+  /**
+   * Flush + release the kyju cross-process lock at `<dbPath>/.lock`.
+   * Called on service teardown so a subsequent process can open the DB
+   * without seeing a stale lock. Idempotent.
+   */
+  close(): Promise<void>;
+  evaluate(): Promise<void>;
+}
+//#endregion
+//#region src/services/view-registry.d.ts
+interface ViewEntry {
+  scope: string;
+  url: string;
+  port: number;
+  ownsServer: boolean;
+  meta?: {
+    kind?: string;
+    sidebar?: boolean;
+    bottomPanel?: boolean;
+    label?: string;
+  };
+}
+declare class ViewRegistryService extends Service {
+  static key: string;
+  static deps: {
+    reloader: typeof ReloaderService;
+    db: typeof DbService;
+  };
+  ctx: {
+    reloader: ReloaderService;
+    db: DbService;
+  };
+  private views;
+  private manifestIcons;
+  register(scope: string, root: string, configFile?: string | false, meta?: {
+    kind?: string;
+    sidebar?: boolean;
+    bottomPanel?: boolean;
+    label?: string;
+  }): Promise<ViewEntry>;
+  registerAlias(scope: string, reloaderId: string, pathPrefix: string, meta?: {
+    kind?: string;
+    sidebar?: boolean;
+    bottomPanel?: boolean;
+    label?: string;
+  }): ViewEntry;
+  unregister(scope: string): Promise<void>;
+  get(scope: string): ViewEntry | undefined;
+  evaluate(): void;
+  private loadManifestIcons;
+  private syncToDb;
+}
+//#endregion
+//#region src/services/renderer-host.d.ts
+declare class RendererHostService extends Service {
+  static key: string;
+  static deps: {
+    reloader: typeof ReloaderService;
+    viewRegistry: typeof ViewRegistryService;
+  };
+  ctx: {
+    reloader: ReloaderService;
+    viewRegistry: ViewRegistryService;
+  };
+  url: string;
+  port: number;
+  evaluate(): Promise<void>;
+}
+//#endregion
+//#region src/services/base-window.d.ts
+declare const MAIN_WINDOW_ID = "main";
+type WindowBounds = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+declare class BaseWindowService extends Service {
+  static key: string;
+  static deps: {
+    db: typeof DbService;
+  };
+  ctx: {
+    db: DbService;
+  };
+  windows: Map<string, BaseWindow>;
+  private get bootWindows();
+  private set bootWindows(value);
+  private getZenWidth;
+  getWindowId(win: BaseWindow): string | undefined;
+  createWindow(opts?: Partial<WindowBounds> & {
+    windowId?: string;
+    show?: boolean;
+  }): {
+    win: BaseWindow;
+    windowId: string;
+  };
+  evaluate(): void;
+}
+//#endregion
+//#region src/services/rpc.d.ts
+type EmitProxy<T> = { [K in keyof T]: T[K] extends Record<string, any> ? EmitProxy<T[K]> & ((data: T[K]) => void) : (data: T[K]) => void };
+declare class RpcService extends Service {
+  static key: string;
+  static deps: {
+    http: typeof HttpService;
+  };
+  ctx: {
+    http: HttpService;
+  };
+  private _emit;
+  get emit(): EmitProxy<ResolvedEvents>;
+  evaluate(): void;
+}
+//#endregion
+//#region src/services/window.d.ts
+declare const WindowService_base: (abstract new () => {
+  ctx: {
+    baseWindow: BaseWindowService;
+    viewRegistry: ViewRegistryService;
+    http: HttpService;
+    rendererHost: RendererHostService;
+  };
+  __setupCleanups: Map<string, (reason: CleanupReason) => void | Promise<void>>;
+  evaluate(): void | Promise<void>;
+  setup(key: string, fn: () => void | ((reason: CleanupReason) => void | Promise<void>)): void;
+  trace<T>(_name: string, fn: () => T | Promise<T>, _meta?: Record<string, unknown>): Promise<T>;
+  traceSync<T>(_name: string, fn: () => T, _meta?: Record<string, unknown>): T;
+  __cleanupAllSetups(reason?: CleanupReason): Promise<void>;
+}) & {
+  deps: Record<string, (string | (abstract new (...args: any[]) => Service)) | {
+    __optional: true;
+    ref: string | (abstract new (...args: any[]) => Service);
+  }>;
+  key: string;
+};
+declare class WindowService extends WindowService_base {
+  static key: string;
+  private mounted;
+  evaluate(): void;
+  openView(args: {
+    scope: string;
+    windowId?: string;
+    query?: Record<string, string | number | boolean | null | undefined>;
+  }): Promise<{
+    windowId: string;
+  }>;
+  focusWindow(windowId: string): Promise<{
+    ok: true;
+  }>;
+  pickFiles(): Promise<string[] | null>;
+  pickDirectory(): Promise<string | null>;
+  openExternal(url: string): Promise<void>;
+  openPath(filePath: string): Promise<void>;
+  copyToClipboard(text: string): void;
+}
+//#endregion
+export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, ViewRegistryService, WindowService };

package/dist/services/index.mjs

@@ -0,0 +1,7 @@
+import { t as ServerService } from "../server-BXwZEQ-n.mjs";
+import { t as ReloaderService } from "../reloader-lLAJ3lqg.mjs";
+import { n as ViewRegistryService, o as HttpService, r as DbService, t as RendererHostService } from "../renderer-host-Bg8QdeeH.mjs";
+import { n as MAIN_WINDOW_ID, t as BaseWindowService } from "../base-window-BUt8pwbw.mjs";
+import { t as RpcService } from "../rpc-BwwQK6hD.mjs";
+import { t as WindowService } from "../window-CmmpCVX6.mjs";
+export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, ViewRegistryService, WindowService };