@richardmcquiston01/error-log-adapter 0.4.0 → 0.6.0

package/dist/index.mjs

@@ -1,9 +1,98 @@
 // src/serialize.ts
-function serializeCause(cause) {
-  if (cause instanceof Error) {
-    return { name: cause.name, message: cause.message, stack: cause.stack };
+var MAX_CAUSE_DEPTH = 6;
+function isErrorLike(value) {
+  if (value instanceof Error) {
+    return true;
+  }
+  const candidate = value;
+  return typeof candidate.name === "string" && typeof candidate.message === "string" && typeof value.stack === "string";
+}
+function readProperty(source, key) {
+  try {
+    return source[key];
+  } catch (error) {
+    return `[Unreadable: ${error instanceof Error ? error.message : String(error)}]`;
+  }
+}
+function toJsonSafe(value, depth, ancestors) {
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+    case "undefined":
+      return value;
+    case "number":
+      return Number.isFinite(value) ? value : String(value);
+    case "bigint":
+      return `${value}n`;
+    case "symbol":
+      return value.toString();
+    case "function":
+      return `[Function ${value.name || "anonymous"}]`;
+    default:
+      break;
+  }
+  if (value === null) {
+    return null;
+  }
+  const objectValue = value;
+  if (ancestors.has(objectValue)) {
+    return "[Circular]";
+  }
+  if (depth >= MAX_CAUSE_DEPTH) {
+    return "[Truncated]";
+  }
+  ancestors.add(objectValue);
+  try {
+    if (isErrorLike(objectValue)) {
+      const result2 = {
+        name: objectValue.name,
+        message: objectValue.message,
+        stack: objectValue.stack
+      };
+      const nested = readProperty(objectValue, "cause");
+      if (nested !== void 0) {
+        result2["cause"] = toJsonSafe(nested, depth + 1, ancestors);
+      }
+      const errors = readProperty(objectValue, "errors");
+      if (Array.isArray(errors)) {
+        result2["errors"] = errors.map(
+          (item) => toJsonSafe(item, depth + 1, ancestors)
+        );
+      }
+      return result2;
+    }
+    if (Array.isArray(value)) {
+      return value.map(
+        (item) => toJsonSafe(item, depth + 1, ancestors)
+      );
+    }
+    const toJson = readProperty(objectValue, "toJSON");
+    if (typeof toJson === "function") {
+      try {
+        return toJsonSafe(
+          toJson.call(objectValue),
+          depth + 1,
+          ancestors
+        );
+      } catch (error) {
+        return `[toJSON failed: ${error instanceof Error ? error.message : String(error)}]`;
+      }
+    }
+    const result = {};
+    for (const key of Object.keys(objectValue)) {
+      result[key] = toJsonSafe(
+        readProperty(objectValue, key),
+        depth + 1,
+        ancestors
+      );
+    }
+    return result;
+  } finally {
+    ancestors.delete(objectValue);
   }
-  return cause;
+}
+function serializeCause(cause) {
+  return toJsonSafe(cause, 0, /* @__PURE__ */ new WeakSet());
 }
 function serializeEntry(entry) {
   const serialized = {
@@ -23,10 +112,20 @@ function describeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// src/fail.ts
+var DEFAULT_PREFIX = "[error-log-adapter]";
+function reportFailure(report) {
+  console.error(`${report.prefix} ${report.adapterName}:`, report.error);
+  return {
+    ok: false,
+    error: `${report.adapterName} failed ${report.action}: ${report.reason ?? describeError(report.error)}`
+  };
+}
+
 // src/adapters/console-error-adapter.ts
 var ConsoleErrorAdapter = class {
   constructor(options = {}) {
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
   }
   async log(entry) {
     try {
@@ -41,35 +140,324 @@ var ConsoleErrorAdapter = class {
   }
 };
 
+// src/uuid.ts
+function generateId() {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi !== void 0 && typeof cryptoApi.randomUUID === "function") {
+    return cryptoApi.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (cryptoApi !== void 0 && typeof cryptoApi.getRandomValues === "function") {
+    cryptoApi.getRandomValues(bytes);
+  } else {
+    for (let index = 0; index < bytes.length; index += 1) {
+      bytes[index] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(
+    bytes,
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/entry-id.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function hasCallerId(entry) {
+  return entry.id !== void 0;
+}
+function resolveEntryId(entry) {
+  if (entry.id === void 0) {
+    return generateId();
+  }
+  if (typeof entry.id !== "string" || !UUID_PATTERN.test(entry.id)) {
+    throw new RangeError(
+      `entry.id must be a UUID such as one from crypto.randomUUID(), received ${JSON.stringify(entry.id)}`
+    );
+  }
+  return entry.id.toLowerCase();
+}
+
+// src/timeout.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var SinkTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SinkTimeoutError";
+  }
+};
+function resolveTimeoutMs(value, adapterName) {
+  const timeoutMs = value ?? DEFAULT_TIMEOUT_MS;
+  if (Number.isNaN(timeoutMs) || timeoutMs <= 0) {
+    throw new RangeError(
+      `${adapterName}: timeoutMs must be a positive number or Infinity, received ${String(value)}.`
+    );
+  }
+  return timeoutMs;
+}
+function timeoutMessage(sink, timeoutMs, action = "respond") {
+  return `${sink} did not ${action} within ${timeoutMs} ms, so the entry may or may not have been stored (the operation can still finish later, so retrying could store it twice)`;
+}
+function withTimeout(start, timeoutMs, message) {
+  if (timeoutMs === Infinity) {
+    return new Promise((resolve, reject) => {
+      try {
+        resolve(start());
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  return new Promise(
+    (resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new SinkTimeoutError(message));
+      }, timeoutMs);
+      const settle = (done) => (...args) => {
+        clearTimeout(timer);
+        done(...args);
+      };
+      try {
+        Promise.resolve(start()).then(settle(resolve), settle(reject));
+      } catch (error) {
+        settle(reject)(error);
+      }
+    }
+  );
+}
+
 // 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",
+  "[::1]"
+]);
+function parseWebhookUrl(url, allowInsecure) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new RangeError(
+      "WebhookErrorAdapter: the webhook URL is not a valid absolute URL (for example https://example.com/errors)."
+    );
+  }
+  if (parsed.protocol === "https:") {
+    return parsed;
+  }
+  if (parsed.protocol === "http:" && (allowInsecure || LOOPBACK_HOSTS.has(parsed.hostname))) {
+    return parsed;
+  }
+  throw new RangeError(
+    `WebhookErrorAdapter: the webhook URL must use https:// because entries contain error messages and stack traces (received ${parsed.protocol}//${parsed.host}). Pass allowInsecure: true to send over http.`
+  );
+}
 var WebhookErrorAdapter = class {
+  /** @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 ?? "[error-log-adapter]";
+    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(() => {
+      timedOut = true;
+      controller.abort();
+    }, this.timeoutMs);
     try {
       const response = await fetch(this.url, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          ...this.options.headers
+          ...this.options.headers,
+          ...await this.signatureHeaders(body)
         },
-        body: JSON.stringify(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.rejected(this.redirectMessage("a redirect"));
+      }
       if (!response.ok) {
-        return this.fail(
-          `webhook ${this.url} responded with HTTP ${response.status}`
-        );
+        if (response.status >= 300 && response.status < 400) {
+          return this.rejected(this.redirectMessage(`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);
-      return this.fail(
-        `could not reach webhook ${this.url}: ${describeError(error)}`
-      );
+      if (error instanceof SigningUnavailableError) {
+        return this.rejected(error.message);
+      }
+      if (timedOut) {
+        return {
+          ok: false,
+          reason: timeoutMessage(`webhook ${this.target}`, this.timeoutMs),
+          retryable: true
+        };
+      }
+      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`;
+  }
+  /** Replaces the full URL in a message with its origin, in case the runtime put it there. */
+  redact(message) {
+    return message.split(this.url).join(this.target);
   }
   fail(reason) {
     return { ok: false, error: `WebhookErrorAdapter failed: ${reason}` };
@@ -77,37 +465,64 @@ var WebhookErrorAdapter = class {
 };
 
 // src/adapters/mongodb-error-adapter.ts
+function isDuplicateKeyError(error) {
+  return typeof error === "object" && error !== null && error.code === 11e3;
+}
 var MongoDbErrorAdapter = class {
+  /** @throws {RangeError} if `options.timeoutMs` is not a positive number or Infinity. */
   constructor(collection, options = {}) {
     this.collection = collection;
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(options.timeoutMs, "MongoDbErrorAdapter");
   }
   async log(entry) {
     try {
-      await this.collection.insertOne(serializeEntry(entry));
+      const document = hasCallerId(entry) ? { _id: resolveEntryId(entry), ...serializeEntry(entry) } : serializeEntry(entry);
+      await withTimeout(
+        () => this.collection.insertOne(document),
+        this.timeoutMs,
+        timeoutMessage("MongoDB", this.timeoutMs)
+      );
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} MongoDbErrorAdapter:`, error);
-      return {
-        ok: false,
-        error: `MongoDbErrorAdapter failed to insert entry: ${describeError(error)}`
-      };
+      if (hasCallerId(entry) && isDuplicateKeyError(error)) {
+        return { ok: true };
+      }
+      return reportFailure({
+        adapterName: "MongoDbErrorAdapter",
+        prefix: this.prefix,
+        action: "to insert entry",
+        error
+      });
     }
   }
 };
 
 // src/adapters/composite-error-adapter.ts
+var DEFAULT_COMPOSITE_TIMEOUT_MS = DEFAULT_TIMEOUT_MS * 3;
 var CompositeErrorAdapter = class {
-  constructor(adapters) {
+  /** @throws {RangeError} if `options.timeoutMs` is not a positive number or Infinity. */
+  constructor(adapters, options = {}) {
     this.adapters = adapters;
+    this.timeoutMs = resolveTimeoutMs(
+      options.timeoutMs ?? DEFAULT_COMPOSITE_TIMEOUT_MS,
+      "CompositeErrorAdapter"
+    );
   }
   async log(entry) {
     const results = await Promise.all(
       this.adapters.map(
-        async (adapter) => {
+        async (adapter, index) => {
           try {
-            return await adapter.log(entry);
+            return await withTimeout(
+              () => adapter.log(entry),
+              this.timeoutMs,
+              `adapter ${index} (${adapter.constructor.name}) did not return within ${this.timeoutMs} ms, so the entry may or may not have been stored there`
+            );
           } catch (error) {
+            if (error instanceof SinkTimeoutError) {
+              return { ok: false, error: error.message };
+            }
             return {
               ok: false,
               error: `adapter threw instead of returning a result: ${String(error)}`
@@ -138,58 +553,101 @@ function createErrorLogStore(database, storeName = DEFAULT_STORE_NAME) {
   database.createObjectStore(storeName, { keyPath: "id" }).createIndex("timestamp", "timestamp");
 }
 var IndexedDbErrorAdapter = class {
+  /** @throws {RangeError} if `options.timeoutMs` is not a positive number or Infinity. */
   constructor(database, options = {}) {
     this.database = database;
     this.storeName = options.storeName ?? DEFAULT_STORE_NAME;
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(
+      options.timeoutMs,
+      "IndexedDbErrorAdapter"
+    );
   }
   async log(entry) {
     try {
       const record = {
-        id: crypto.randomUUID(),
+        id: resolveEntryId(entry),
         ...serializeEntry(entry)
       };
-      await this.write(record);
+      await this.write(record, hasCallerId(entry));
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} IndexedDbErrorAdapter:`, error);
-      return {
-        ok: false,
-        error: `IndexedDbErrorAdapter failed to write to object store "${this.storeName}": ${describeError(error)}`
-      };
+      return reportFailure({
+        adapterName: "IndexedDbErrorAdapter",
+        prefix: this.prefix,
+        action: `to write to object store "${this.storeName}"`,
+        error
+      });
     }
   }
-  /** Resolves once the transaction commits; rejects if it errors or aborts. */
-  write(record) {
-    return new Promise(
-      (resolve, reject) => {
-        const transaction = this.database.transaction(
-          this.storeName,
-          "readwrite"
-        );
-        const fail = (action) => () => reject(
-          new Error(
-            `transaction ${action}: ${transaction.error?.message ?? "no details provided"}`
-          )
-        );
-        transaction.oncomplete = () => resolve();
-        transaction.onerror = fail("failed");
-        transaction.onabort = fail("aborted");
-        transaction.objectStore(this.storeName).add(record);
-      }
+  /**
+   * Resolves once the transaction commits; rejects if the request fails, the
+   * transaction aborts, or it does not finish within `timeoutMs`.
+   *
+   * Error events are handled here (`preventDefault` and `stopPropagation`), so a
+   * failed log write does not reach the `onerror` handler an app may have set on
+   * its own database object.
+   */
+  write(record, replaceExisting) {
+    return withTimeout(
+      () => new Promise(
+        (resolve, reject) => {
+          const transaction = this.database.transaction(
+            this.storeName,
+            "readwrite"
+          );
+          const fail = (what, source) => (event) => {
+            event?.preventDefault?.();
+            event?.stopPropagation?.();
+            reject(new Error(`${what}: ${describeDomError(source.error)}`));
+          };
+          transaction.oncomplete = () => resolve();
+          transaction.onerror = fail("transaction failed", transaction);
+          transaction.onabort = fail("transaction aborted", transaction);
+          const store = transaction.objectStore(
+            this.storeName
+          );
+          const request = replaceExisting && typeof store.put === "function" ? store.put(record) : store.add(record);
+          if (typeof request === "object" && request !== null) {
+            request.onerror = fail(
+              "request failed",
+              request
+            );
+          }
+        }
+      ),
+      this.timeoutMs,
+      timeoutMessage("IndexedDB", this.timeoutMs, "finish the transaction")
     );
   }
 };
+function describeDomError(error) {
+  if (error === null || error === void 0) {
+    return "no details provided";
+  }
+  const text = [error.name, error.message].filter((part) => typeof part === "string" && part !== "").join(": ");
+  return text === "" ? "no details provided" : text;
+}
 
-// src/adapters/sqlite-error-adapter.ts
+// src/sql-ident.ts
 var DEFAULT_TABLE_NAME = "error_log";
 var IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function assertValidTableName(tableName) {
-  if (!IDENTIFIER_PATTERN.test(tableName)) {
+function assertIdentifier(value, label, owner, maxLength) {
+  if (!IDENTIFIER_PATTERN.test(value)) {
     throw new RangeError(
-      `SqliteErrorAdapter: invalid table name "${tableName}". Use only letters, digits and underscores, and do not start with a digit.`
+      `${owner}: invalid ${label} "${value}". Use only letters, digits and underscores, and do not start with a digit.`
     );
   }
+  if (maxLength !== void 0 && value.length > maxLength) {
+    throw new RangeError(
+      `${owner}: ${label} "${value}" is ${value.length} characters long, but the limit is ${maxLength}.`
+    );
+  }
+}
+
+// src/adapters/sqlite-error-adapter.ts
+function assertValidTableName(tableName) {
+  assertIdentifier(tableName, "table name", "SqliteErrorAdapter");
 }
 function buildCreateErrorLogTableSql(tableName = DEFAULT_TABLE_NAME) {
   assertValidTableName(tableName);
@@ -199,23 +657,24 @@ function buildCreateErrorLogTableSql(tableName = DEFAULT_TABLE_NAME) {
   ];
 }
 var SqliteErrorAdapter = class {
-  /** @throws {RangeError} if `options.tableName` is not a plain identifier. */
+  /** @throws {RangeError} if `options.tableName` is not a plain identifier or `options.timeoutMs` is invalid. */
   constructor(client, options = {}) {
     this.client = client;
     this.tableReady = null;
     this.tableName = options.tableName ?? DEFAULT_TABLE_NAME;
     assertValidTableName(this.tableName);
     this.createTable = options.createTable ?? true;
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(options.timeoutMs, "SqliteErrorAdapter");
   }
   async log(entry) {
     try {
       await this.ensureTable();
       const serialized = serializeEntry(entry);
-      await this.client.run(
-        `INSERT INTO ${this.tableName} (id, code, message, cause, source, occurred_at) VALUES (?, ?, ?, ?, ?, ?)`,
+      await this.run(
+        `INSERT INTO ${this.tableName} (id, code, message, cause, source, occurred_at) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT (id) DO NOTHING`,
         [
-          crypto.randomUUID(),
+          resolveEntryId(entry),
           serialized.code,
           serialized.message,
           serialized.cause === void 0 ? null : JSON.stringify(serialized.cause),
@@ -225,11 +684,12 @@ var SqliteErrorAdapter = class {
       );
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} SqliteErrorAdapter:`, error);
-      return {
-        ok: false,
-        error: `SqliteErrorAdapter failed to write to table "${this.tableName}": ${describeError(error)}`
-      };
+      return reportFailure({
+        adapterName: "SqliteErrorAdapter",
+        prefix: this.prefix,
+        action: `to write to table "${this.tableName}"`,
+        error
+      });
     }
   }
   /** Creates the table once. A failed attempt is retried on the next log call. */
@@ -249,9 +709,17 @@ var SqliteErrorAdapter = class {
   }
   async runCreateStatements() {
     for (const sql of buildCreateErrorLogTableSql(this.tableName)) {
-      await this.client.run(sql, []);
+      await this.run(sql, []);
     }
   }
+  /** Runs one statement, giving up waiting after `timeoutMs`. */
+  run(sql, params) {
+    return withTimeout(
+      () => this.client.run(sql, params),
+      this.timeoutMs,
+      timeoutMessage("SQLite", this.timeoutMs)
+    );
+  }
 };
 
 // src/adapters/web-storage-error-adapter.ts
@@ -270,7 +738,8 @@ var WebStorageErrorAdapter = class {
     this.storage = storage;
     this.key = options.key ?? DEFAULT_STORAGE_KEY;
     this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.locks = options.locks === void 0 ? defaultLockManager() : options.locks;
     if (!Number.isInteger(this.maxEntries) || this.maxEntries < 1) {
       throw new RangeError(
         `WebStorageErrorAdapter: maxEntries must be a positive integer, received ${String(options.maxEntries)}.`
@@ -280,23 +749,49 @@ var WebStorageErrorAdapter = class {
   async log(entry) {
     try {
       const record = {
-        id: crypto.randomUUID(),
+        id: resolveEntryId(entry),
         ...serializeEntry(entry)
       };
-      this.append(record);
+      await this.appendLocked(record);
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} WebStorageErrorAdapter:`, error);
-      return {
-        ok: false,
-        error: `WebStorageErrorAdapter failed to write to storage key "${this.key}": ${describeError(error)}`
-      };
+      return reportFailure({
+        adapterName: "WebStorageErrorAdapter",
+        prefix: this.prefix,
+        action: `to write to storage key "${this.key}"`,
+        error
+      });
+    }
+  }
+  /**
+   * Appends under a cross-tab lock when one is available. If the lock itself
+   * cannot be taken (for example a sandboxed frame), the entry is still written
+   * without it rather than lost.
+   */
+  async appendLocked(record) {
+    if (this.locks === null) {
+      this.append(record);
+      return;
+    }
+    let appended = false;
+    try {
+      await this.locks.request(`error-log-adapter:${this.key}`, () => {
+        appended = true;
+        this.append(record);
+      });
+    } catch (error) {
+      if (appended) {
+        throw error;
+      }
+      this.append(record);
     }
   }
-  /** Reads, appends, trims, and writes back. Runs without awaiting, so calls never interleave. */
+  /** Reads, appends, trims, and writes back. Runs without awaiting, so calls in one tab never interleave. */
   append(record) {
     const records = [
-      ...this.readRecords(),
+      ...this.readRecords().filter(
+        (existing) => existing?.id !== record.id
+      ),
       record
     ].slice(-this.maxEntries);
     for (; ; ) {
@@ -322,16 +817,51 @@ var WebStorageErrorAdapter = class {
       if (Array.isArray(parsed)) {
         return parsed;
       }
-      console.error(
-        `${this.prefix} WebStorageErrorAdapter: storage key "${this.key}" did not hold an array, so it was replaced.`
-      );
+      this.setAside(stored, "did not hold an array");
     } catch (error) {
-      console.error(
-        `${this.prefix} WebStorageErrorAdapter: storage key "${this.key}" held invalid JSON (${describeError(error)}), so it was replaced.`
-      );
+      this.setAside(stored, `held invalid JSON (${describeError(error)})`);
     }
     return [];
   }
+  /**
+   * Copies an unusable value to `<key>.corrupt` before it is replaced, so data
+   * the host app stored under the same key is not silently destroyed. Only the
+   * first one is kept; a later unusable value would not overwrite it.
+   */
+  setAside(stored, reason) {
+    const backupKey = `${this.key}${CORRUPT_KEY_SUFFIX}`;
+    let savedTo = "but it could not be copied aside";
+    try {
+      if (this.storage.getItem(backupKey) === null) {
+        this.storage.setItem(backupKey, stored);
+        savedTo = `and a copy was kept under "${backupKey}"`;
+      } else {
+        savedTo = `and "${backupKey}" already holds an earlier copy`;
+      }
+    } catch {
+    }
+    console.error(
+      `${this.prefix} WebStorageErrorAdapter: storage key "${this.key}" ${reason}, so it was replaced, ${savedTo}.`
+    );
+  }
+};
+var CORRUPT_KEY_SUFFIX = ".corrupt";
+function defaultLockManager() {
+  const locks = globalThis.navigator?.locks;
+  return typeof locks?.request === "function" ? locks : null;
+}
+
+// src/queue.ts
+var SerialQueue = class {
+  constructor() {
+    this.tail = Promise.resolve();
+  }
+  /** Starts `task` once every earlier task has finished, and resolves with its result. */
+  run(task) {
+    const result = this.tail.then(task);
+    this.tail = result.catch(() => void 0);
+    return result;
+  }
 };
 
 // src/file-system.ts
@@ -339,6 +869,7 @@ async function loadNodeFileSystem() {
   const moduleName = "node:fs/promises";
   return await import(moduleName);
 }
+var ROOT_PATTERN = /^(?:[A-Za-z]:)?[\\/]+$/;
 function parentDirectory(filePath) {
   const lastSeparator = Math.max(
     filePath.lastIndexOf("/"),
@@ -347,7 +878,11 @@ function parentDirectory(filePath) {
   if (lastSeparator < 0) {
     return null;
   }
-  return lastSeparator === 0 ? "/" : filePath.slice(0, lastSeparator);
+  const directory = filePath.slice(0, lastSeparator + 1);
+  if (ROOT_PATTERN.test(directory)) {
+    return null;
+  }
+  return filePath.slice(0, lastSeparator);
 }
 function isMissingFileError(error) {
   return typeof error === "object" && error !== null && error.code === "ENOENT";
@@ -393,24 +928,20 @@ var FlatFileErrorAdapter = class {
   constructor(filePath, options = {}) {
     this.filePath = filePath;
     this.directoryReady = false;
-    this.queue = Promise.resolve();
+    this.queue = new SerialQueue();
     this.fs = options.fs;
     this.formatLine = options.formatLine ?? formatErrorLogLine;
     this.maxBytes = options.maxBytes;
     this.maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
     this.createDirectory = options.createDirectory ?? true;
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
     if (this.maxBytes !== void 0) {
       assertPositiveInteger(this.maxBytes, "maxBytes");
     }
     assertPositiveInteger(this.maxFiles, "maxFiles");
   }
   log(entry) {
-    const result = this.queue.then(
-      () => this.write(entry)
-    );
-    this.queue = result.catch(() => void 0);
-    return result;
+    return this.queue.run(() => this.write(entry));
   }
   async write(entry) {
     try {
@@ -423,11 +954,12 @@ var FlatFileErrorAdapter = class {
       await fs.appendFile(this.filePath, line);
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} FlatFileErrorAdapter:`, error);
-      return {
-        ok: false,
-        error: `FlatFileErrorAdapter failed to append to "${this.filePath}": ${describeError(error)}`
-      };
+      return reportFailure({
+        adapterName: "FlatFileErrorAdapter",
+        prefix: this.prefix,
+        action: `to append to "${this.filePath}"`,
+        error
+      });
     }
   }
   /** Uses the injected file system, or loads `node:fs/promises` on first use. */
@@ -502,13 +1034,13 @@ var JsonFileErrorAdapter = class {
   constructor(filePath, options = {}) {
     this.filePath = filePath;
     this.directoryReady = false;
-    this.queue = Promise.resolve();
+    this.queue = new SerialQueue();
     this.mode = options.mode ?? "ndjson";
     this.maxEntries = options.maxEntries;
     this.indent = options.indent ?? DEFAULT_INDENT;
     this.fs = options.fs;
     this.createDirectory = options.createDirectory ?? true;
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
     if (this.maxEntries !== void 0) {
       if (this.mode !== "array") {
         throw new RangeError(
@@ -528,16 +1060,12 @@ var JsonFileErrorAdapter = class {
     }
   }
   log(entry) {
-    const result = this.queue.then(
-      () => this.write(entry)
-    );
-    this.queue = result.catch(() => void 0);
-    return result;
+    return this.queue.run(() => this.write(entry));
   }
   async write(entry) {
     try {
       const record = {
-        id: crypto.randomUUID(),
+        id: resolveEntryId(entry),
         ...serializeEntry(entry)
       };
       const fs = await this.getFileSystem();
@@ -550,11 +1078,12 @@ var JsonFileErrorAdapter = class {
       }
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} JsonFileErrorAdapter:`, error);
-      return {
-        ok: false,
-        error: `JsonFileErrorAdapter failed to write "${this.filePath}" in ${this.mode} mode: ${describeError(error)}`
-      };
+      return reportFailure({
+        adapterName: "JsonFileErrorAdapter",
+        prefix: this.prefix,
+        action: `to write "${this.filePath}" in ${this.mode} mode`,
+        error
+      });
     }
   }
   async getFileSystem() {
@@ -580,7 +1109,9 @@ var JsonFileErrorAdapter = class {
    */
   async rewriteArray(fs, record) {
     const records = [
-      ...await this.readRecords(fs),
+      ...(await this.readRecords(fs)).filter(
+        (existing) => existing?.id !== record.id
+      ),
       record
     ];
     const kept = this.maxEntries === void 0 ? records : records.slice(-this.maxEntries);
@@ -630,25 +1161,14 @@ var JsonFileErrorAdapter = class {
 };
 
 // src/adapters/sql-error-adapter.ts
-var DEFAULT_TABLE_NAME2 = "error_log";
 var MAX_TABLE_NAME_LENGTH = 47;
-var IDENTIFIER_PATTERN2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function assertValidTableName2(tableName, adapterName) {
-  if (!IDENTIFIER_PATTERN2.test(tableName)) {
-    throw new RangeError(
-      `${adapterName}: invalid table name "${tableName}". Use only letters, digits and underscores, and do not start with a digit.`
-    );
-  }
-  if (tableName.length > MAX_TABLE_NAME_LENGTH) {
-    throw new RangeError(
-      `${adapterName}: table name "${tableName}" is ${tableName.length} characters long, but the limit is ${MAX_TABLE_NAME_LENGTH}.`
-    );
-  }
+  assertIdentifier(tableName, "table name", adapterName, MAX_TABLE_NAME_LENGTH);
 }
 function quoteIdentifier(dialect, identifier) {
   return dialect === "postgres" ? `"${identifier}"` : `\`${identifier}\``;
 }
-function buildErrorLogTableDdl(dialect, tableName = DEFAULT_TABLE_NAME2) {
+function buildErrorLogTableDdl(dialect, tableName = DEFAULT_TABLE_NAME) {
   assertValidTableName2(tableName, "buildErrorLogTableDdl");
   const table = quoteIdentifier(dialect, tableName);
   const index = quoteIdentifier(
@@ -662,7 +1182,13 @@ function buildErrorLogTableDdl(dialect, tableName = DEFAULT_TABLE_NAME2) {
     ];
   }
   return [
-    `CREATE TABLE IF NOT EXISTS ${table} (id CHAR(36) NOT NULL PRIMARY KEY, code VARCHAR(255) NOT NULL, message TEXT NOT NULL, cause JSON NULL, source VARCHAR(255) NULL, occurred_at DATETIME(3) NOT NULL, created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3), INDEX ${index} (occurred_at))`
+    `CREATE TABLE IF NOT EXISTS ${table} (id CHAR(36) NOT NULL PRIMARY KEY, code TEXT NOT NULL, message TEXT NOT NULL, cause JSON NULL, source TEXT NULL, occurred_at DATETIME(3) NOT NULL, created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3), INDEX ${index} (occurred_at))`
+  ];
+}
+function buildMySqlWidenColumnsSql(tableName = DEFAULT_TABLE_NAME) {
+  assertValidTableName2(tableName, "buildMySqlWidenColumnsSql");
+  return [
+    `ALTER TABLE ${quoteIdentifier("mysql", tableName)} MODIFY code TEXT NOT NULL, MODIFY source TEXT NULL`
   ];
 }
 function toMysqlDateTime(date) {
@@ -674,10 +1200,11 @@ var SqlErrorAdapter = class {
     this.dialect = dialect;
     this.adapterName = adapterName;
     this.tableReady = null;
-    this.tableName = options.tableName ?? DEFAULT_TABLE_NAME2;
+    this.tableName = options.tableName ?? DEFAULT_TABLE_NAME;
     assertValidTableName2(this.tableName, adapterName);
     this.createTable = options.createTable ?? true;
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(options.timeoutMs, adapterName);
   }
   async log(entry) {
     try {
@@ -689,7 +1216,7 @@ var SqlErrorAdapter = class {
         );
       }
       const params = [
-        crypto.randomUUID(),
+        resolveEntryId(entry),
         serialized.code,
         serialized.message,
         serialized.cause === void 0 ? null : JSON.stringify(serialized.cause),
@@ -697,19 +1224,21 @@ var SqlErrorAdapter = class {
         this.dialect === "postgres" ? occurredAt.toISOString() : toMysqlDateTime(occurredAt)
       ];
       await this.ensureTable();
-      await this.client.query(this.insertSql(), params);
+      await this.query(this.insertSql(), params);
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} ${this.adapterName}:`, error);
-      return {
-        ok: false,
-        error: `${this.adapterName} failed to write to table "${this.tableName}": ${describeError(error)}`
-      };
+      return reportFailure({
+        adapterName: this.adapterName,
+        prefix: this.prefix,
+        action: `to write to table "${this.tableName}"`,
+        error
+      });
     }
   }
   insertSql() {
     const placeholders = this.dialect === "postgres" ? "$1, $2, $3, $4, $5, $6" : "?, ?, ?, ?, ?, ?";
-    return `INSERT INTO ${quoteIdentifier(this.dialect, this.tableName)} (id, code, message, cause, source, occurred_at) VALUES (${placeholders})`;
+    const onRepeat = this.dialect === "postgres" ? "ON CONFLICT (id) DO NOTHING" : "ON DUPLICATE KEY UPDATE id = id";
+    return `INSERT INTO ${quoteIdentifier(this.dialect, this.tableName)} (id, code, message, cause, source, occurred_at) VALUES (${placeholders}) ${onRepeat}`;
   }
   /** Creates the table once. A failed attempt is retried on the next log call. */
   ensureTable() {
@@ -728,9 +1257,20 @@ var SqlErrorAdapter = class {
   }
   async runCreateStatements() {
     for (const sql of buildErrorLogTableDdl(this.dialect, this.tableName)) {
-      await this.client.query(sql, []);
+      await this.query(sql, []);
     }
   }
+  /** Runs one statement, giving up waiting after `timeoutMs`. */
+  query(sql, params) {
+    return withTimeout(
+      () => this.client.query(sql, params),
+      this.timeoutMs,
+      timeoutMessage(
+        this.dialect === "postgres" ? "Postgres" : "MySQL",
+        this.timeoutMs
+      )
+    );
+  }
 };
 var PostgresErrorAdapter = class extends SqlErrorAdapter {
   /** @throws {RangeError} if `options.tableName` is not a plain identifier of 47 characters or fewer. */
@@ -755,7 +1295,8 @@ var RedisErrorAdapter = class {
     this.key = options.key ?? DEFAULT_REDIS_KEY;
     this.maxEntries = options.maxEntries;
     this.side = options.side ?? "right";
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(options.timeoutMs, "RedisErrorAdapter");
     if (this.mode !== "list" && this.mode !== "stream") {
       throw new RangeError(
         `RedisErrorAdapter: mode must be "list" or "stream", received "${String(options.mode)}".`
@@ -777,11 +1318,11 @@ var RedisErrorAdapter = class {
   }
   async log(entry) {
     try {
-      const record = { id: crypto.randomUUID(), ...serializeEntry(entry) };
+      const record = { id: resolveEntryId(entry), ...serializeEntry(entry) };
       if (this.mode === "stream") {
-        await this.client.sendCommand(this.buildStreamCommand(record));
+        await this.send(this.buildStreamCommand(record));
       } else {
-        await this.client.sendCommand([
+        await this.send([
           this.side === "left" ? "LPUSH" : "RPUSH",
           this.key,
           JSON.stringify(record)
@@ -790,11 +1331,12 @@ var RedisErrorAdapter = class {
       }
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} RedisErrorAdapter:`, error);
-      return {
-        ok: false,
-        error: `RedisErrorAdapter failed to write to ${this.mode} "${this.key}": ${describeError(error)}`
-      };
+      return reportFailure({
+        adapterName: "RedisErrorAdapter",
+        prefix: this.prefix,
+        action: `to write to ${this.mode} "${this.key}"`,
+        error
+      });
     }
   }
   buildStreamCommand(record) {
@@ -826,6 +1368,14 @@ var RedisErrorAdapter = class {
    * stored by now, so a trim failure is reported but does not fail the call;
    * the next successful write trims the list again.
    */
+  /** Sends one command, giving up waiting after `timeoutMs`. */
+  send(args) {
+    return withTimeout(
+      () => this.client.sendCommand(args),
+      this.timeoutMs,
+      timeoutMessage("Redis", this.timeoutMs)
+    );
+  }
   async trimList() {
     if (this.maxEntries === void 0) {
       return;
@@ -833,7 +1383,7 @@ var RedisErrorAdapter = class {
     const keep = this.maxEntries;
     const [start, stop] = this.side === "right" ? [String(-keep), "-1"] : ["0", String(keep - 1)];
     try {
-      await this.client.sendCommand(["LTRIM", this.key, start, stop]);
+      await this.send(["LTRIM", this.key, start, stop]);
     } catch (error) {
       console.error(
         `${this.prefix} RedisErrorAdapter: stored the entry but could not trim list "${this.key}" to ${keep} entries: ${describeError(error)}`
@@ -860,11 +1410,12 @@ var S3ErrorAdapter = class {
     this.bucket = bucket;
     this.buffer = [];
     this.timer = null;
-    this.flushQueue = Promise.resolve();
+    this.flushQueue = new SerialQueue();
     this.keyPrefix = normalizePrefix(options.keyPrefix ?? DEFAULT_S3_PREFIX);
     this.batch = options.batch;
     this.contentType = options.contentType ?? (this.batch === void 0 ? "application/json" : "application/x-ndjson");
-    this.logPrefix = options.prefix ?? "[error-log-adapter]";
+    this.logPrefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(options.timeoutMs, "S3ErrorAdapter");
     if (bucket === "") {
       throw new RangeError("S3ErrorAdapter: bucket must not be empty.");
     }
@@ -884,7 +1435,7 @@ var S3ErrorAdapter = class {
   async log(entry) {
     try {
       const record = {
-        id: crypto.randomUUID(),
+        id: resolveEntryId(entry),
         ...serializeEntry(entry)
       };
       const occurredAt = new Date(record.timestamp);
@@ -909,11 +1460,9 @@ var S3ErrorAdapter = class {
    * Entries from a failed upload stay buffered and are retried by the next flush.
    */
   flush() {
-    const result = this.flushQueue.then(
+    return this.flushQueue.run(
       () => this.uploadBuffered()
     );
-    this.flushQueue = result.catch(() => void 0);
-    return result;
   }
   async addToBatch(record, batch) {
     this.buffer.push(record);
@@ -952,7 +1501,7 @@ var S3ErrorAdapter = class {
       return { ok: true };
     }
     try {
-      const key = `${this.keyPrefix}${datePath(/* @__PURE__ */ new Date())}-${crypto.randomUUID()}.ndjson`;
+      const key = `${this.keyPrefix}${datePath(/* @__PURE__ */ new Date())}-${generateId()}.ndjson`;
       const body = pending.map((record) => JSON.stringify(record)).join("\n");
       await this.upload(key, `${body}
 `);
@@ -969,64 +1518,41 @@ var S3ErrorAdapter = class {
     }
   }
   upload(key, body) {
-    return this.client.putObject({
-      Bucket: this.bucket,
-      Key: key,
-      Body: body,
-      ContentType: this.contentType
-    });
+    return withTimeout(
+      () => this.client.putObject({
+        Bucket: this.bucket,
+        Key: key,
+        Body: body,
+        ContentType: this.contentType
+      }),
+      this.timeoutMs,
+      timeoutMessage("S3", this.timeoutMs)
+    );
   }
   fail(error, bufferedCount) {
-    console.error(`${this.logPrefix} S3ErrorAdapter:`, error);
     const retry = bufferedCount === void 0 ? "" : ` (${bufferedCount} buffered ${bufferedCount === 1 ? "entry was" : "entries were"} kept for the next flush)`;
-    return {
-      ok: false,
-      error: `S3ErrorAdapter failed to upload to bucket "${this.bucket}": ${describeError(error)}${retry}`
-    };
+    return reportFailure({
+      adapterName: "S3ErrorAdapter",
+      prefix: this.logPrefix,
+      action: `to upload to bucket "${this.bucket}"`,
+      error,
+      reason: `${describeError(error)}${retry}`
+    });
   }
 };
 
 // src/adapters/firebase-error-adapter.ts
-var DEFAULT_WRITE_TIMEOUT_MS = 1e4;
-function resolveTimeout(options, adapter) {
-  const timeoutMs = options.timeoutMs ?? DEFAULT_WRITE_TIMEOUT_MS;
-  if (Number.isNaN(timeoutMs) || timeoutMs <= 0) {
-    throw new RangeError(
-      `${adapter}: timeoutMs must be a positive number or Infinity, received ${String(options.timeoutMs)}.`
-    );
-  }
-  return timeoutMs;
-}
-function waitForWrite(write, timeoutMs) {
-  if (timeoutMs === Infinity) {
-    return Promise.resolve(write);
-  }
-  return new Promise(
-    (resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(
-          new Error(
-            `the write was not saved within ${timeoutMs} ms (the connection may be down; the SDK keeps the write queued and may still save it later)`
-          )
-        );
-      }, timeoutMs);
-      write.then(
-        (value) => {
-          clearTimeout(timer);
-          resolve(value);
-        },
-        (reason) => {
-          clearTimeout(timer);
-          reject(reason);
-        }
-      );
-    }
+function waitForWrite(start, timeoutMs) {
+  return withTimeout(
+    start,
+    timeoutMs,
+    `the write was not saved within ${timeoutMs} ms (the connection may be down; the SDK keeps the write queued and may still save it later, so logging the entry again could store it twice unless it carries an id)`
   );
 }
 function buildRecord(entry) {
   const serialized = serializeEntry(entry);
   const record = {
-    id: crypto.randomUUID(),
+    id: resolveEntryId(entry),
     code: serialized.code,
     message: serialized.message,
     timestamp: serialized.timestamp
@@ -1043,23 +1569,27 @@ var FirestoreErrorAdapter = class {
   /** @throws {RangeError} if `options.timeoutMs` is not a positive number or `Infinity`. */
   constructor(collection, options = {}) {
     this.collection = collection;
-    this.prefix = options.prefix ?? "[error-log-adapter]";
-    this.timeoutMs = resolveTimeout(options, "FirestoreErrorAdapter");
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(
+      options.timeoutMs,
+      "FirestoreErrorAdapter"
+    );
   }
   async log(entry) {
     try {
       const record = buildRecord(entry);
       await waitForWrite(
-        this.collection.doc(record.id).set(record),
+        () => this.collection.doc(record.id).set(record),
         this.timeoutMs
       );
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} FirestoreErrorAdapter:`, error);
-      return {
-        ok: false,
-        error: `FirestoreErrorAdapter failed to write the document: ${describeError(error)}`
-      };
+      return reportFailure({
+        adapterName: "FirestoreErrorAdapter",
+        prefix: this.prefix,
+        action: `to write the document`,
+        error
+      });
     }
   }
 };
@@ -1067,34 +1597,51 @@ var RealtimeDatabaseErrorAdapter = class {
   /** @throws {RangeError} if `options.timeoutMs` is not a positive number or `Infinity`. */
   constructor(reference, options = {}) {
     this.reference = reference;
-    this.prefix = options.prefix ?? "[error-log-adapter]";
-    this.timeoutMs = resolveTimeout(options, "RealtimeDatabaseErrorAdapter");
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(
+      options.timeoutMs,
+      "RealtimeDatabaseErrorAdapter"
+    );
   }
   async log(entry) {
     try {
-      await waitForWrite(
-        this.reference.push(buildRecord(entry)),
-        this.timeoutMs
-      );
+      const record = buildRecord(entry);
+      let write;
+      if (hasCallerId(entry)) {
+        if (this.reference.child === void 0) {
+          throw new TypeError(
+            "the entry has an id, which needs a reference with child(key).set(value) so a repeat overwrites the first write; add child to the reference or log without an id"
+          );
+        }
+        write = this.reference.child(record.id).set(record);
+      } else {
+        write = this.reference.push(record);
+      }
+      await waitForWrite(() => write, this.timeoutMs);
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} RealtimeDatabaseErrorAdapter:`, error);
-      return {
-        ok: false,
-        error: `RealtimeDatabaseErrorAdapter failed to write the entry: ${describeError(error)}`
-      };
+      return reportFailure({
+        adapterName: "RealtimeDatabaseErrorAdapter",
+        prefix: this.prefix,
+        action: `to write the entry`,
+        error
+      });
     }
   }
 };
 
 // src/adapters/supabase-error-adapter.ts
-var IDENTIFIER_PATTERN3 = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function buildSupabaseSetupSql(tableName = DEFAULT_TABLE_NAME2, options = {}) {
+var POLICY_MAX_CODE_LENGTH = 255;
+var POLICY_MAX_MESSAGE_LENGTH = 4096;
+var POLICY_MAX_CAUSE_BYTES = 8192;
+var INSERT_POLICY_CHECK = `char_length(code) <= ${POLICY_MAX_CODE_LENGTH} AND char_length(message) <= ${POLICY_MAX_MESSAGE_LENGTH} AND (source IS NULL OR char_length(source) <= ${POLICY_MAX_CODE_LENGTH}) AND (cause IS NULL OR pg_column_size(cause) <= ${POLICY_MAX_CAUSE_BYTES})`;
+function buildSupabaseSetupSql(tableName = DEFAULT_TABLE_NAME, options = {}) {
   const insertRoles = options.insertRoles ?? [];
   for (const role of insertRoles) {
-    if (!IDENTIFIER_PATTERN3.test(role)) {
+    assertIdentifier(role, "role name", "buildSupabaseSetupSql");
+    if ((role.toLowerCase() === "anon" || role.toLowerCase() === "public") && options.allowPublicInsert !== true) {
       throw new RangeError(
-        `buildSupabaseSetupSql: invalid role name "${role}". Use only letters, digits and underscores, and do not start with a digit.`
+        `buildSupabaseSetupSql: role "${role}" would let anyone who loads your page write to the log, because the anon key is public. Use "authenticated" instead, or pass allowPublicInsert: true to accept the risk of forged entries and quota use.`
       );
     }
   }
@@ -1106,7 +1653,7 @@ function buildSupabaseSetupSql(tableName = DEFAULT_TABLE_NAME2, options = {}) {
     const policy = `${tableName}_insert_only`;
     statements.push(
       `DROP POLICY IF EXISTS "${policy}" ON "${tableName}"`,
-      `CREATE POLICY "${policy}" ON "${tableName}" FOR INSERT TO ${insertRoles.map((role) => `"${role}"`).join(", ")} WITH CHECK (true)`
+      `CREATE POLICY "${policy}" ON "${tableName}" FOR INSERT TO ${insertRoles.map((role) => `"${role}"`).join(", ")} WITH CHECK (${INSERT_POLICY_CHECK})`
     );
   }
   return statements;
@@ -1136,49 +1683,97 @@ function describeSupabaseError(result) {
   return parts.join("; ");
 }
 var SupabaseErrorAdapter = class {
-  /** @throws {RangeError} if `options.tableName` is empty. */
+  /** @throws {RangeError} if `options.tableName` is not a plain identifier or `options.timeoutMs` is invalid. */
   constructor(client, options = {}) {
     this.client = client;
-    this.tableName = options.tableName ?? DEFAULT_TABLE_NAME2;
-    if (this.tableName.trim() === "") {
-      throw new RangeError(
-        "SupabaseErrorAdapter: tableName must not be empty."
-      );
-    }
-    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.tableName = options.tableName ?? DEFAULT_TABLE_NAME;
+    assertIdentifier(this.tableName, "table name", "SupabaseErrorAdapter");
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(
+      options.timeoutMs,
+      "SupabaseErrorAdapter"
+    );
   }
   async log(entry) {
     try {
       const serialized = serializeEntry(entry);
       const row = {
-        id: crypto.randomUUID(),
+        id: resolveEntryId(entry),
         code: serialized.code,
         message: serialized.message,
         cause: serialized.cause === void 0 ? null : serialized.cause,
         source: serialized.source ?? null,
         occurred_at: serialized.timestamp
       };
-      const result = await this.client.from(this.tableName).insert(row);
+      const result = await withTimeout(
+        () => this.client.from(this.tableName).insert(row),
+        this.timeoutMs,
+        timeoutMessage("Supabase", this.timeoutMs)
+      );
       if (result.error) {
-        console.error(`${this.prefix} SupabaseErrorAdapter:`, result);
-        return this.fail(describeSupabaseError(result));
+        if (hasCallerId(entry) && result.error.code === "23505") {
+          return { ok: true };
+        }
+        return this.fail(result, describeSupabaseError(result));
       }
       return { ok: true };
     } catch (error) {
-      console.error(`${this.prefix} SupabaseErrorAdapter:`, error);
-      return this.fail(describeError(error));
+      return this.fail(error, describeError(error));
     }
   }
-  fail(reason) {
-    return {
-      ok: false,
-      error: `SupabaseErrorAdapter failed to insert into table "${this.tableName}": ${reason}`
-    };
+  fail(logged, reason) {
+    return reportFailure({
+      adapterName: "SupabaseErrorAdapter",
+      prefix: this.prefix,
+      action: `to insert into table "${this.tableName}"`,
+      error: logged,
+      reason
+    });
+  }
+};
+
+// 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
+      });
+    }
   }
 };
 export {
   CompositeErrorAdapter,
   ConsoleErrorAdapter,
+  EventEmitterErrorAdapter,
   FirestoreErrorAdapter,
   FlatFileErrorAdapter,
   IndexedDbErrorAdapter,
@@ -1195,6 +1790,7 @@ export {
   WebhookErrorAdapter,
   buildCreateErrorLogTableSql,
   buildErrorLogTableDdl,
+  buildMySqlWidenColumnsSql,
   buildSupabaseSetupSql,
   createErrorLogStore,
   formatErrorLogLine,