@zhin.js/client 1.0.18 → 1.1.0

package/client/bootstrap/loadConsoleEntries.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it, vi } from "vitest";
+import { createPluginRegisterHostApi, getRegisterFn } from "./loadConsoleEntries.js";
+
+describe("console entries bootstrap", () => {
+  it("resolves named register export", () => {
+    const register = () => {};
+    expect(getRegisterFn({ register })).toBe(register);
+  });
+
+  it("resolves default register export", () => {
+    const register = () => {};
+    expect(getRegisterFn({ default: { register } })).toBe(register);
+  });
+
+  it("returns null when no register export exists", () => {
+    expect(getRegisterFn({ default: {} })).toBeNull();
+  });
+
+  it("creates a host API with addPage aliased to addRoute", () => {
+    const React = {} as any;
+    const addRoute = vi.fn();
+    const addTool = vi.fn(() => "tool-id");
+    const api = createPluginRegisterHostApi({ React, addRoute, addTool });
+
+    api.addPage({ path: "/x", name: "x", element: "page" as any });
+    api.addRoute({ path: "/y", name: "y", element: "route" as any });
+    expect(api.React).toBe(React);
+    expect(addRoute).toHaveBeenCalledTimes(2);
+    expect(api.addTool({ id: "t", name: "T" })).toBe("tool-id");
+  });
+});
+

package/client/bootstrap/loadConsoleEntries.ts

