@richardmcquiston01/error-log-adapter 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -22,19 +22,24 @@ var index_exports = {};
 __export(index_exports, {
   CompositeErrorAdapter: () => CompositeErrorAdapter,
   ConsoleErrorAdapter: () => ConsoleErrorAdapter,
+  FirestoreErrorAdapter: () => FirestoreErrorAdapter,
   FlatFileErrorAdapter: () => FlatFileErrorAdapter,
   IndexedDbErrorAdapter: () => IndexedDbErrorAdapter,
   JsonFileErrorAdapter: () => JsonFileErrorAdapter,
   MongoDbErrorAdapter: () => MongoDbErrorAdapter,
   MySqlErrorAdapter: () => MySqlErrorAdapter,
   PostgresErrorAdapter: () => PostgresErrorAdapter,
+  RealtimeDatabaseErrorAdapter: () => RealtimeDatabaseErrorAdapter,
   RedisErrorAdapter: () => RedisErrorAdapter,
   S3ErrorAdapter: () => S3ErrorAdapter,
   SqliteErrorAdapter: () => SqliteErrorAdapter,
+  SupabaseErrorAdapter: () => SupabaseErrorAdapter,
   WebStorageErrorAdapter: () => WebStorageErrorAdapter,
   WebhookErrorAdapter: () => WebhookErrorAdapter,
   buildCreateErrorLogTableSql: () => buildCreateErrorLogTableSql,
   buildErrorLogTableDdl: () => buildErrorLogTableDdl,
+  buildMySqlWidenColumnsSql: () => buildMySqlWidenColumnsSql,
+  buildSupabaseSetupSql: () => buildSupabaseSetupSql,
   createErrorLogStore: () => createErrorLogStore,
   formatErrorLogLine: () => formatErrorLogLine,
   serializeCause: () => serializeCause,
@@ -43,11 +48,100 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // 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;
   }
-  return cause;
+  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);
+  }
+}
+function serializeCause(cause) {
+  return toJsonSafe(cause, 0, /* @__PURE__ */ new WeakSet());
 }
 function serializeEntry(entry) {
   const serialized = {
@@ -67,10 +161,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 {
@@ -85,14 +189,135 @@ 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 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 `timeoutMs` 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");
+    this.target = parseWebhookUrl(url, options.allowInsecure ?? false).origin;
   }
   async log(entry) {
+    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",
@@ -100,58 +325,112 @@ var WebhookErrorAdapter = class {
           "Content-Type": "application/json",
           ...this.options.headers
         },
-        body: JSON.stringify(serializeEntry(entry))
+        // 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)
+        ),
+        // 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"));
+      }
       if (!response.ok) {
+        if (response.status >= 300 && response.status < 400) {
+          return this.fail(this.redirectMessage(`HTTP ${response.status}`));
+        }
         return this.fail(
-          `webhook ${this.url} responded with HTTP ${response.status}`
+          `webhook ${this.target} responded with HTTP ${response.status}`
         );
       }
       return { ok: true };
     } catch (error) {
       console.error(`${this.prefix} WebhookErrorAdapter:`, error);
+      if (timedOut) {
+        return this.fail(
+          timeoutMessage(`webhook ${this.target}`, this.timeoutMs)
+        );
+      }
       return this.fail(
-        `could not reach webhook ${this.url}: ${describeError(error)}`
+        `could not reach webhook ${this.target}: ${this.redact(describeError(error))}`
       );
+    } finally {
+      clearTimeout(timer);
     }
   }
+  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}` };
   }
 };
 
 // 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)}`
@@ -182,59 +461,102 @@ 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);
   return [
@@ -243,23 +565,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),
@@ -269,11 +592,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. */
@@ -293,9 +617,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
@@ -314,7 +646,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)}.`
@@ -324,23 +657,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
+      });
     }
   }
-  /** Reads, appends, trims, and writes back. Runs without awaiting, so calls never interleave. */
+  /**
+   * 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 in one tab never interleave. */
   append(record) {
     const records = [
-      ...this.readRecords(),
+      ...this.readRecords().filter(
+        (existing) => existing?.id !== record.id
+      ),
       record
     ].slice(-this.maxEntries);
     for (; ; ) {
@@ -366,16 +725,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
@@ -383,6 +777,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("/"),
@@ -391,7 +786,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";
@@ -437,24 +836,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 {
@@ -467,11 +862,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. */
@@ -546,13 +942,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(
@@ -572,16 +968,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();
@@ -594,11 +986,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() {
@@ -624,7 +1017,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);
@@ -674,25 +1069,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(
@@ -706,7 +1090,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) {
@@ -718,10 +1108,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 {
@@ -733,7 +1124,7 @@ var SqlErrorAdapter = class {
         );
       }
       const params = [
-        crypto.randomUUID(),
+        resolveEntryId(entry),
         serialized.code,
         serialized.message,
         serialized.cause === void 0 ? null : JSON.stringify(serialized.cause),
@@ -741,19 +1132,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() {
@@ -772,9 +1165,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. */
@@ -799,7 +1203,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)}".`
@@ -821,11 +1226,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)
@@ -834,11 +1239,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) {
@@ -870,6 +1276,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;
@@ -877,7 +1291,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)}`
@@ -904,11 +1318,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.");
     }
@@ -928,7 +1343,7 @@ var S3ErrorAdapter = class {
   async log(entry) {
     try {
       const record = {
-        id: crypto.randomUUID(),
+        id: resolveEntryId(entry),
         ...serializeEntry(entry)
       };
       const occurredAt = new Date(record.timestamp);
@@ -953,11 +1368,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);
@@ -996,7 +1409,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}
 `);
