@richardmcquiston01/error-log-adapter 0.5.0 → 0.7.0

package/dist/index.d.cts

@@ -89,17 +89,50 @@ interface WebhookErrorOptions {
      * still have received the entry.
      */
     timeoutMs?: number;
+    /**
+     * How many times to try again after a failure that may go away on its own: a
+     * network error, a timeout, HTTP 408, 425, 429 or any 5xx. Other 4xx answers and
+     * redirects are never retried. Defaults to 0 (send once). The wait doubles
+     * after each attempt, starting at `retryDelayMs`, with jitter, and a
+     * `Retry-After` header is honored. `timeoutMs` applies to each attempt, and
+     * `log()` resolves only after the last one. Every attempt sends the same body,
+     * and with `retries` above 0 the body always carries an `id`, so the receiver
+     * can drop a repeat if an earlier attempt did arrive.
+     */
+    retries?: number;
+    /** Wait before the first retry, in milliseconds. Defaults to 500. */
+    retryDelayMs?: number;
+    /** Longest wait between attempts, in milliseconds. Defaults to 30000. */
+    maxRetryDelayMs?: number;
+    /**
+     * Shared secret for signing each request, so the receiver can verify the
+     * entry came from you and was not altered. Adds `X-Signature-Timestamp`
+     * (Unix seconds) and `X-Signature-256` (`sha256=` and the hex HMAC-SHA256 of
+     * `<timestamp>.<body>`). The receiver should recompute it and reject old
+     * timestamps. Needs Web Crypto (Node 20+, browsers, Deno, Bun); without it
+     * `log()` fails rather than sending an unsigned entry.
+     */
+    signingSecret?: string;
 }
 declare class WebhookErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
     private readonly url;
     private readonly options;
     private readonly prefix;
     private readonly timeoutMs;
+    private readonly retries;
+    private readonly retryDelayMs;
+    private readonly maxRetryDelayMs;
     /** Scheme and host only. Webhook URLs often carry a secret in the path or query. */
     private readonly target;
-    /** @throws {RangeError} if `url` is not a valid `https://` URL (see `allowInsecure`) or `timeoutMs` is invalid. */
+    /** @throws {RangeError} if `url` is not a valid `https://` URL (see `allowInsecure`) or a timeout, retry or signing option is invalid. */
     constructor(url: string, options?: WebhookErrorOptions);
     log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+    /** Milliseconds to wait before retry number `retryNumber` (1 for the first). */
+    private retryWaitMs;
+    private send;
+    /** Timestamp and signature headers, or none when no `signingSecret` is set. */
+    private signatureHeaders;
+    private rejected;
     private redirectMessage;
     /** Replaces the full URL in a message with its origin, in case the runtime put it there. */
     private redact;
@@ -929,4 +962,101 @@ declare class SupabaseErrorAdapter<TCode extends string = string> implements Err
     private fail;
 }
 