@@ -0,0 +1,149 @@
+import type {
+  ConsoleClientEntry,
+  ConsoleEntriesResponse,
+  ConsolePluginRegister,
+  PluginRegisterHostApi,
+} from "@zhin.js/console-types";
+import { DEFAULT_CONSOLE_BASE_PATH } from "@zhin.js/console-types";
+
+export type FetchConsoleEntriesOptions = {
+  entriesUrl?: string;
+  signal?: AbortSignal;
+  fetchInit?: RequestInit | (() => RequestInit);
+};
+
+export type LoadConsoleEntriesOptions = FetchConsoleEntriesOptions & {
+  /** Origin for `/@dev` / `/@assets` module URLs (Remote Console: Host API base). */
+  assetOrigin?: string;
+  hostApi: PluginRegisterHostApi;
+  beforeLoad?: () => void;
+  onEmpty?: () => void;
+  onFetchError?: (status: number) => void;
+  onEntryError?: (entry: ConsoleClientEntry, error: unknown) => void;
+};
+
+export type CreatePluginRegisterHostApiOptions = {
+  React: PluginRegisterHostApi["React"];
+  addRoute: PluginRegisterHostApi["addRoute"];
+  addTool: PluginRegisterHostApi["addTool"];
+};
+
+export function createPluginRegisterHostApi(
+  options: CreatePluginRegisterHostApiOptions,
+): PluginRegisterHostApi {
+  const addRoute = options.addRoute;
+  return {
+    React: options.React,
+    addRoute,
+    addPage: addRoute,
+    addTool: options.addTool,
+  };
+}
+
+const CONSOLE_API_BASE_STORAGE_KEY = "zhin_api_base";
+
+function resolveStoredApiBase(): string {
+  if (typeof window === "undefined") return "";
+  const stored = localStorage.getItem(CONSOLE_API_BASE_STORAGE_KEY)?.trim();
+  return stored ? stored.replace(/\/$/, "") : "";
+}
+
+function defaultEntriesUrl(): string {
+  const apiBase = resolveStoredApiBase();
+  if (apiBase) return `${apiBase}/entries`;
+  const root = DEFAULT_CONSOLE_BASE_PATH.replace(/\/$/, "");
+  return `${root ? `${root}/entries` : "/entries"}`;
+}
+
+function resolveRequestUrl(pathOrUrl: string): string {
+  if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) return pathOrUrl;
+  if (typeof window === "undefined") return pathOrUrl;
+  const apiBase = resolveStoredApiBase();
+  const origin = apiBase || window.location.origin;
+  return new URL(pathOrUrl, `${origin}/`).href;
+}
+
+function resolvePluginImportUrl(resolvedModule: string, assetOrigin?: string): string {
+  if (resolvedModule.startsWith("http://") || resolvedModule.startsWith("https://")) return resolvedModule;
+  if (typeof window === "undefined") return resolvedModule;
+  const origin = assetOrigin?.replace(/\/$/, "") || window.location.origin;
+  return new URL(resolvedModule, `${origin}/`).href;
+}
+
+function resolveFetchInit(init?: RequestInit | (() => RequestInit)): RequestInit {
+  return typeof init === "function" ? init() : (init ?? {});
+}
+
+export async function fetchConsoleEntries(
+  options?: FetchConsoleEntriesOptions,
+): Promise<ConsoleEntriesResponse> {
+  const pathOrUrl = options?.entriesUrl ?? defaultEntriesUrl();
+  const url = resolveRequestUrl(pathOrUrl);
+  const init = resolveFetchInit(options?.fetchInit);
+  const res = await fetch(url, {
+    ...init,
+    signal: options?.signal ?? init.signal,
+  } as RequestInit);
+  if (!res.ok) throw Object.assign(new Error(`load entries failed: ${res.status}`), { status: res.status });
+  return (await res.json()) as ConsoleEntriesResponse;
+}
+
+export function getRegisterFn(mod: Record<string, unknown> | null | undefined): ConsolePluginRegister | null {
+  if (!mod) return null;
+  const r = mod["register"];
+  if (typeof r === "function") return r as ConsolePluginRegister;
+  const d = mod["default"] as Record<string, unknown> | undefined;
+  if (d && typeof d["register"] === "function") return d["register"] as ConsolePluginRegister;
+  return null;
+}
+
+export async function registerConsolePluginsFromEntries(
+  entries: ConsoleClientEntry[],
+  hostApi: PluginRegisterHostApi,
+  onEntryError?: (entry: ConsoleClientEntry, error: unknown) => void,
+  assetOrigin?: string,
+): Promise<void> {
+  if (!entries.length) return;
+  await Promise.all(
+    entries.map(async (entry) => {
+      try {
+        const specifier = resolvePluginImportUrl(entry.resolvedModule, assetOrigin);
+        const mod = (await import(/* @vite-ignore */ specifier)) as Record<string, unknown>;
+        const register = getRegisterFn(mod);
+        if (register) await register(hostApi);
+        else throw new Error(`entry "${entry.id}" has no register export`);
+      } catch (error) {
+        if (onEntryError) onEntryError(entry, error);
+        else throw error;
+      }
+    }),
+  );
+}
+
+export async function loadConsoleEntries(options: LoadConsoleEntriesOptions): Promise<void> {
+  options.beforeLoad?.();
+  let data: ConsoleEntriesResponse;
+  try {
+    data = await fetchConsoleEntries(options);
+  } catch (error) {
+    const status = typeof (error as { status?: unknown }).status === "number"
+      ? (error as { status: number }).status
+      : 0;
+    if (options.onFetchError) {
+      options.onFetchError(status);
+      return;
+    }
+    throw error;
+  }
+  if (!data.entries?.length) {
+    options.onEmpty?.();
+    return;
+  }
+  await registerConsolePluginsFromEntries(
+    data.entries,
+    options.hostApi,
+    options.onEntryError,
+    options.assetOrigin,
+  );
+}
+

package/client/console-utils/cn.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/client/console-utils/remoteApi.ts

