@zenbujs/core 0.0.5 → 0.0.8

package/dist/index-w5QyDjuf.d.mts

@@ -0,0 +1,780 @@
+import { i as Service, t as CleanupReason } from "./runtime-BQWntcOb.mjs";
+import { c as EffectFieldNode, d as KyjuError, l as FieldNode, r as createRouter, t as Db } from "./index-DeDxePAa.mjs";
+import { n as ResolvedEvents, t as ResolvedDbRoot } from "./registry-CMp8FYgS.mjs";
+import http from "node:http";
+import { WebSocket, WebSocketServer } from "ws";
+import { ViteDevServer } from "vite";
+import * as Effect from "effect/Effect";
+import { BaseWindow, WebPreferences } 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 const ServerService_base: (abstract new () => {
+  ctx: {};
+  __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>;
+}) & {
+  key: "server";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class ServerService extends ServerService_base {
+  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 const ReloaderService_base: (abstract new () => {
+  ctx: {};
+  __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>;
+}) & {
+  key: "reloader";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class ReloaderService extends ReloaderService_base {
+  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 const HttpService_base: (abstract new () => {
+  ctx: {
+    server: ServerService;
+    reloader: ReloaderService;
+  };
+  __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>;
+}) & {
+  key: "http";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class HttpService extends HttpService_base {
+  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 const DbService_base: (abstract new () => {
+  ctx: {
+    http: HttpService;
+  };
+  __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>;
+}) & {
+  key: "db";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class DbService extends DbService_base {
+  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 {
+  type: string;
+  url: string;
+  port: number;
+  ownsServer: boolean;
+  meta?: {
+    kind?: string;
+    sidebar?: boolean;
+    bottomPanel?: boolean;
+    label?: string;
+  };
+}
+declare const ViewRegistryService_base: (abstract new () => {
+  ctx: {
+    reloader: ReloaderService;
+    db: DbService;
+  };
+  __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>;
+}) & {
+  key: "view-registry";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class ViewRegistryService extends ViewRegistryService_base {
+  private views;
+  private manifestIcons;
+  register(type: string, root: string, configFile?: string | false, meta?: {
+    kind?: string;
+    sidebar?: boolean;
+    bottomPanel?: boolean;
+    label?: string;
+  }): Promise<ViewEntry>;
+  registerAlias(type: string, reloaderId: string, pathPrefix: string, meta?: {
+    kind?: string;
+    sidebar?: boolean;
+    bottomPanel?: boolean;
+    label?: string;
+  }): ViewEntry;
+  unregister(type: string): Promise<void>;
+  get(type: string): ViewEntry | undefined;
+  evaluate(): void;
+  private loadManifestIcons;
+  private syncToDb;
+}
+//#endregion
+//#region src/services/renderer-host.d.ts
+declare const RendererHostService_base: (abstract new () => {
+  ctx: {
+    reloader: ReloaderService;
+    viewRegistry: ViewRegistryService;
+  };
+  __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>;
+}) & {
+  key: "renderer-host";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class RendererHostService extends RendererHostService_base {
+  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 const BaseWindowService_base: (abstract new () => {
+  ctx: {
+    db: DbService;
+  };
+  __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>;
+}) & {
+  key: "base-window";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class BaseWindowService extends BaseWindowService_base {
+  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 const RpcService_base: (abstract new () => {
+  ctx: {
+    http: HttpService;
+  };
+  __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>;
+}) & {
+  key: "rpc";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class RpcService extends RpcService_base {
+  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>;
+}) & {
+  key: "window";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class WindowService extends WindowService_base {
+  private mounted;
+  evaluate(): void;
+  openView(args: {
+    type: string;
+    windowId?: string;
+    query?: Record<string, string | number | boolean | null | undefined>;
+    view?: {
+      backgroundColor?: string;
+      webPreferences?: WebPreferences;
+    };
+  }): 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
+//#region src/shared/pm-install.d.ts
+/**
+ * Bundled-toolchain `<pm> install` helpers.
+ *
+ * Imported by both:
+ *   - `packages/core/src/launcher.ts` (tsdown inlines this into
+ *     `dist/launcher.mjs`; the launcher cannot `import "@zenbujs/core"`)
+ *   - `packages/core/src/services/updater.ts` (resolved through normal
+ *     `@zenbujs/core/...` resolution at runtime)
+ *
+ * Both call sites operate on the apps-dir (`~/.zenbu/apps/<name>/`) and
+ * the .app's `Resources/` (where `provisionToolchain` staged
+ * `bun`, `pnpm`, etc.). The launcher kicks off the FIRST install at
+ * launch; the updater service runs the SAME logic when an `update()`
+ * lockfile-diff says deps drifted.
+ */
+type PackageManagerSpec = {
+  type: "pnpm";
+  version: string;
+} | {
+  type: "npm";
+  version: string;
+} | {
+  type: "yarn";
+  version: string;
+} | {
+  type: "bun";
+  version: string;
+};
+//#endregion
+//#region src/services/updater.d.ts
+type UpdaterPhase = {
+  phase: "idle";
+} | {
+  phase: "checking";
+} | {
+  phase: "fetching";
+  loaded?: number;
+  total?: number;
+  ratio?: number;
+} | {
+  phase: "resolving";
+  depthConsidered: number;
+} | {
+  phase: "installing";
+  pm: string;
+  line?: string;
+  loaded?: number;
+  total?: number;
+  ratio?: number;
+} | {
+  phase: "applied";
+  sha: string;
+  reranInstall: boolean;
+} | {
+  phase: "up-to-date";
+  sha: string;
+} | {
+  phase: "incompatible";
+  remoteHead: string;
+  reason: string;
+} | {
+  phase: "error";
+  message: string;
+};
+interface UpdaterInfo {
+  mode: "bundle" | "dev";
+  appsDir: string | null;
+  hostVersion: string | null;
+  currentSha: string | null;
+  mirror: {
+    url: string;
+    branch: string;
+  } | null;
+  packageManager: PackageManagerSpec | null;
+}
+interface UpdaterCheckResult {
+  status: "ok" | "dev-mode" | "error" | "no-mirror" | "no-host-version";
+  currentSha: string | null;
+  targetSha: string | null;
+  tipSha: string | null;
+  hasUpdate: boolean;
+  incompatibleHead: boolean;
+  error?: string;
+}
+interface UpdaterUpdateResult {
+  status: "applied" | "up-to-date" | "incompatible" | "dirty-tree" | "dev-mode" | "no-mirror" | "no-host-version" | "in-progress" | "error";
+  appliedSha?: string;
+  reranInstall?: boolean;
+  error?: string;
+}
+declare const UpdaterService_base: (abstract new () => {
+  ctx: {};
+  __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>;
+}) & {
+  key: "updater";
+  deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })>;
+  create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+    key: string;
+  })> = {}>(config: {
+    key: TKey;
+    deps?: TDeps;
+  }): (abstract new () => {
+    ctx: { [K in keyof TDeps]: TDeps[K] extends infer T ? T extends TDeps[K] ? T extends (abstract new (...args: any[]) => Service) & {
+      key: string;
+    } ? InstanceType<T> : unknown : never : never };
+    __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>;
+  }) & {
+    key: TKey;
+    deps: Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })>;
+    create<TKey extends string, TDeps extends Record<string, string | ((abstract new (...args: any[]) => Service) & {
+      key: string;
+    })> = {}>(config: {
+      key: TKey;
+      deps?: TDeps;
+    }): /*elided*/any;
+  };
+};
+declare class UpdaterService extends UpdaterService_base {
+  status: UpdaterPhase;
+  private listeners;
+  private inflight;
+  private pollDisposers;
+  evaluate(): void;
+  /**
+   * Returns the current `UpdaterPhase`. Cheap; safe to poll from the
+   * renderer at ~250ms cadence to drive a progress UI while
+   * `update()` runs.
+   */
+  getStatus(): Promise<UpdaterPhase>;
+  /**
+   * Synchronous-ish snapshot of the updater's environment. Doesn't
+   * touch the network. `currentSha` is read off-disk so very recent
+   * checkouts may lag by a few ms; callers that care about exactness
+   * should call `check()` first.
+   */
+  getInfo(): Promise<UpdaterInfo>;
+  /**
+   * Fetch + resolve target sha without touching the working tree. Use
+   * this for "is there an update?" UI. Cheap enough to call on a timer.
+   */
+  check(): Promise<UpdaterCheckResult>;
+  /**
+   * Apply the latest compatible commit. Pauses HMR while git operations
+   * and `<pm> install` run, so the renderer never sees a half-applied
+   * tree. Refuses when the apps-dir has uncommitted edits.
+   */
+  update(opts?: {
+    dryRun?: boolean;
+  }): Promise<UpdaterUpdateResult>;
+  /**
+   * Subscribe to phase transitions. Fires synchronously with the
+   * current status on attach so callers can render initial state
+   * without a separate read.
+   */
+  onChange(cb: (s: UpdaterPhase) => void): () => void;
+  /**
+   * Convenience polling loop. Calls `check()` every `intervalMs` and,
+   * when `autoApply` is set, invokes `update()` whenever a new
+   * compatible target is found. Returns a disposer.
+   */
+  startPolling(intervalMs: number, opts?: {
+    autoApply?: boolean;
+  }): () => void;
+  private loadContext;
+  private setStatus;
+  private makeReporter;
+  private makeInstallReporter;
+}
+//#endregion
+export { MAIN_WINDOW_ID as a, DbService as c, ServerService as d, BaseWindowService as i, HttpService as l, WindowService as n, RendererHostService as o, RpcService as r, ViewRegistryService as s, UpdaterService as t, ReloaderService as u };