@socketsecurity/lib 6.0.0 → 6.0.2

package/dist/http-request/browser.d.ts

@@ -0,0 +1,190 @@
+/**
+ * @file Browser-safe HTTP request layer — mirrors the public surface of
+ *   `@socketsecurity/lib/http-request` (`httpJson`, `httpText`, `httpRequest`,
+ *   `HttpResponseError`) but uses the browser's `fetch` API instead of Node's
+ *   `node:https`. Designed for Chrome MV3 service workers, content scripts,
+ *   popups, and any other browser context that doesn't have `node:http` /
+ *   `node:https` / `node:stream`. Consumers import from
+ *   `@socketsecurity/lib/http-request/browser` directly, OR from
+ *   `@socketsecurity/lib/http-request` inside a bundler that resolves the
+ *   `browser` package.json conditional (rolldown, vite, esbuild) — the bundler
+ *   picks this entry automatically. API parity with the Node side is the goal —
+ *   same function names, same option shapes (where browsers can support them),
+ *   same error shape. Caveats:
+ *
+ *   - `HttpResponse.body` is `Uint8Array` here, vs Node's `Buffer`. Most callers
+ *     use `arrayBuffer()` / `text()` / `json()` and don't care.
+ *   - `HttpResponse.headers` is `Record<string, string>` here, vs Node's
+ *     `IncomingHttpHeaders` (which has array-valued headers like `set-cookie`).
+ *     Browser `fetch()` flattens repeated headers per spec.
+ *   - Hooks (`onRequest` / `onResponse`) are not yet supported in the browser
+ *     path. Add when needed.
+ */
+/**
+ * Browser-side HTTP error. Mirrors the Node-side `HttpResponseError` shape
+ * (same `.name`, same `.response.status/statusText` access pattern, same
+ * `instanceof` semantics) but constructs from a `BrowserHttpResponse` instead
+ * of a Node `HttpResponse`.
+ */
+export declare class HttpResponseError extends Error {
+    response: BrowserHttpResponse;
+    constructor(response: BrowserHttpResponse, message?: string | undefined);
+}
+/**
+ * Combine an external `signal` with an internal `timeout`-driven
+ * AbortController so either can cancel the in-flight fetch.
+ */
+export declare function combineSignals(external: AbortSignal | undefined, timeoutMs: number | undefined): {
+    signal: AbortSignal | undefined;
+    cleanup: () => void;
+};
+export declare function attempt(url: string, options: BrowserHttpRequestOptions): Promise<BrowserHttpResponse>;
+export declare function decodeText(bytes: Uint8Array): string;
+/**
+ * Per-attempt request info passed to `hooks.onRequest`. Mirrors the Node-side
+ * `HttpHookRequestInfo` shape so callers can share hook implementations.
+ */
+export interface BrowserHttpHookRequestInfo {
+    method: string;
+    url: string;
+    headers?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+}
+/**
+ * Per-attempt response info passed to `hooks.onResponse`. Either `status`
+ * (success) or `error` (network failure) is populated.
+ */
+export interface BrowserHttpHookResponseInfo {
+    method: string;
+    url: string;
+    duration: number;
+    status?: number | undefined;
+    statusText?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    error?: Error | undefined;
+}
+export interface BrowserHttpHooks {
+    onRequest?: ((info: BrowserHttpHookRequestInfo) => void) | undefined;
+    onResponse?: ((info: BrowserHttpHookResponseInfo) => void) | undefined;
+}
+export interface BrowserHttpRequestOptions {
+    /**
+     * Request body. Strings, Blobs, FormData, ArrayBuffer all pass through to
+     * fetch unchanged. Objects are NOT auto-stringified — the convenience wrapper
+     * `httpJson` handles JSON serialization.
+     */
+    body?: string | Blob | FormData | ArrayBuffer | Uint8Array | undefined;
+    /**
+     * Whether to follow redirects automatically. Defaults to true (browser fetch
+     * default). Setting `false` sets `redirect: 'manual'` so 3xx responses are
+     * returned to the caller instead of followed.
+     */
+    followRedirects?: boolean | undefined;
+    /**
+     * Request headers. Object form for ergonomics; passed through to fetch.
+     */
+    headers?: Record<string, string> | undefined;
+    /**
+     * Lifecycle hooks for observing request/response events. Mirrors the
+     * Node-side `hooks` field. Hooks fire per-attempt — retries trigger separate
+     * hook calls.
+     */
+    hooks?: BrowserHttpHooks | undefined;
+    /**
+     * Maximum response body size in bytes. Responses larger than this are
+     * truncated and treated as a network failure (so retries can fire). Defaults
+     * to no limit. Useful when calling untrusted endpoints.
+     */
+    maxResponseSize?: number | undefined;
+    /**
+     * HTTP method. Defaults to GET.
+     */
+    method?: string | undefined;
+    /**
+     * Number of retry attempts on 5xx / network failure. Defaults to 0 (no
+     * retries).
+     */
+    retries?: number | undefined;
+    /**
+     * Base delay (ms) between retries. Doubles per attempt (exponential).
+     * Defaults to 250ms.
+     */
+    retryDelay?: number | undefined;
+    /**
+     * Abort signal forwarded to fetch. Combined with `timeout` via
+     * AbortController when both are present.
+     */
+    signal?: AbortSignal | undefined;
+    /**
+     * Throw on non-2xx response. Defaults to false; `httpJson` / `httpText` set
+     * this to true so callers don't have to check `.ok`.
+     */
+    throwOnError?: boolean | undefined;
+    /**
+     * Per-attempt timeout in milliseconds. Implemented via AbortController;
+     * exceeds the timeout aborts the fetch and the attempt counts as a network
+     * failure (retryable). Defaults to no timeout (fetch defaults).
+     */
+    timeout?: number | undefined;
+}
+/**
+ * Browser-shaped HTTP response. Surface mirrors the Node-side `HttpResponse`
+ * but with browser-native body types.
+ */
+export interface BrowserHttpResponse {
+    /**
+     * Raw response body. `Uint8Array` instead of Node's `Buffer`.
+     */
+    body: Uint8Array;
+    /**
+     * Response headers, lowercased keys (matching Node side's lowercase
+     * convention). Repeated headers are joined with `, ` per fetch spec.
+     */
+    headers: Record<string, string>;
+    /**
+     * Convenience: true when status is 2xx.
+     */
+    ok: boolean;
+    /**
+     * HTTP status code.
+     */
+    status: number;
+    /**
+     * HTTP status text.
+     */
+    statusText: string;
+    /**
+     * Final URL after any redirects.
+     */
+    url: string;
+    /**
+     * Body as ArrayBuffer.
+     */
+    arrayBuffer(): ArrayBuffer;
+    /**
+     * Body parsed as JSON. Throws on invalid JSON.
+     */
+    json<T = unknown>(): T;
+    /**
+     * Body decoded as UTF-8 text.
+     */
+    text(): string;
+}
+export declare function headersToRecord(headers: Headers): Record<string, string>;
+/**
+ * GET / POST a JSON endpoint. Automatically sets `Accept: application/json` and
+ * `Content-Type: application/json` (when a body is present). Throws
+ * `HttpResponseError` on non-2xx.
+ */
+export declare function httpJson<T = unknown>(url: string, options?: BrowserHttpRequestOptions | undefined): Promise<T>;
+/**
+ * Lower-level HTTP request. Use `httpJson` / `httpText` for the common cases.
+ * Returns the response unconditionally — callers inspect `.ok` or pass
+ * `throwOnError: true` to get a thrown `HttpResponseError` on non-2xx.
+ */
+export declare function httpRequest(url: string, options?: BrowserHttpRequestOptions | undefined): Promise<BrowserHttpResponse>;
+/**
+ * GET / POST a text endpoint. Throws `HttpResponseError` on non-2xx.
+ */
+export declare function httpText(url: string, options?: BrowserHttpRequestOptions | undefined): Promise<string>;
+export declare function sleep(ms: number): Promise<void>;