@@ -0,0 +1,48 @@
+const TOKEN_KEY = "zhin_api_token";
+const API_BASE_KEY = "zhin_api_base";
+
+export function getApiBase(): string {
+  const stored = localStorage.getItem(API_BASE_KEY)?.trim();
+  if (stored) return stored.replace(/\/$/, "");
+  if (typeof window !== "undefined") return window.location.origin;
+  return "";
+}
+
+export function getToken(): string | null {
+  return localStorage.getItem(TOKEN_KEY);
+}
+
+export function resolveApiUrl(path: string): string {
+  const base = getApiBase();
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${p}`;
+}
+
+export function resolveWebSocketUrl(path: string): string {
+  const httpUrl = resolveApiUrl(path);
+  const url = new URL(httpUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return url.href;
+}
+
+/** fetch with Bearer token; relative paths resolve against {@link getApiBase}. */
+export async function apiFetch(
+  input: RequestInfo | URL,
+  init?: RequestInit,
+): Promise<Response> {
+  const token = getToken();
+  const headers = new Headers(init?.headers);
+  if (token) headers.set("Authorization", `Bearer ${token}`);
+
+  const url =
+    typeof input === "string" && input.startsWith("/")
+      ? resolveApiUrl(input)
+      : input;
+
+  const res = await fetch(url, { ...init, headers });
+  if (res.status === 401) {
+    localStorage.removeItem(TOKEN_KEY);
+    window.dispatchEvent(new CustomEvent("zhin:auth-required"));
+  }
+  return res;
+}

package/client/index.ts

@@ -37,12 +37,31 @@ export {
   CONSOLE_HOST_REACT_NAMESPACE_KEY,
 } from "@zhin.js/console-types";
 
-// Re-export console-core browser utilities
+export { configureConsole, getRuntimeEnv } from "./runtime/index.js";
+
 export {
   createRegistryStore,
   useRegistry,
   type RegistryStore,
-  configureConsole,
-  getRuntimeEnv,
-  cn,
-} from "@zhin.js/console-core/browser";
+} from "./store/createRegistryStore.js";
+
+export { cn } from "./console-utils/cn.js";
+
+export {
+  apiFetch,
+  getApiBase,
+  getToken,
+  resolveApiUrl,
+  resolveWebSocketUrl,
+} from "./console-utils/remoteApi.js";
+
+export {
+  fetchConsoleEntries,
+  createPluginRegisterHostApi,
+  getRegisterFn,
+  loadConsoleEntries,
+  registerConsolePluginsFromEntries,
+  type CreatePluginRegisterHostApiOptions,
+  type FetchConsoleEntriesOptions,
+  type LoadConsoleEntriesOptions,
+} from "./bootstrap/loadConsoleEntries.js";

package/client/persistence/idb-store.ts

@@ -0,0 +1,76 @@
+const DB_NAME = "zhin-console";
+const DB_VERSION = 1;
+const STORE_INBOX = "inbox";
+const STORE_PENDING = "pending";
+
+export type InboxRecord = {
+  id: string;
+  adapter: string;
+  botId: string;
+  kind: "message" | "request" | "notice";
+  payload: unknown;
+  updatedAt: number;
+};
+
+function openDb(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onerror = () => reject(req.error);
+    req.onsuccess = () => resolve(req.result);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE_INBOX)) {
+        db.createObjectStore(STORE_INBOX, { keyPath: "id" });
+      }
+      if (!db.objectStoreNames.contains(STORE_PENDING)) {
+        db.createObjectStore(STORE_PENDING, { keyPath: "id" });
+      }
+    };
+  });
+}
+
+export async function idbPutInbox(record: InboxRecord): Promise<void> {
+  const db = await openDb();
+  await new Promise<void>((resolve, reject) => {
+    const tx = db.transaction(STORE_INBOX, "readwrite");
+    tx.objectStore(STORE_INBOX).put(record);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+  db.close();
+}
+
+export async function idbListInbox(
+  adapter: string,
+  botId: string,
+  kind: InboxRecord["kind"],
+): Promise<InboxRecord[]> {
+  const db = await openDb();
+  const all = await new Promise<InboxRecord[]>((resolve, reject) => {
+    const tx = db.transaction(STORE_INBOX, "readonly");
+    const req = tx.objectStore(STORE_INBOX).getAll();
+    req.onsuccess = () => resolve((req.result as InboxRecord[]) ?? []);
+    req.onerror = () => reject(req.error);
+  });
+  db.close();
+  return all.filter((r) => r.adapter === adapter && r.botId === botId && r.kind === kind);
+}
+
+export async function applyConsoleEvent(event: { type: string; data?: unknown }): Promise<void> {
+  const t = event.type;
+  if (t === "bot:message" || t === "bot:request" || t === "bot:notice") {
+    const data = event.data as Record<string, unknown> | undefined;
+    if (!data) return;
+    const adapter = String(data.adapter ?? "");
+    const botId = String(data.botId ?? data.bot ?? "");
+    const id = `${adapter}:${botId}:${t}:${Date.now()}`;
+    await idbPutInbox({
+      id,
+      adapter,
+      botId,
+      kind: t === "bot:message" ? "message" : t === "bot:request" ? "request" : "notice",
+      payload: data,
+      updatedAt: Date.now(),
+    });
+  }
+}

package/client/runtime/index.ts

@@ -0,0 +1,12 @@
+import type { RuntimeEnv } from "@zhin.js/console-types";
+
+let runtimeEnvFn: (() => RuntimeEnv) | null = null;
+
+export function configureConsole(options: { getRuntimeEnv: () => RuntimeEnv }) {
+  runtimeEnvFn = options.getRuntimeEnv;
+}
+
+export function getRuntimeEnv(): RuntimeEnv {
+  if (runtimeEnvFn) return runtimeEnvFn();
+  return "production";
+}

package/client/store/createRegistryStore.ts

@@ -0,0 +1,46 @@
+import * as React from "react";
+
+export type RegistryStore<T> = {
+  add(item: T): void;
+  remove(predicate: (item: T) => boolean): void;
+  getSnapshot(): readonly T[];
+  subscribe(listener: () => void): () => void;
+};
+
+export function createRegistryStore<T>(dedupeKey?: (item: T) => string): RegistryStore<T> {
+  let items: T[] = [];
+  const listeners = new Set<() => void>();
+
+  const emit = () => {
+    for (const l of listeners) l();
+  };
+
+  return {
+    add(item) {
+      if (dedupeKey) {
+        const key = dedupeKey(item);
+        if (items.some((i) => dedupeKey(i) === key)) return;
+      }
+      items = [...items, item];
+      emit();
+    },
+    remove(predicate) {
+      const next = items.filter((i) => !predicate(i));
+      if (next.length !== items.length) {
+        items = next;
+        emit();
+      }
+    },
+    getSnapshot() {
+      return items;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}
+
+export function useRegistry<T>(store: RegistryStore<T>): readonly T[] {
+  return React.useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+}

package/client/websocket/manager.ts

@@ -10,6 +10,8 @@ import {
   MessageError,
   RequestTimeoutError,
 } from "./types";
+import { getApiBase, getStoredToken, resolveApiUrl } from "./remote-settings.js";
+import { applyConsoleEvent } from "../persistence/idb-store.js";
 
 export class WebSocketManager {
   private ws: WebSocket | null = null;
@@ -24,6 +26,8 @@ export class WebSocketManager {
     { resolve: (value: unknown) => void; reject: (error: Error) => void; timer: ReturnType<typeof setTimeout> }
   >();
   private connectedListeners = new Set<(connected: boolean) => void>();
+  private sseAbort: AbortController | null = null;
+  private useRestTransport = true;
 
   constructor(config: WebSocketConfig = {}, callbacks: WebSocketCallbacks = {}) {
     this.config = {
@@ -45,6 +49,10 @@ export class WebSocketManager {
   }
 
   connect(): void {
+    if (this.useRestTransport) {
+      void this.connectRestSse();
+      return;
+    }
     if (this.state === ConnectionState.CONNECTED || this.state === ConnectionState.CONNECTING) return;
     this.setState(ConnectionState.CONNECTING);
     try {
@@ -55,9 +63,82 @@ export class WebSocketManager {
     }
   }
 
+  private async connectRestSse(): Promise<void> {
+    const token = getStoredToken();
+    if (!token) {
+      this.setState(ConnectionState.DISCONNECTED);
+      this.notifyConnection(false);
+      return;
+    }
+    this.setState(ConnectionState.CONNECTING);
+    this.sseAbort?.abort();
+    this.sseAbort = new AbortController();
+    try {
+      const res = await fetch(resolveApiUrl("/api/events"), {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: "text/event-stream",
+        },
+        signal: this.sseAbort.signal,
+      });
+      if (!res.ok || !res.body) {
+        throw new ConnectionError(`SSE failed: HTTP ${res.status}`);
+      }
+      this.setState(ConnectionState.CONNECTED);
+      this.reconnectAttempts = 0;
+      this.notifyConnection(true);
+      this.callbacks.onConnect?.();
+      void this.pumpSse(res.body);
+    } catch (error) {
+      if ((error as Error).name === "AbortError") return;
+      this.handleConnectionError(
+        error instanceof ConnectionError ? error : new ConnectionError("SSE connect failed", error as Error),
+      );
+      this.scheduleReconnect();
+    }
+  }
+
+  private async pumpSse(body: ReadableStream<Uint8Array>): Promise<void> {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split("\n\n");
+        buffer = parts.pop() ?? "";
+        for (const part of parts) {
+          const line = part.split("\n").find((l) => l.startsWith("data: "));
+          if (!line) continue;
+          const json = line.slice(6);
+          try {
+            const message = JSON.parse(json) as WebSocketMessage;
+            void applyConsoleEvent(message);
+            this.handleBroadcast(message);
+            this.callbacks.onMessage?.(message);
+          } catch {
+            /* skip */
+          }
+        }
+      }
+    } catch {
+      /* closed */
+    } finally {
+      if (this.state === ConnectionState.CONNECTED) {
+        this.notifyConnection(false);
+        this.setState(ConnectionState.RECONNECTING);
+        this.scheduleReconnect();
+      }
+    }
+  }
+
   disconnect(): void {
     this.clearReconnectTimer();
     this.clearPendingRequests();
+    this.sseAbort?.abort();
+    this.sseAbort = null;
     if (this.ws) {
       this.ws.close();
       this.ws = null;
@@ -67,6 +148,10 @@ export class WebSocketManager {
   }
 
   send(message: unknown): void {
+    if (this.useRestTransport) {
+      void this.sendRequest(message);
+      return;
+    }
     if (!this.isConnected()) throw new WebSocketError("WebSocket is not connected", "NOT_CONNECTED");
     try {
       this.ws!.send(JSON.stringify(message));
@@ -76,6 +161,9 @@ export class WebSocketManager {
   }
 
   async sendRequest<T = unknown>(message: unknown): Promise<T> {
+    if (this.useRestTransport) {
+      return this.sendRestRequest<T>(message);
+    }
     if (!this.isConnected()) throw new WebSocketError("WebSocket is not connected", "NOT_CONNECTED");
     return new Promise((resolve, reject) => {
       const requestId = ++this.requestId;
@@ -95,7 +183,46 @@ export class WebSocketManager {
     });
   }
 
+  private async sendRestRequest<T>(message: unknown): Promise<T> {
+    const token = getStoredToken();
+    if (!token) throw new WebSocketError("Not authenticated", "NOT_CONNECTED");
+    const requestId = ++this.requestId;
+    const body = { ...(message as Record<string, unknown>), requestId };
+    const timer = setTimeout(() => {
+      /* handled below */
+    }, this.config.requestTimeout);
+    try {
+      const res = await fetch(resolveApiUrl("/api/console/request"), {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(this.config.requestTimeout),
+      });
+      clearTimeout(timer);
+      const json = (await res.json()) as {
+        success?: boolean;
+        data?: T;
+        error?: string;
+        requestId?: number;
+      };
+      if (!res.ok || json.success === false) {
+        throw new WebSocketError(json.error ?? `HTTP ${res.status}`, "SERVER_ERROR");
+      }
+      return json.data as T;
+    } catch (error) {
+      clearTimeout(timer);
+      if (error instanceof WebSocketError) throw error;
+      throw new MessageError("REST request failed", error as Error);
+    }
+  }
+
   isConnected(): boolean {
+    if (this.useRestTransport) {
+      return this.state === ConnectionState.CONNECTED;
+    }
     return this.ws?.readyState === WebSocket.OPEN;
   }
 
@@ -107,7 +234,11 @@ export class WebSocketManager {
     return this.sendRequest<unknown>({ type: "config:get", pluginName });
   }
   async setConfig(pluginName: string, config: unknown) {
-    return this.sendRequest<{ success?: boolean; reloaded?: boolean; message?: string }>({ type: "config:set", pluginName, data: config });
+    return this.sendRequest<{ success?: boolean; reloaded?: boolean; message?: string }>({
+      type: "config:set",
+      pluginName,
+      data: config,
+    });
   }
   async getSchema(pluginName: string) {
     return this.sendRequest<unknown>({ type: "schema:get", pluginName });
@@ -191,7 +322,8 @@ export class WebSocketManager {
     this.ws.onopen = () => this.handleConnectionOpen();
     this.ws.onmessage = (event) => this.handleMessage(event);
     this.ws.onclose = () => this.handleConnectionClose();
-    this.ws.onerror = (event) => this.handleConnectionError(new ConnectionError("WebSocket error", event as unknown as Error));
+    this.ws.onerror = (event) =>
+      this.handleConnectionError(new ConnectionError("WebSocket error", event as unknown as Error));
   }
 
   private handleConnectionOpen(): void {
@@ -208,6 +340,7 @@ export class WebSocketManager {
         this.handleRequestResponse(message);
         return;
       }
+      void applyConsoleEvent(message);
       this.handleBroadcast(message);
       this.callbacks.onMessage?.(message);
     } catch (error) {
@@ -260,7 +393,7 @@ export class WebSocketManager {
   private handleConnectionError(error: Error): void {
     this.clearReconnectTimer();
     this.setState(ConnectionState.ERROR);
-    console.error("[WebSocket] Connection error:", error);
+    console.error("[Console transport] Connection error:", error);
     this.callbacks.onError?.(error as unknown as Event);
   }
 

package/client/websocket/remote-settings.ts

@@ -0,0 +1,25 @@
+const API_BASE_KEY = "zhin_api_base";
+const TOKEN_KEY = "zhin_api_token";
+
+export function getApiBase(): string {
+  const stored = localStorage.getItem(API_BASE_KEY)?.trim();
+  if (stored) return stored.replace(/\/$/, "");
+  if (typeof window !== "undefined") {
+    return window.location.origin;
+  }
+  return "";
+}
+
+export function setApiBase(base: string): void {
+  localStorage.setItem(API_BASE_KEY, base.replace(/\/$/, ""));
+}
+
+export function getStoredToken(): string | null {
+  return localStorage.getItem(TOKEN_KEY);
+}
+
+export function resolveApiUrl(path: string): string {
+  const base = getApiBase();
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${p}`;
+}

