@aipanel/core 1.2.8 → 1.2.10

package/es/{node-logger.mjs → node/node-logger.mjs}

@@ -1,14 +1,16 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { LOG_PREFIX } from "./constants.mjs";
+import { LOG_PREFIX } from "../common/constants.mjs";
 import {
+  LEVEL_NAMES,
   LogLevel,
   getConfig,
+  getTimestamp,
   formatContext,
   formatValue,
   generateTraceId as _generateTraceId
-} from "./logger-core.mjs";
+} from "../common/logger-core.mjs";
 const COLORS = {
   reset: "\x1B[0m",
   dim: "\x1B[2m",
@@ -28,21 +30,6 @@ const LEVEL_COLORS = {
   [LogLevel.ERROR]: COLORS.red,
   [LogLevel.NONE]: COLORS.reset
 };
-const LEVEL_NAMES = {
-  [LogLevel.DEBUG]: "DEBUG",
-  [LogLevel.INFO]: "INFO",
-  [LogLevel.WARN]: "WARN",
-  [LogLevel.ERROR]: "ERROR",
-  [LogLevel.NONE]: "NONE"
-};
-function getTimestamp() {
-  const now = /* @__PURE__ */ new Date();
-  const hours = String(now.getHours()).padStart(2, "0");
-  const minutes = String(now.getMinutes()).padStart(2, "0");
-  const seconds = String(now.getSeconds()).padStart(2, "0");
-  const ms = String(now.getMilliseconds()).padStart(3, "0");
-  return `${hours}:${minutes}:${seconds}.${ms}`;
-}
 function getCallerInfo(depth = 3) {
   const stack = new Error().stack;
   if (!stack) return "";

package/es/node/node-utils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview Node.js 专用工具函数（仅服务端可用）
+ */
+/**
+ * 创建一个锚定到指定目录（默认 process.cwd()）的 require。
+ * 跨 ESM/CJS 安全，避免依赖 __dirname / import.meta.url（CJS 打包时会与 Node 内置变量冲突或被置空）。
+ */
+export declare function createPackageRequire(baseDir?: string): NodeJS.Require;
+/**
+ * 解析 npm 包根目录（跨 ESM/CJS 安全）。
+ * @param packageName - 包名，例如 "vite-plugin-aipanel"
+ * @param baseDir - 解析基准目录，默认当前工作目录
+ */
+export declare function resolvePackageDir(packageName: string, baseDir?: string): string;
+/**
+ * 检查 Chrome DevTools 是否可用
+ * @param timeout - 超时时间（毫秒），默认 2000ms
+ * @returns Chrome DevTools 是否可用
+ */
+export declare function checkChromeDevToolsAvailable(port?: number, timeout?: number): Promise<boolean>;
+/**
+ * 检查指定端口是否可用
+ */
+export declare function isPortAvailable(port: number, hostname?: string): Promise<boolean>;
+/**
+ * 从 startPort 开始寻找可用端口
+ */
+export declare function findAvailablePort(startPort: number, hostname?: string, maxTries?: number): Promise<number>;
+/**
+ * 可等待的进程接口（ResultPromise 等匹配就够）
+ */
+export interface WaitableProcess {
+    exitCode: number | null | undefined;
+}
+/**
+ * 轮询等待服务准备就绪（HTTP 状态码 < 500 即当作 ready）；超时或进程退出时 reject
+ * @param url - 检查的服务 URL
+ * @param timeout - 超时毫秒数
+ * @param proc - 可选进程，提前退出时直接失败
+ */
+export declare function waitForServer(url: string, timeout?: number, proc?: WaitableProcess): Promise<void>;
+/**
+ * 从指定目录往上查找 .git 根目录（找不到时返回起始目录）
+ */
+export declare function findGitRoot(startDir: string, maxDepth?: number): string;
+/**
+ * 检查某 CLI 是否安装（运行 <bin> --version，退出码 0 即存在）
+ */
+export declare function checkCliInstalled(bin: string): Promise<boolean>;
+/**
+ * 获取某 CLI 版本号（<bin> --version 的第一行，败路返回 null）
+ */
+export declare function getCliVersion(bin: string): Promise<string | null>;
+/** 孤儿进程清理配置（提供商的 check/kill 统一实现） */
+export interface KillOrphanCliOptions {
+    /** 进程命令行/参数中需匹配的子串（如 opencode / dsh） */
+    match: string;
+    /** Windows wmic 按名称查询的进程名（如 opencode.exe / node.exe） */
+    winName: string;
+    /** 超时毫秒（默认 5000） */
+    timeout?: number;
+    /** 运行名（仅用于日志，默认等于 match） */
+    label?: string;
+}
+/**
+ * 清理被 reparent 到 init（PPID=1）的孤儿进程（win: wmic+taskkill；unix: ps+kill）
+ * @returns 被成功结束的进程数
+ */
+export declare function killOrphanCliProcesses(bin: string, options: KillOrphanCliOptions): Promise<number>;

package/es/node/node-utils.mjs

@@ -0,0 +1,291 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import {
+  CHROME_DEVTOOLS_PORT,
+  CHROME_DEVTOOLS_CHECK_TIMEOUT,
+  SERVER_CHECK_INTERVAL
+} from "../common/constants.mjs";
+import { PerformanceTimer, createLogger } from "./node-logger.mjs";
+const log = createLogger("NodeUtils");
+function createPackageRequire(baseDir = process.cwd()) {
+  return createRequire(path.join(baseDir, "package.json"));
+}
+function resolvePackageDir(packageName, baseDir = process.cwd()) {
+  const require2 = createPackageRequire(baseDir);
+  const entryPath = require2.resolve(packageName);
+  return path.dirname(path.dirname(entryPath));
+}
+async function checkChromeDevToolsAvailable(port = CHROME_DEVTOOLS_PORT, timeout = CHROME_DEVTOOLS_CHECK_TIMEOUT) {
+  const net = await import("net");
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, timeout);
+    socket.connect(port, "localhost", () => {
+      clearTimeout(timer);
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+async function isPortAvailable(port, hostname) {
+  const net = await import("net");
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port, hostname);
+  });
+}
+async function findAvailablePort(startPort, hostname, maxTries = 100) {
+  for (let port = startPort; port < startPort + maxTries; port++) {
+    if (await isPortAvailable(port, hostname)) return port;
+  }
+  throw new Error(`No available port in range ${startPort}-${startPort + maxTries}`);
+}
+function waitForServer(url, timeout = 1e4, proc) {
+  const timer = new PerformanceTimer("waitForServer", { url, timeout });
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    let attempts = 0;
+    const check = () => {
+      attempts++;
+      log.debug(`Checking server availability (attempt ${attempts})`, { url });
+      if (proc?.exitCode !== null && proc?.exitCode !== void 0) {
+        timer.end(`\u2716 Process exited with code ${proc.exitCode}`);
+        reject(new Error(`Process exited with code ${proc.exitCode}`));
+        return;
+      }
+      const req = http.get(url, (res) => {
+        if (res.statusCode && res.statusCode < 500) {
+          timer.end(`\u2713 Server ready after ${attempts} attempts`);
+          resolve();
+        } else {
+          log.debug(`Server returned status ${res.statusCode}, retrying...`);
+          retryOrReject();
+        }
+      });
+      req.on("error", (err) => {
+        log.debug(`Server check failed: ${err.message}`);
+        retryOrReject();
+      });
+    };
+    const retryOrReject = () => {
+      const elapsed = Date.now() - startTime;
+      if (elapsed < timeout) {
+        setTimeout(check, SERVER_CHECK_INTERVAL);
+      } else {
+        timer.end("\u2716 Timeout");
+        reject(new Error(`Server not ready after ${timeout}ms (${attempts} attempts)`));
+      }
+    };
+    check();
+  });
+}
+function findGitRoot(startDir, maxDepth = 10) {
+  const timer = new PerformanceTimer("findGitRoot", { startDir, maxDepth });
+  let currentDir = startDir;
+  let depth = 0;
+  while (depth < maxDepth) {
+    const gitDir = path.join(currentDir, ".git");
+    try {
+      if (fs.existsSync(gitDir)) {
+        timer.end(`\u2713 Found git root at depth ${depth}: ${currentDir}`);
+        return currentDir;
+      }
+    } catch (err) {
+      log.debug(`Error checking .git directory at ${currentDir}`, {
+        error: err.message
+      });
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      log.debug("Reached filesystem root");
+      break;
+    }
+    currentDir = parentDir;
+    depth++;
+  }
+  timer.end(`\u2716 No git root found after ${depth} levels, using start directory`);
+  return startDir;
+}
+async function checkCliInstalled(bin) {
+  const timer = new PerformanceTimer(`checkCliInstalled:${bin}`);
+  return new Promise((resolve) => {
+    const proc = spawn(bin, ["--version"], { stdio: "ignore", shell: true });
+    proc.on("close", (code) => {
+      const installed = code === 0;
+      timer.end(installed ? `\u2713 ${bin} is installed` : `\u2716 ${bin} not found`);
+      resolve(installed);
+    });
+    proc.on("error", (err) => {
+      log.debug(`Failed to check ${bin} installation`, { error: err.message });
+      timer.end("\u2716 Check failed");
+      resolve(false);
+    });
+  });
+}
+function getCliVersion(bin) {
+  return new Promise((resolve) => {
+    const proc = spawn(bin, ["--version"], { stdio: "pipe", shell: true });
+    let output = "";
+    proc.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve(code === 0 && output.trim() ? output.trim() : null);
+    });
+    proc.on("error", () => resolve(null));
+  });
+}
+function killOrphanCliProcesses(bin, options) {
+  const label = options.label ?? bin;
+  const timeoutMs = options.timeout ?? 5e3;
+  const timer = new PerformanceTimer(`killOrphanCliProcesses:${label}`);
+  log.debug(`Looking for orphan ${label} processes (PPID=1)`);
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (count) => {
+      if (!settled) {
+        settled = true;
+        resolve(count);
+      }
+    };
+    const timeout = setTimeout(() => {
+      log.warn(`Kill orphan ${label} processes timed out, skipping`);
+      timer.end("\u26A0 Timeout, skipped");
+      done(0);
+    }, timeoutMs);
+    const wrappedResolve = (count) => {
+      clearTimeout(timeout);
+      done(count);
+    };
+    if (process.platform === "win32") {
+      killOrphansOnWindows(wrappedResolve, options, label, timer);
+    } else {
+      killOrphansOnUnix(wrappedResolve, options, label, timer);
+    }
+  });
+}
+function killOrphansOnWindows(resolve, options, label, timer) {
+  log.debug(`Using Windows method to find orphan ${label} processes`);
+  const proc = spawn(
+    "wmic",
+    ["process", "where", `name="${options.winName}"`, "get", "processid,parentprocessid,commandline"],
+    { stdio: "pipe" }
+  );
+  let output = "";
+  proc.stdout?.on("data", (data) => {
+    output += data.toString();
+  });
+  proc.on("close", () => {
+    const pidsToKill = [];
+    output.split("\n").forEach((rawLine) => {
+      const line = rawLine.trim();
+      if (!line.includes(options.match)) return;
+      const parts = line.split(/\s+/);
+      if (parts.length >= 3) {
+        const ppid = parts[0];
+        const pid = parts[1];
+        if (ppid === "1" && pid && !Number.isNaN(Number(pid))) pidsToKill.push(pid);
+      }
+    });
+    finishOrphanKillWindows(pidsToKill, resolve, label, timer);
+  });
+  proc.on("error", (err) => {
+    log.debug(`Failed to find orphan ${label} processes`, { error: err.message });
+    timer.end("\u2716 Failed to find orphan processes");
+    resolve(0);
+  });
+}
+function finishOrphanKillWindows(pidsToKill, resolve, label, timer) {
+  if (pidsToKill.length === 0) {
+    log.debug("No orphan processes found");
+    timer.end("No orphan processes found");
+    resolve(0);
+    return;
+  }
+  log.debug(`Found ${pidsToKill.length} orphan processes`, { pids: pidsToKill });
+  let killedCount = 0;
+  let completedCount = 0;
+  pidsToKill.forEach((pid) => {
+    const killProc = spawn("taskkill", ["/F", "/PID", pid], { stdio: "ignore" });
+    killProc.on("close", (code) => {
+      completedCount++;
+      if (code === 0) killedCount++;
+      if (completedCount === pidsToKill.length) {
+        timer.end(`\u2713 Killed ${killedCount} orphan ${label} processes`);
+        resolve(killedCount);
+      }
+    });
+  });
+}
+function killOrphansOnUnix(resolve, options, label, timer) {
+  log.debug(`Using Unix method to find orphan ${label} processes`);
+  const proc = spawn("ps", ["-e", "-o", "pid,ppid,args"], { stdio: "pipe" });
+  let output = "";
+  proc.stdout?.on("data", (data) => {
+    output += data.toString();
+  });
+  proc.on("close", () => {
+    const pidsToKill = [];
+    output.split("\n").forEach((line) => {
+      if (!line.includes(options.match)) return;
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 3) {
+        const pid = parts[0];
+        const ppid = parts[1];
+        if (ppid === "1" && pid && !Number.isNaN(Number(pid))) pidsToKill.push(pid);
+      }
+    });
+    if (pidsToKill.length === 0) {
+      log.debug("No orphan processes found");
+      timer.end("No orphan processes found");
+      resolve(0);
+      return;
+    }
+    log.debug(`Found ${pidsToKill.length} orphan processes`, { pids: pidsToKill });
+    const killProc = spawn("kill", ["-9", ...pidsToKill], { stdio: "ignore" });
+    killProc.on("close", (code) => {
+      const killedCount = code === 0 ? pidsToKill.length : 0;
+      timer.end(
+        killedCount > 0 ? `\u2713 Killed ${killedCount} orphan ${label} processes` : "\u2716 Failed to kill processes"
+      );
+      resolve(killedCount);
+    });
+    killProc.on("error", () => {
+      timer.end("\u2716 Failed to kill processes");
+      resolve(0);
+    });
+  });
+  proc.on("error", (err) => {
+    log.debug(`Failed to find orphan ${label} processes`, { error: err.message });
+    timer.end("\u2716 Failed to find orphan processes");
+    resolve(0);
+  });
+}
+export {
+  checkChromeDevToolsAvailable,
+  checkCliInstalled,
+  createPackageRequire,
+  findAvailablePort,
+  findGitRoot,
+  getCliVersion,
+  isPortAvailable,
+  killOrphanCliProcesses,
+  resolvePackageDir,
+  waitForServer
+};