package/dist/http-request/browser.js

@@ -0,0 +1,224 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+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 browser_exports = {};
+__export(browser_exports, {
+  HttpResponseError: () => HttpResponseError,
+  attempt: () => attempt,
+  combineSignals: () => combineSignals,
+  decodeText: () => decodeText,
+  headersToRecord: () => headersToRecord,
+  httpJson: () => httpJson,
+  httpRequest: () => httpRequest,
+  httpText: () => httpText,
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(browser_exports);
+var import_browser_fetch = require("./browser-fetch");
+class HttpResponseError extends Error {
+  response;
+  constructor(response, message) {
+    const statusCode = response.status ?? "unknown";
+    const statusMessage = response.statusText || "No status message";
+    super(message ?? `HTTP ${statusCode}: ${statusMessage}`);
+    this.name = "HttpResponseError";
+    this.response = response;
+  }
+}
+function combineSignals(external, timeoutMs) {
+  if (!timeoutMs) {
+    return { signal: external, cleanup: () => {
+    } };
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let externalListener;
+  if (external) {
+    if (external.aborted) {
+      controller.abort();
+    } else {
+      externalListener = () => controller.abort();
+      external.addEventListener("abort", externalListener);
+    }
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timer);
+      if (external && externalListener) {
+        external.removeEventListener("abort", externalListener);
+      }
+    }
+  };
+}
+async function attempt(url, options) {
+  const method = options.method ?? "GET";
+  const init = { method };
+  if (options.headers) {
+    init.headers = options.headers;
+  }
+  if (options.body !== void 0) {
+    ;
+    init.body = options.body;
+  }
+  if (options.followRedirects === false) {
+    init.redirect = "manual";
+  }
+  const { signal, cleanup } = combineSignals(options.signal, options.timeout);
+  if (signal) {
+    init.signal = signal;
+  }
+  const startedAt = Date.now();
+  if (options.hooks?.onRequest) {
+    options.hooks.onRequest({
+      method,
+      url,
+      headers: options.headers,
+      timeout: options.timeout
+    });
+  }
+  try {
+    const response = await (0, import_browser_fetch.doFetch)(url, init);
+    const buffer = await response.arrayBuffer();
+    if (options.maxResponseSize !== void 0 && buffer.byteLength > options.maxResponseSize) {
+      throw new Error(
+        `Response body (${buffer.byteLength} bytes) exceeds maxResponseSize (${options.maxResponseSize})`
+      );
+    }
+    const body = new Uint8Array(buffer);
+    const headers = headersToRecord(response.headers);
+    if (options.hooks?.onResponse) {
+      options.hooks.onResponse({
+        method,
+        url,
+        duration: Date.now() - startedAt,
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    return {
+      body,
+      headers,
+      status: response.status,
+      statusText: response.statusText,
+      ok: response.ok,
+      url: response.url,
+      arrayBuffer() {
+        return buffer;
+      },
+      text() {
+        return decodeText(body);
+      },
+      json() {
+        return JSON.parse(decodeText(body));
+      }
+    };
+  } catch (err) {
+    if (options.hooks?.onResponse) {
+      options.hooks.onResponse({
+        method,
+        url,
+        duration: Date.now() - startedAt,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+    throw err;
+  } finally {
+    cleanup();
+  }
+}
+function decodeText(bytes) {
+  return new TextDecoder("utf-8").decode(bytes);
+}
+function headersToRecord(headers) {
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key.toLowerCase()] = value;
+  });
+  return out;
+}
+async function httpJson(url, options) {
+  const opts = options ?? {};
+  const headers = {
+    Accept: "application/json",
+    ...opts.headers ?? {}
+  };
+  if (opts.body !== void 0 && !("Content-Type" in headers)) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await httpRequest(url, {
+    ...opts,
+    headers,
+    throwOnError: true
+  });
+  return response.json();
+}
+async function httpRequest(url, options) {
+  const opts = options ?? {};
+  const maxAttempts = (opts.retries ?? 0) + 1;
+  const baseDelay = opts.retryDelay ?? 250;
+  let lastError;
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const response = await attempt(url, opts);
+      if (response.status >= 500 && i + 1 < maxAttempts) {
+        await sleep(baseDelay * Math.pow(2, i));
+        continue;
+      }
+      if (opts.throwOnError && !response.ok) {
+        throw new HttpResponseError(response);
+      }
+      return response;
+    } catch (err) {
+      lastError = err;
+      if (err instanceof HttpResponseError) {
+        throw err;
+      }
+      if (i + 1 < maxAttempts) {
+        await sleep(baseDelay * Math.pow(2, i));
+        continue;
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(`HTTP request to ${url} failed`);
+}
+async function httpText(url, options) {
+  const response = await httpRequest(url, {
+    ...options ?? {},
+    throwOnError: true
+  });
+  return response.text();
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpResponseError,
+  attempt,
+  combineSignals,
+  decodeText,
+  headersToRecord,
+  httpJson,
+  httpRequest,
+  httpText,
+  sleep
+});

package/dist/http-request/download-types.d.ts

@@ -6,7 +6,7 @@
  *   - `Checksums` / `FetchChecksumsOptions` — checksum-file helpers
  */
 import type { IncomingHttpHeaders } from 'node:http';
-import type { Logger } from '../logger/logger';
+import type { Logger } from '../logger/node';
 /**
  * Configuration options for file downloads.
  */
@@ -55,7 +55,7 @@ export interface HttpDownloadOptions {
      *
      * @example
      *   ;```ts
-     *   import { getDefaultLogger } from '@socketsecurity/lib/logger/logger'
+     *   import { getDefaultLogger } from '@socketsecurity/lib/logger/node'
      *
      *   const logger = getDefaultLogger()
      *   await httpDownload('https://example.com/file.zip', '/tmp/file.zip', {

package/dist/http-request/http-request.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Public HTTP-request entry — re-exports the platform-correct
+ *   implementation. Bundlers that honor the package.json `'browser'` condition
+ *   (rolldown, vite, esbuild on browser platform) swap this entry to
+ *   `./browser`; Node consumers get `./node`. Same named exports (`httpJson`,
+ *   `httpText`, `httpRequest`, `HttpResponseError`) on both platforms so
+ *   callers can write `import { httpJson } from
+ *   '@socketsecurity/lib/http-request/http-request'` without caring about
+ *   platform.
+ */
+export { httpJson, httpRequest, httpText, HttpResponseError } from './node';
+export type { HttpResponse, HttpRequestOptions } from './node';

package/dist/http-request/http-request.js

@@ -0,0 +1,36 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+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 http_request_exports = {};
+__export(http_request_exports, {
+  HttpResponseError: () => import_node.HttpResponseError,
+  httpJson: () => import_node.httpJson,
+  httpRequest: () => import_node.httpRequest,
+  httpText: () => import_node.httpText
+});
+module.exports = __toCommonJS(http_request_exports);
+var import_node = require("./node");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpResponseError,
+  httpJson,
+  httpRequest,
+  httpText
+});

package/dist/http-request/node.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file Node-side HTTP request layer — the public surface (`httpJson`,
+ *   `httpText`, `httpRequest`, `HttpResponseError`) for consumers on Node.
+ *   Pairs with `./browser` (browser-safe variant via `fetch`); both files
+ *   expose the same named exports so the package.json `'browser'` condition can
+ *   swap them by platform without consumers changing their imports. `httpJson`
+ *   and `httpText` live here directly; `httpRequest` and the shared types are
+ *   re-exported from their dedicated leaves so the sub-imports
+ *   (`./http-request/request`, `./http-request/response-types`) stay loadable
+ *   individually for callers that don't want the convenience wrappers in their
+ *   bundle.
+ */
+import type { HttpRequestOptions } from './request-types';
+export { httpRequest } from './request';
+export { HttpResponseError } from './response-types';
+export type { HttpResponse } from './response-types';
+export type { HttpRequestOptions } from './request-types';
+/**
+ * GET / POST a JSON endpoint. Automatically sets `Accept: application/json` and
+ * `Content-Type: application/json` (when a body is present); user-supplied
+ * headers always win. Throws `HttpResponseError` on non-2xx.
+ */
+export declare function httpJson<T = unknown>(url: string, options?: HttpRequestOptions | undefined): Promise<T>;
+/**
+ * GET / POST a text endpoint. Sets `Accept: text/plain` (and `Content-Type:
+ * text/plain` on bodies); user headers override. Throws `HttpResponseError` on
+ * non-2xx.
+ */
+export declare function httpText(url: string, options?: HttpRequestOptions | undefined): Promise<string>;

package/dist/http-request/{convenience.js → node.js}

@@ -18,15 +18,19 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var convenience_exports = {};
-__export(convenience_exports, {
+var node_exports = {};
+__export(node_exports, {
+  HttpResponseError: () => import_response_types2.HttpResponseError,
   httpJson: () => httpJson,
+  httpRequest: () => import_request2.httpRequest,
   httpText: () => httpText
 });
-module.exports = __toCommonJS(convenience_exports);
+module.exports = __toCommonJS(node_exports);
 var import_error = require("../primordials/error");
 var import_request = require("./request");
 var import_response_types = require("./response-types");
+var import_request2 = require("./request");
+var import_response_types2 = require("./response-types");
 async function httpJson(url, options) {
   const {
     body,
@@ -91,6 +95,8 @@ async function httpText(url, options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  HttpResponseError,
   httpJson,
+  httpRequest,
   httpText
 });

package/dist/http-request/request-attempt.js

@@ -42,6 +42,7 @@ async function httpRequestAttempt(url, options) {
     maxRedirects = 5,
     maxResponseSize,
     method = "GET",
+    signal,
     stream = false,
     timeout = 3e4
   } = { __proto__: null, ...options };
@@ -88,6 +89,9 @@ async function httpRequestAttempt(url, options) {
     if (ca && isHttps) {
       requestOptions["ca"] = ca;
     }
+    if (signal) {
+      requestOptions["signal"] = signal;
+    }
     const emitResponse = (info) => {
       try {
         hooks?.onResponse?.({

package/dist/http-request/request-types.d.ts

@@ -206,6 +206,21 @@ export interface HttpRequestOptions {
      * @default 1000
      */
     retryDelay?: number | undefined;
+    /**
+     * AbortSignal forwarded to the underlying `http.request` / `https.request`
+     * call. Supported in Node 22+ via `node:http` request options. When both
+     * `signal` and `timeout` are provided, either can cancel the in-flight
+     * request (whichever fires first). Aborts are NOT retried — an external
+     * cancel is treated as an explicit caller decision.
+     *
+     * @example
+     *   ;```ts
+     *   const ac = new AbortController()
+     *   setTimeout(() => ac.abort(), 5000)
+     *   await httpRequest('https://api.example.com/x', { signal: ac.signal })
+     *   ```
+     */
+    signal?: AbortSignal | undefined;
     /**
      * When true, resolve with an HttpResponse whose body is NOT buffered. The
      * `rawResponse` property contains the unconsumed IncomingResponse stream for

package/dist/http-request/request.js

@@ -46,6 +46,7 @@ async function httpRequest(url, options) {
     onRetry,
     retries = 0,
     retryDelay = 1e3,
+    signal,
     stream = false,
     throwOnError = false,
     timeout = 3e4
@@ -67,6 +68,7 @@ async function httpRequest(url, options) {
     maxRedirects,
     maxResponseSize,
     method,
+    signal,
     stream,
     timeout
   };
@@ -83,6 +85,9 @@ async function httpRequest(url, options) {
       if (attempt === retries) {
         break;
       }
+      if (signal?.aborted) {
+        break;
+      }
       const delayMs = retryDelay * 2 ** attempt;
       if (onRetry) {
         const retryResult = onRetry(attempt + 1, e, delayMs);

package/dist/links/{link.d.ts → create.d.ts}

@@ -13,7 +13,7 @@ import type { LinkOptions } from './types';
  *
  * @example
  *   ;```ts
- *   import { link } from '@socketsecurity/lib/links/link'
+ *   import { link } from '@socketsecurity/lib/links/create'
  *
  *   // Use current theme
  *   console.log(link('Documentation', 'https://socket.dev'))
@@ -46,7 +46,7 @@ export declare function link(text: string, url: string, options?: LinkOptions):
  *
  * @example
  *   ;```ts
- *   import { links } from '@socketsecurity/lib/links/link'
+ *   import { links } from '@socketsecurity/lib/links/create'
  *
  *   const formatted = links([
  *     ['Documentation', 'https://socket.dev'],

package/dist/links/{link.js → create.js}

@@ -28,12 +28,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var link_exports = {};
-__export(link_exports, {
+var create_exports = {};
+__export(create_exports, {
   link: () => link,
   links: () => links
 });
-module.exports = __toCommonJS(link_exports);
+module.exports = __toCommonJS(create_exports);
 var import_yoctocolors_cjs = __toESM(require("../external/yoctocolors-cjs"));
 var import_array = require("../primordials/array");
 var import_context = require("../themes/context");

package/dist/logger/_internal.d.ts

@@ -1,5 +1,5 @@
 /**
- * @file Private state shared between the `logger/logger` class (which owns the
+ * @file Private state shared between the `logger/node` class (which owns the
  *   public `Logger` surface) and `logger/console-init` (which mutates
  *   `Logger.prototype` to mirror `globalConsole`). The `_` prefix keeps this
  *   module out of the generated package.json `exports` map (the `dist/**\/_*`

package/dist/logger/browser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file Browser-safe `Logger` implementation — mirrors the public `success` /
+ *   `fail` / `warn` / `error` / `info` / `log` surface of the Node `Logger`
+ *   (see `./node`) but backed by the global `console` so it works in Chrome MV3
+ *   service workers, content scripts, popups, and any other browser context
+ *   without `node:process` / `node:console` / fs. Consumers should import
+ *   `Logger` from `./logger` (auto-routed by the package.json `browser`
+ *   condition) or `./default` for the singleton. `./browser` is the
+ *   explicit-platform name; useful for tests pinning to one implementation.
+ */
+export declare class Logger {
+    log(message: unknown, ...args: unknown[]): this;
+    info(message: unknown, ...args: unknown[]): this;
+    warn(message: unknown, ...args: unknown[]): this;
+    error(message: unknown, ...args: unknown[]): this;
+    success(message: unknown, ...args: unknown[]): this;
+    fail(message: unknown, ...args: unknown[]): this;
+}