package/dist/bootstrap/loadConsoleEntries.d.ts

@@ -0,0 +1,26 @@
+import type { ConsoleClientEntry, ConsoleEntriesResponse, ConsolePluginRegister, PluginRegisterHostApi } from "@zhin.js/console-types";
+export type FetchConsoleEntriesOptions = {
+    entriesUrl?: string;
+    signal?: AbortSignal;
+    fetchInit?: RequestInit | (() => RequestInit);
+};
+export type LoadConsoleEntriesOptions = FetchConsoleEntriesOptions & {
+    /** Origin for `/@dev` / `/@assets` module URLs (Remote Console: Host API base). */
+    assetOrigin?: string;
+    hostApi: PluginRegisterHostApi;
+    beforeLoad?: () => void;
+    onEmpty?: () => void;
+    onFetchError?: (status: number) => void;
+    onEntryError?: (entry: ConsoleClientEntry, error: unknown) => void;
+};
+export type CreatePluginRegisterHostApiOptions = {
+    React: PluginRegisterHostApi["React"];
+    addRoute: PluginRegisterHostApi["addRoute"];
+    addTool: PluginRegisterHostApi["addTool"];
+};
+export declare function createPluginRegisterHostApi(options: CreatePluginRegisterHostApiOptions): PluginRegisterHostApi;
+export declare function fetchConsoleEntries(options?: FetchConsoleEntriesOptions): Promise<ConsoleEntriesResponse>;
+export declare function getRegisterFn(mod: Record<string, unknown> | null | undefined): ConsolePluginRegister | null;
+export declare function registerConsolePluginsFromEntries(entries: ConsoleClientEntry[], hostApi: PluginRegisterHostApi, onEntryError?: (entry: ConsoleClientEntry, error: unknown) => void, assetOrigin?: string): Promise<void>;
+export declare function loadConsoleEntries(options: LoadConsoleEntriesOptions): Promise<void>;
+//# sourceMappingURL=loadConsoleEntries.d.ts.map

package/dist/bootstrap/loadConsoleEntries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadConsoleEntries.d.ts","sourceRoot":"","sources":["../../client/bootstrap/loadConsoleEntries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AAGhC,MAAM,MAAM,0BAA0B,GAAG;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,CAAC,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,0BAA0B,GAAG;IACnE,mFAAmF;IACnF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,qBAAqB,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpE,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,KAAK,EAAE,qBAAqB,CAAC,OAAO,CAAC,CAAC;IACtC,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAC5C,OAAO,EAAE,qBAAqB,CAAC,SAAS,CAAC,CAAC;CAC3C,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,kCAAkC,GAC1C,qBAAqB,CAQvB;AAoCD,wBAAsB,mBAAmB,CACvC,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC,sBAAsB,CAAC,CAUjC;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,qBAAqB,GAAG,IAAI,CAO3G;AAED,wBAAsB,iCAAiC,CACrD,OAAO,EAAE,kBAAkB,EAAE,EAC7B,OAAO,EAAE,qBAAqB,EAC9B,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,EAClE,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB1F"}