package/es/node.d.ts

@@ -1,7 +1,7 @@
-export * from "./constants";
-export * from "./logger-core";
-export * from "./node-logger";
-export * from "./process-logger";
-export * from "./file-log-watcher";
-export * from "./node-utils";
+export * from "./common/constants";
+export * from "./common/logger-core";
+export * from "./node/node-logger";
+export * from "./node/process-logger";
+export * from "./node/file-log-watcher";
+export * from "./node/node-utils";
 export * from "./node/diagnostics";

package/es/node.mjs

@@ -1,7 +1,7 @@
-export * from "./constants.mjs";
-export * from "./logger-core.mjs";
-export * from "./node-logger.mjs";
-export * from "./process-logger.mjs";
-export * from "./file-log-watcher.mjs";
-export * from "./node-utils.mjs";
+export * from "./common/constants.mjs";
+export * from "./common/logger-core.mjs";
+export * from "./node/node-logger.mjs";
+export * from "./node/process-logger.mjs";
+export * from "./node/file-log-watcher.mjs";
+export * from "./node/node-utils.mjs";
 export * from "./node/diagnostics.mjs";

package/lib/{logger.cjs → client/logger.cjs}

@@ -21,15 +21,8 @@ __export(logger_exports, {
   logger: () => logger
 });
 module.exports = __toCommonJS(logger_exports);