@@ -1013,39 +1426,241 @@ 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
+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: resolveEntryId(entry),
+    code: serialized.code,
+    message: serialized.message,
+    timestamp: serialized.timestamp
+  };
+  if (serialized.source !== void 0) {
+    record.source = serialized.source;
+  }
+  if (serialized.cause !== void 0) {
+    record.cause = JSON.stringify(serialized.cause);
+  }
+  return record;
+}
+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 ?? 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.timeoutMs
+      );
+      return { ok: true };
+    } catch (error) {
+      return reportFailure({
+        adapterName: "FirestoreErrorAdapter",
+        prefix: this.prefix,
+        action: `to write the document`,
+        error
+      });
+    }
+  }
+};
+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 ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(
+      options.timeoutMs,
+      "RealtimeDatabaseErrorAdapter"
+    );
+  }
+  async log(entry) {
+    try {
+      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) {
+      return reportFailure({
+        adapterName: "RealtimeDatabaseErrorAdapter",
+        prefix: this.prefix,
+        action: `to write the entry`,
+        error
+      });
+    }
+  }
+};
+
+// src/adapters/supabase-error-adapter.ts
+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) {
+    assertIdentifier(role, "role name", "buildSupabaseSetupSql");
+    if ((role.toLowerCase() === "anon" || role.toLowerCase() === "public") && options.allowPublicInsert !== true) {
+      throw new RangeError(
+        `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.`
+      );
+    }
+  }
+  const statements = [
+    ...buildErrorLogTableDdl("postgres", tableName),
+    `ALTER TABLE "${tableName}" ENABLE ROW LEVEL SECURITY`
+  ];
+  if (insertRoles.length > 0) {
+    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 (${INSERT_POLICY_CHECK})`
+    );
+  }
+  return statements;
+}
+function describeSupabaseError(result) {
+  const error = result.error ?? { message: "" };
+  const parts = [];
+  if (error.message) {
+    parts.push(error.message);
+  } else if (result.status) {
+    parts.push(
+      `HTTP ${result.status}${result.statusText ? ` ${result.statusText}` : ""} with no error message (a 404 usually means the table does not exist or is not exposed by the API)`
+    );
+  } else {
+    parts.push("unknown error with no message");
+  }
+  if (error.code) {
+    parts.push(`code ${error.code}`);
+  }
+  const detailsLine = (error.details ?? "").split("\n")[0].trim();
+  if (detailsLine && detailsLine !== error.message) {
+    parts.push(`details: ${detailsLine}`);
+  }
+  if (error.hint) {
+    parts.push(`hint: ${error.hint}`);
+  }
+  return parts.join("; ");
+}
+var SupabaseErrorAdapter = class {
+  /** @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_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: 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 withTimeout(
+        () => this.client.from(this.tableName).insert(row),
+        this.timeoutMs,
+        timeoutMessage("Supabase", this.timeoutMs)
+      );
+      if (result.error) {
+        if (hasCallerId(entry) && result.error.code === "23505") {
+          return { ok: true };
+        }
+        return this.fail(result, describeSupabaseError(result));
+      }
+      return { ok: true };
+    } catch (error) {
+      return this.fail(error, describeError(error));
+    }
+  }
+  fail(logged, reason) {
+    return reportFailure({
+      adapterName: "SupabaseErrorAdapter",
+      prefix: this.prefix,
+      action: `to insert into table "${this.tableName}"`,
+      error: logged,
+      reason
+    });
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CompositeErrorAdapter,
   ConsoleErrorAdapter,
+  FirestoreErrorAdapter,
   FlatFileErrorAdapter,
   IndexedDbErrorAdapter,
   JsonFileErrorAdapter,
   MongoDbErrorAdapter,
   MySqlErrorAdapter,
   PostgresErrorAdapter,
+  RealtimeDatabaseErrorAdapter,
   RedisErrorAdapter,
   S3ErrorAdapter,
   SqliteErrorAdapter,
+  SupabaseErrorAdapter,
   WebStorageErrorAdapter,
   WebhookErrorAdapter,
   buildCreateErrorLogTableSql,
   buildErrorLogTableDdl,
+  buildMySqlWidenColumnsSql,
+  buildSupabaseSetupSql,
   createErrorLogStore,
   formatErrorLogLine,
   serializeCause,