-export { type CollectionLike, CompositeErrorAdapter, type CompositeErrorOptions, ConsoleErrorAdapter, type ConsoleErrorOptions, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbRequestLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, type LockManagerLike, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, type RedisClientLike, RedisErrorAdapter, type RedisErrorOptions, type S3BatchOptions, type S3ClientLike, S3ErrorAdapter, type S3ErrorOptions, type S3PutObjectInput, type SerializedErrorLogEntry, type SqlClientLike, type SqlDialect, type SqlErrorOptions, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildMySqlWidenColumnsSql, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };
+/** What listeners receive: the serialized entry plus its UUID. */
+interface EventEmitterErrorRecord extends SerializedErrorLogEntry {
+    id: string;
+}
+/**
+ * The only thing this adapter needs from an emitter: `emit(eventName, payload)`.
+ * Node's `EventEmitter` and mitt-style emitters fit as they are. A browser
+ * `EventTarget` needs a one-line wrapper:
+ *
+ * ```ts
+ * const target = new EventTarget();
+ * const emitter: EmitterLike = {
+ *   emit: (name, payload) =>
+ *     target.dispatchEvent(new CustomEvent(name, { detail: payload })),
+ * };
+ * ```
+ */
+interface EmitterLike {
+    emit(eventName: string, payload: EventEmitterErrorRecord): unknown;
+}
+interface EventEmitterErrorOptions {
+    /**
+     * Name of the event to emit. Defaults to `error-log`. Avoid `error` on a Node
+     * `EventEmitter`: it throws when no listener is attached, and `log` would then
+     * return `ok: false`.
+     */
+    eventName?: string;
+    /**
+     * Treat an emit that reached nobody as a failure. Node's `EventEmitter.emit`
+     * returns `false` when there are no listeners; with this set to `true`, `log`
+     * then returns `ok: false` instead of letting the entry vanish. Emitters whose
+     * `emit` returns anything else (mitt, an `EventTarget` wrapper) cannot tell,
+     * so they always count as delivered. Defaults to `false`.
+     */
+    requireListener?: boolean;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Emits each entry as an event on an emitter you own, for in-process hooks such
+ * as a toast, a metrics counter, or a test assertion. Listeners run
+ * synchronously inside `emit`, so a listener that throws makes `log` return
+ * `ok: false` with the listener's message; the application is not affected.
+ *
+ * ```ts
+ * const bus = new EventEmitter();
+ * bus.on('error-log', (record) => showToast(record.message));
+ * const adapter = new EventEmitterErrorAdapter(bus);
+ * ```
+ */
+declare class EventEmitterErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly emitter;
+    private readonly eventName;
+    private readonly requireListener;
+    private readonly prefix;
+    /** @throws {RangeError} if `options.eventName` is empty. */
+    constructor(emitter: EmitterLike, options?: EventEmitterErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+
+/**
+ * The only things this adapter needs from a socket: `send` and `readyState`. The
+ * browser `WebSocket`, Node's global `WebSocket`, Deno, Bun, and the `ws` package
+ * all fit as they are.
+ */
+interface WebSocketLike {
+    send(data: string): unknown;
+    readonly readyState: number;
+}
+interface WebSocketErrorOptions {
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Sends each entry as one JSON text message (the serialized entry plus its UUID
+ * `id`) over a socket you own. You connect, and reconnect, the socket; this
+ * adapter never opens one and keeps no buffer. If the socket is not open when
+ * `log` is called, the entry is not sent and `log` returns `ok: false`, so
+ * combine it with a durable adapter in a `CompositeErrorAdapter` when entries
+ * must not be lost while the socket is down.
+ *
+ * `ok: true` means the socket accepted the message, not that the server
+ * received it: a WebSocket gives no acknowledgement, and a connection that
+ * drops after `send` loses the message.
+ *
+ * ```ts
+ * const socket = new WebSocket('wss://logs.example.com/errors');
+ * const adapter = new WebSocketErrorAdapter(socket);
+ * ```
+ */
+declare class WebSocketErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly socket;
+    private readonly prefix;
+    constructor(socket: WebSocketLike, options?: WebSocketErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+
+export { type CollectionLike, CompositeErrorAdapter, type CompositeErrorOptions, ConsoleErrorAdapter, type ConsoleErrorOptions, type EmitterLike, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, EventEmitterErrorAdapter, type EventEmitterErrorOptions, type EventEmitterErrorRecord, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbRequestLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, type LockManagerLike, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, type RedisClientLike, RedisErrorAdapter, type RedisErrorOptions, type S3BatchOptions, type S3ClientLike, S3ErrorAdapter, type S3ErrorOptions, type S3PutObjectInput, type SerializedErrorLogEntry, type SqlClientLike, type SqlDialect, type SqlErrorOptions, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebSocketErrorAdapter, type WebSocketErrorOptions, type WebSocketLike, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildMySqlWidenColumnsSql, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };

package/dist/index.d.ts

@@ -89,17 +89,50 @@ interface WebhookErrorOptions {
      * still have received the entry.
      */
     timeoutMs?: number;
+    /**
+     * How many times to try again after a failure that may go away on its own: a
+     * network error, a timeout, HTTP 408, 425, 429 or any 5xx. Other 4xx answers and
+     * redirects are never retried. Defaults to 0 (send once). The wait doubles
+     * after each attempt, starting at `retryDelayMs`, with jitter, and a
+     * `Retry-After` header is honored. `timeoutMs` applies to each attempt, and
+     * `log()` resolves only after the last one. Every attempt sends the same body,
+     * and with `retries` above 0 the body always carries an `id`, so the receiver
+     * can drop a repeat if an earlier attempt did arrive.
+     */
+    retries?: number;
+    /** Wait before the first retry, in milliseconds. Defaults to 500. */
+    retryDelayMs?: number;
+    /** Longest wait between attempts, in milliseconds. Defaults to 30000. */
+    maxRetryDelayMs?: number;
+    /**
+     * Shared secret for signing each request, so the receiver can verify the
+     * entry came from you and was not altered. Adds `X-Signature-Timestamp`
+     * (Unix seconds) and `X-Signature-256` (`sha256=` and the hex HMAC-SHA256 of
+     * `<timestamp>.<body>`). The receiver should recompute it and reject old
+     * timestamps. Needs Web Crypto (Node 20+, browsers, Deno, Bun); without it
+     * `log()` fails rather than sending an unsigned entry.
+     */
+    signingSecret?: string;
 }
 declare class WebhookErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
     private readonly url;
     private readonly options;
     private readonly prefix;
     private readonly timeoutMs;
+    private readonly retries;
+    private readonly retryDelayMs;
+    private readonly maxRetryDelayMs;
     /** Scheme and host only. Webhook URLs often carry a secret in the path or query. */
     private readonly target;
-    /** @throws {RangeError} if `url` is not a valid `https://` URL (see `allowInsecure`) or `timeoutMs` is invalid. */
+    /** @throws {RangeError} if `url` is not a valid `https://` URL (see `allowInsecure`) or a timeout, retry or signing option is invalid. */
     constructor(url: string, options?: WebhookErrorOptions);
     log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+    /** Milliseconds to wait before retry number `retryNumber` (1 for the first). */
+    private retryWaitMs;
+    private send;
+    /** Timestamp and signature headers, or none when no `signingSecret` is set. */
+    private signatureHeaders;
+    private rejected;
     private redirectMessage;
     /** Replaces the full URL in a message with its origin, in case the runtime put it there. */
     private redact;
@@ -929,4 +962,101 @@ declare class SupabaseErrorAdapter<TCode extends string = string> implements Err
     private fail;
 }
 
-export { type CollectionLike, CompositeErrorAdapter, type CompositeErrorOptions, ConsoleErrorAdapter, type ConsoleErrorOptions, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbRequestLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, type LockManagerLike, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, type RedisClientLike, RedisErrorAdapter, type RedisErrorOptions, type S3BatchOptions, type S3ClientLike, S3ErrorAdapter, type S3ErrorOptions, type S3PutObjectInput, type SerializedErrorLogEntry, type SqlClientLike, type SqlDialect, type SqlErrorOptions, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildMySqlWidenColumnsSql, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };
+/** What listeners receive: the serialized entry plus its UUID. */
+interface EventEmitterErrorRecord extends SerializedErrorLogEntry {
+    id: string;
+}
+/**
+ * The only thing this adapter needs from an emitter: `emit(eventName, payload)`.
+ * Node's `EventEmitter` and mitt-style emitters fit as they are. A browser
+ * `EventTarget` needs a one-line wrapper:
+ *
+ * ```ts
+ * const target = new EventTarget();
+ * const emitter: EmitterLike = {
+ *   emit: (name, payload) =>
+ *     target.dispatchEvent(new CustomEvent(name, { detail: payload })),
+ * };
+ * ```
+ */
+interface EmitterLike {
+    emit(eventName: string, payload: EventEmitterErrorRecord): unknown;
+}
+interface EventEmitterErrorOptions {
+    /**
+     * Name of the event to emit. Defaults to `error-log`. Avoid `error` on a Node
+     * `EventEmitter`: it throws when no listener is attached, and `log` would then
+     * return `ok: false`.
+     */
+    eventName?: string;
+    /**
+     * Treat an emit that reached nobody as a failure. Node's `EventEmitter.emit`
+     * returns `false` when there are no listeners; with this set to `true`, `log`
+     * then returns `ok: false` instead of letting the entry vanish. Emitters whose
+     * `emit` returns anything else (mitt, an `EventTarget` wrapper) cannot tell,
+     * so they always count as delivered. Defaults to `false`.
+     */
+    requireListener?: boolean;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Emits each entry as an event on an emitter you own, for in-process hooks such
+ * as a toast, a metrics counter, or a test assertion. Listeners run
+ * synchronously inside `emit`, so a listener that throws makes `log` return
+ * `ok: false` with the listener's message; the application is not affected.
+ *
+ * ```ts
+ * const bus = new EventEmitter();
+ * bus.on('error-log', (record) => showToast(record.message));
+ * const adapter = new EventEmitterErrorAdapter(bus);
+ * ```
+ */
+declare class EventEmitterErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly emitter;
+    private readonly eventName;
+    private readonly requireListener;
+    private readonly prefix;
+    /** @throws {RangeError} if `options.eventName` is empty. */
+    constructor(emitter: EmitterLike, options?: EventEmitterErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+
+/**
+ * The only things this adapter needs from a socket: `send` and `readyState`. The
+ * browser `WebSocket`, Node's global `WebSocket`, Deno, Bun, and the `ws` package
+ * all fit as they are.
+ */
+interface WebSocketLike {
+    send(data: string): unknown;
+    readonly readyState: number;
+}
+interface WebSocketErrorOptions {
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Sends each entry as one JSON text message (the serialized entry plus its UUID
+ * `id`) over a socket you own. You connect, and reconnect, the socket; this
+ * adapter never opens one and keeps no buffer. If the socket is not open when
+ * `log` is called, the entry is not sent and `log` returns `ok: false`, so
+ * combine it with a durable adapter in a `CompositeErrorAdapter` when entries
+ * must not be lost while the socket is down.
+ *
+ * `ok: true` means the socket accepted the message, not that the server
+ * received it: a WebSocket gives no acknowledgement, and a connection that
+ * drops after `send` loses the message.
+ *
+ * ```ts
+ * const socket = new WebSocket('wss://logs.example.com/errors');
+ * const adapter = new WebSocketErrorAdapter(socket);
+ * ```
+ */
+declare class WebSocketErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly socket;
+    private readonly prefix;
+    constructor(socket: WebSocketLike, options?: WebSocketErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+
+export { type CollectionLike, CompositeErrorAdapter, type CompositeErrorOptions, ConsoleErrorAdapter, type ConsoleErrorOptions, type EmitterLike, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, EventEmitterErrorAdapter, type EventEmitterErrorOptions, type EventEmitterErrorRecord, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbRequestLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, type LockManagerLike, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, type RedisClientLike, RedisErrorAdapter, type RedisErrorOptions, type S3BatchOptions, type S3ClientLike, S3ErrorAdapter, type S3ErrorOptions, type S3PutObjectInput, type SerializedErrorLogEntry, type SqlClientLike, type SqlDialect, type SqlErrorOptions, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebSocketErrorAdapter, type WebSocketErrorOptions, type WebSocketLike, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildMySqlWidenColumnsSql, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };

package/dist/index.mjs

@@ -229,6 +229,78 @@ function withTimeout(start, timeoutMs, message) {
 }
 
 // src/adapters/webhook-error-adapter.ts
+var DEFAULT_RETRY_DELAY_MS = 500;
+var DEFAULT_MAX_RETRY_DELAY_MS = 3e4;
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 425, 429]);
+var SigningUnavailableError = class extends Error {
+};
+async function hmacSha256Hex(secret, message) {
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle === void 0) {
+    throw new SigningUnavailableError(
+      "signingSecret needs Web Crypto (crypto.subtle), which this runtime does not provide, so the entry was not sent unsigned"
+    );
+  }
+  const encoder = new TextEncoder();
+  const key = await subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await subtle.sign(
+    "HMAC",
+    key,
+    encoder.encode(message)
+  );
+  return Array.from(
+    new Uint8Array(signature),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
+function parseRetryAfterMs(value) {
+  if (value === null || value === void 0 || value.trim() === "") {
+    return void 0;
+  }
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return seconds * 1e3;
+  }
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function validateRetryOptions(options) {
+  const retries = options.retries ?? 0;
+  if (!Number.isInteger(retries) || retries < 0) {
+    throw new RangeError(
+      `WebhookErrorAdapter: retries must be a whole number of 0 or more, received ${String(options.retries)}.`
+    );
+  }
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  if (!Number.isFinite(retryDelayMs) || retryDelayMs <= 0) {
+    throw new RangeError(
+      `WebhookErrorAdapter: retryDelayMs must be a positive number, received ${String(options.retryDelayMs)}.`
+    );
+  }
+  const maxRetryDelayMs = options.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+  if (!Number.isFinite(maxRetryDelayMs) || maxRetryDelayMs < retryDelayMs) {
+    throw new RangeError(
+      `WebhookErrorAdapter: maxRetryDelayMs must be a number no smaller than retryDelayMs (${retryDelayMs}), received ${String(options.maxRetryDelayMs)}.`
+    );
+  }
+  if (options.signingSecret === "") {
+    throw new RangeError(
+      "WebhookErrorAdapter: signingSecret must not be empty; leave it out to send unsigned."
+    );
+  }
+  return { retries, retryDelayMs, maxRetryDelayMs };
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
   "localhost",
   "127.0.0.1",
@@ -254,15 +326,57 @@ function parseWebhookUrl(url, allowInsecure) {
   );
 }
 var WebhookErrorAdapter = class {
-  /** @throws {RangeError} if `url` is not a valid `https://` URL (see `allowInsecure`) or `timeoutMs` is invalid. */
+  /** @throws {RangeError} if `url` is not a valid `https://` URL (see `allowInsecure`) or a timeout, retry or signing option is invalid. */
   constructor(url, options = {}) {
     this.url = url;
     this.options = options;
     this.prefix = options.prefix ?? DEFAULT_PREFIX;
     this.timeoutMs = resolveTimeoutMs(options.timeoutMs, "WebhookErrorAdapter");
+    ({
+      retries: this.retries,
+      retryDelayMs: this.retryDelayMs,
+      maxRetryDelayMs: this.maxRetryDelayMs
+    } = validateRetryOptions(options));
     this.target = parseWebhookUrl(url, options.allowInsecure ?? false).origin;
   }
   async log(entry) {
+    let body;
+    try {
+      body = JSON.stringify(
+        hasCallerId(entry) || this.retries > 0 ? { id: resolveEntryId(entry), ...serializeEntry(entry) } : serializeEntry(entry)
+      );
+    } catch (error) {
+      console.error(`${this.prefix} WebhookErrorAdapter:`, error);
+      return this.fail(
+        `could not prepare the entry: ${this.redact(describeError(error))}`
+      );
+    }
+    let attempt = await this.send(body);
+    let attempts = 1;
+    while (!attempt.ok && attempt.retryable && attempts <= this.retries) {
+      await sleep(this.retryWaitMs(attempts, attempt.retryAfterMs));
+      attempt = await this.send(body);
+      attempts += 1;
+    }
+    if (attempt.ok) {
+      return { ok: true };
+    }
+    return this.fail(
+      attempts > 1 ? `${attempt.reason} (after ${attempts} attempts)` : attempt.reason
+    );
+  }
+  /** Milliseconds to wait before retry number `retryNumber` (1 for the first). */
+  retryWaitMs(retryNumber, retryAfterMs) {
+    if (retryAfterMs !== void 0) {
+      return Math.min(retryAfterMs, this.maxRetryDelayMs);
+    }
+    const ceiling = Math.min(
+      this.maxRetryDelayMs,
+      this.retryDelayMs * 2 ** (retryNumber - 1)
+    );
+    return ceiling / 2 + Math.random() * ceiling / 2;
+  }
+  async send(body) {
     const controller = new AbortController();
     let timedOut = false;
     const timer = this.timeoutMs === Infinity ? void 0 : setTimeout(() => {
@@ -274,43 +388,70 @@ var WebhookErrorAdapter = class {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          ...this.options.headers
+          ...this.options.headers,
+          ...await this.signatureHeaders(body)
         },
-        // A caller-supplied id goes along so the receiver can drop a repeat.
-        body: JSON.stringify(
-          hasCallerId(entry) ? { id: resolveEntryId(entry), ...serializeEntry(entry) } : serializeEntry(entry)
-        ),
+        body,
         // A redirect would turn the POST into a GET without a body (302, 303)
         // or re-send the entry and headers to another host (307, 308).
         redirect: "manual",
         signal: controller.signal
       });
       if (response.type === "opaqueredirect") {
-        return this.fail(this.redirectMessage("a redirect"));
+        return this.rejected(this.redirectMessage("a redirect"));
       }
       if (!response.ok) {
         if (response.status >= 300 && response.status < 400) {
-          return this.fail(this.redirectMessage(`HTTP ${response.status}`));
+          return this.rejected(this.redirectMessage(`HTTP ${response.status}`));
         }
-        return this.fail(
-          `webhook ${this.target} responded with HTTP ${response.status}`
-        );
+        return {
+          ok: false,
+          reason: `webhook ${this.target} responded with HTTP ${response.status}`,
+          retryable: response.status >= 500 || RETRYABLE_STATUSES.has(response.status),
+          retryAfterMs: parseRetryAfterMs(response.headers?.get("retry-after"))
+        };
       }
       return { ok: true };
     } catch (error) {
       console.error(`${this.prefix} WebhookErrorAdapter:`, error);
+      if (error instanceof SigningUnavailableError) {
+        return this.rejected(error.message);
+      }
       if (timedOut) {
-        return this.fail(
-          timeoutMessage(`webhook ${this.target}`, this.timeoutMs)
-        );
+        return {
+          ok: false,
+          reason: timeoutMessage(`webhook ${this.target}`, this.timeoutMs),
+          retryable: true
+        };
       }
-      return this.fail(
-        `could not reach webhook ${this.target}: ${this.redact(describeError(error))}`
-      );
+      return {
+        ok: false,
+        reason: `could not reach webhook ${this.target}: ${this.redact(describeError(error))}`,
+        retryable: true
+      };
     } finally {
       clearTimeout(timer);
     }
   }
+  /** Timestamp and signature headers, or none when no `signingSecret` is set. */
+  async signatureHeaders(body) {
+    const secret = this.options.signingSecret;
+    if (secret === void 0) {
+      return {};
+    }
+    const timestamp = String(Math.floor(Date.now() / 1e3));
+    const signature = await hmacSha256Hex(
+      secret,
+      `${timestamp}.${body}`
+    );
+    return {
+      "X-Signature-Timestamp": timestamp,
+      "X-Signature-256": `sha256=${signature}`
+    };
+  }
+  rejected(reason) {
+    return { ok: false, reason, retryable: false };
+  }
   redirectMessage(what) {
     return `webhook ${this.target} responded with ${what}, which is not followed because the entry would not arrive intact; use the final URL instead`;
   }
@@ -1590,9 +1731,85 @@ var SupabaseErrorAdapter = class {
     });
   }
 };
+
+// src/adapters/event-emitter-error-adapter.ts
+var DEFAULT_EVENT_NAME = "error-log";
+var EventEmitterErrorAdapter = class {
+  /** @throws {RangeError} if `options.eventName` is empty. */
+  constructor(emitter, options = {}) {
+    this.emitter = emitter;
+    this.eventName = options.eventName ?? DEFAULT_EVENT_NAME;
+    if (this.eventName === "") {
+      throw new RangeError(
+        "EventEmitterErrorAdapter: eventName must not be empty."
+      );
+    }
+    this.requireListener = options.requireListener ?? false;
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+  }
+  async log(entry) {
+    try {
+      const record = {
+        id: resolveEntryId(entry),
+        ...serializeEntry(entry)
+      };
+      const delivered = this.emitter.emit(this.eventName, record);
+      if (this.requireListener && delivered === false) {
+        throw new Error(
+          `no listener is attached to "${this.eventName}", so nothing received the entry`
+        );
+      }
+      return { ok: true };
+    } catch (error) {
+      return reportFailure({
+        adapterName: "EventEmitterErrorAdapter",
+        prefix: this.prefix,
+        action: `to emit "${this.eventName}"`,
+        error
+      });
+    }
+  }
+};
+
+// src/adapters/websocket-error-adapter.ts
+var OPEN = 1;
+var STATE_NAMES = {
+  0: "still connecting",
+  1: "open",
+  2: "closing",
+  3: "closed"
+};
+var WebSocketErrorAdapter = class {
+  constructor(socket, options = {}) {
+    this.socket = socket;
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+  }
+  async log(entry) {
+    try {
+      const state = this.socket.readyState;
+      if (state !== OPEN) {
+        throw new Error(
+          `the socket is ${STATE_NAMES[state] ?? `in unknown state ${String(state)}`} (readyState ${String(state)}), so the entry was not sent; connect or reconnect it first`
+        );
+      }
+      this.socket.send(
+        JSON.stringify({ id: resolveEntryId(entry), ...serializeEntry(entry) })
+      );
+      return { ok: true };
+    } catch (error) {
+      return reportFailure({
+        adapterName: "WebSocketErrorAdapter",
+        prefix: this.prefix,
+        action: "to send over the socket",
+        error
+      });
+    }
+  }
+};
 export {
   CompositeErrorAdapter,
   ConsoleErrorAdapter,
+  EventEmitterErrorAdapter,
   FirestoreErrorAdapter,
   FlatFileErrorAdapter,
   IndexedDbErrorAdapter,
@@ -1605,6 +1822,7 @@ export {
   S3ErrorAdapter,
   SqliteErrorAdapter,
   SupabaseErrorAdapter,
+  WebSocketErrorAdapter,
   WebStorageErrorAdapter,
   WebhookErrorAdapter,
   buildCreateErrorLogTableSql,