-var import_constants = require("./constants.cjs");
-var import_logger_core = require("./logger-core.cjs");
-const LEVEL_NAMES = {
-  [import_logger_core.LogLevel.DEBUG]: "DEBUG",
-  [import_logger_core.LogLevel.INFO]: "INFO ",
-  [import_logger_core.LogLevel.WARN]: "WARN ",
-  [import_logger_core.LogLevel.ERROR]: "ERROR",
-  [import_logger_core.LogLevel.NONE]: "NONE "
-};
+var import_constants = require("../common/constants.cjs");
+var import_logger_core = require("../common/logger-core.cjs");
 const C = {
   dim: "color: #888",
   bright: "font-weight: bold",
@@ -56,7 +49,7 @@ function log(level, message, context, ...args) {
     segments.push("%c%s");
     styles.push(C.dim, (0, import_logger_core.getTimestamp)());
   }
-  segments.push(`%c${LEVEL_NAMES[level]}`);
+  segments.push(`%c${import_logger_core.LEVEL_NAMES[level].padEnd(5)}`);
   styles.push(LEVEL_COLORS[level]);
   segments.push(`%c${import_constants.LOG_PREFIX}`);
   styles.push(C.bright);

package/lib/{logger.d.ts → client/logger.d.ts}

@@ -1,4 +1,4 @@
-import { type LogContext } from "./logger-core";
+import { type LogContext } from "../common/logger-core";
 export declare const logger: {
     debug(message: string, context?: LogContext, ...args: unknown[]): void;
     info(message: string, context?: LogContext, ...args: unknown[]): void;

package/lib/client/storage.cjs

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var storage_exports = {};
+__export(storage_exports, {
+  storageGet: () => storageGet,
+  storageRemove: () => storageRemove,
+  storageSet: () => storageSet
+});
+module.exports = __toCommonJS(storage_exports);
+function storageArea(area) {
+  try {
+    if (typeof window === "undefined") return void 0;
+    return area === "local" ? window.localStorage : window.sessionStorage;
+  } catch {
+    return void 0;
+  }
+}
+function storageGet(area, key) {
+  try {
+    const raw = storageArea(area)?.getItem(key);
+    return raw == null ? null : JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function storageSet(area, key, value) {
+  try {
+    storageArea(area)?.setItem(key, JSON.stringify(value));
+  } catch {
+  }
+}
+function storageRemove(area, key) {
+  try {
+    storageArea(area)?.removeItem(key);
+  } catch {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  storageGet,
+  storageRemove,
+  storageSet
+});

package/lib/client/storage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 浏览器存储辅助（window.localStorage/sessionStorage，仅 client 端；通过 @aipanel/core/client 导出）
+ */
+/**
+ * 安全读取浏览器存储（JSON 解码；不可用/异常返回 null）
+ */
+export declare function storageGet<T>(area: "local" | "session", key: string): T | null;
+/**
+ * 安全写入浏览器存储（JSON 序列化；异常忽略）
+ */
+export declare function storageSet(area: "local" | "session", key: string, value: unknown): void;
+/**
+ * 安全删除浏览器存储项
+ */
+export declare function storageRemove(area: "local" | "session", key: string): void;

package/lib/client/theme.cjs

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var theme_exports = {};
+__export(theme_exports, {
+  getSystemTheme: () => getSystemTheme,
+  resolveWidgetTheme: () => resolveWidgetTheme
+});
+module.exports = __toCommonJS(theme_exports);
+function getSystemTheme() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return "light";
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function resolveWidgetTheme(theme, system = getSystemTheme()) {
+  return theme === "auto" ? system : theme;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSystemTheme,
+  resolveWidgetTheme
+});

package/lib/client/theme.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 浏览器主题辅助（依赖 window.matchMedia，仅 client 端使用；通过 @aipanel/core/client 导出）
+ */
+import type { AIPanelWidgetTheme } from "../common/types";
+/**
+ * 当前系统主题（仅浏览器有效；SSR/无 window 环境返回 light）
+ */
+export declare function getSystemTheme(): "light" | "dark";
+/**
+ * 挂件主题偏好解析：auto 按系统主题折算为 light/dark
+ * @param theme - 挂件主题偏好（AIPanelWidgetTheme）
+ * @param system - 系统主题（默认当前系统）
+ * @returns 实际应用主题
+ */
+export declare function resolveWidgetTheme(theme: AIPanelWidgetTheme, system?: "light" | "dark"): "light" | "dark";

package/lib/client.cjs

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+module.exports = __toCommonJS(client_exports);
+__reExport(client_exports, require("./client/logger.cjs"), module.exports);
+__reExport(client_exports, require("./client/storage.cjs"), module.exports);
+__reExport(client_exports, require("./client/theme.cjs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./client/logger.cjs"),
+  ...require("./client/storage.cjs"),
+  ...require("./client/theme.cjs")
+});

package/lib/client.d.ts

@@ -0,0 +1,3 @@
+export * from "./client/logger";
+export * from "./client/storage";
+export * from "./client/theme";