@mushi-mushi/core 1.27.0 → 1.27.2

package/README.md

@@ -138,4 +138,4 @@ MIT
 <!-- mushi-readme-stats-footer -->
 ---
 
-<sub>Monorepo scale (July 2026): 55 edge functions · 328 SQL migrations · 13 outbound plugins · 11 inbound adapters · 19 pipeline agents. Canonical counts: <a href="https://github.com/kensaurus/mushi-mushi/blob/master/docs/stats.md">docs/stats.md</a> · <code>pnpm docs-stats</code></sub>
+<sub>Monorepo scale (July 2026): 55 edge functions · 336 SQL migrations · 13 outbound plugins · 11 inbound adapters · 19 pipeline agents. Canonical counts: <a href="https://github.com/kensaurus/mushi-mushi/blob/master/docs/stats.md">docs/stats.md</a> · <code>pnpm docs-stats</code></sub>

package/dist/index.cjs

@@ -111,6 +111,7 @@ var DEFAULT_TIMEOUT = 1e4;
 var DEFAULT_MAX_RETRIES = 2;
 var DEFAULT_CIRCUIT_THRESHOLD = 4;
 var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
+var MAX_INLINE_RETRY_WAIT_MS = 1e4;
 function createApiClient(options) {
   const {
     projectId,
@@ -185,11 +186,15 @@ function createApiClient(options) {
             `[Mushi] Credentials rejected (HTTP ${response.status}). Check your Project ID and API key scope (must be "report:write"). ` + where
           );
         }
-        if (response.status >= 500 && retries > 0) {
-          await sleep(getBackoffDelay(maxRetries - retries));
+        const rateLimited = response.status === 429;
+        const unusable = response.status >= 500 || rateLimited;
+        const retryAfterMs = rateLimited ? parseRetryAfter(response.headers.get("Retry-After")) : null;
+        const canWaitInline = retryAfterMs === null || retryAfterMs <= MAX_INLINE_RETRY_WAIT_MS;
+        if (unusable && retries > 0 && canWaitInline) {
+          await sleep(retryAfterMs ?? getBackoffDelay(maxRetries - retries));
           return request(method, path, body, retries - 1, internalKind, extraHeaders);
         }
-        if (response.status >= 500) cbRecordUnreachable();
+        if (unusable) cbRecordUnreachable();
         else cbRecordReachable();
         return {
           ok: false,
@@ -207,7 +212,7 @@ function createApiClient(options) {
       clearTimeout(timer);
       if (retries > 0 && isRetryable(error)) {
         await sleep(getBackoffDelay(maxRetries - retries));
-        return request(method, path, body, retries - 1, internalKind);
+        return request(method, path, body, retries - 1, internalKind, extraHeaders);
       }
       cbRecordUnreachable();
       return {
@@ -497,6 +502,16 @@ function sleep(ms) {
 function getBackoffDelay(attempt) {
   return Math.min(1e3 * 2 ** attempt + Math.random() * 500, 1e4);
 }
+function parseRetryAfter(value, now2 = Date.now()) {
+  if (!value) return null;
+  const raw = value.trim();
+  if (!raw) return null;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return seconds < 0 ? null : seconds * 1e3;
+  const at = Date.parse(raw);
+  if (Number.isNaN(at)) return null;
+  return Math.max(at - now2, 0);
+}
 function isRetryable(error) {
   if (error instanceof DOMException && error.name === "AbortError") return true;
   if (error instanceof TypeError) return true;
@@ -1056,12 +1071,27 @@ function openKeyDb() {
   return new Promise((resolve, reject) => {
     const req = indexedDB.open(KEY_DB, 1);
     req.onupgradeneeded = () => {
+      try {
+        const db = req.result;
+        if (!db) return;
+        if (!db.objectStoreNames.contains(KEY_STORE)) {
+          db.createObjectStore(KEY_STORE);
+        }
+      } catch {
+      }
+    };
+    req.onsuccess = () => {
       const db = req.result;
-      if (!db.objectStoreNames.contains(KEY_STORE)) {
-        db.createObjectStore(KEY_STORE);
+      if (!db || !db.objectStoreNames.contains(KEY_STORE)) {
+        try {
+          db?.close();
+        } catch {
+        }
+        reject(new Error("key object store unavailable"));
+        return;
       }
+      resolve(db);
     };
-    req.onsuccess = () => resolve(req.result);
     req.onerror = () => reject(req.error);
   });
 }
@@ -1151,6 +1181,8 @@ function createOfflineQueue(config = {}) {
   let syncCleanup = null;
   let flushInterval = null;
   let backendType = null;
+  let inFlight = null;
+  let followUp = null;
   async function wrapForStorage(report) {
     const queuedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (!encryptAtRest) {
@@ -1204,12 +1236,28 @@ function createOfflineQueue(config = {}) {
     return new Promise((resolve, reject) => {
       const request = indexedDB.open(DB_NAME, DB_VERSION);
       request.onupgradeneeded = () => {
+        try {
+          const db = request.result;
+          if (!db) return;
+          if (!db.objectStoreNames.contains(STORE_NAME)) {
+            db.createObjectStore(STORE_NAME, { keyPath: "id" });
+          }
+        } catch {
+        }
+      };
+      request.onsuccess = () => {
         const db = request.result;
-        if (!db.objectStoreNames.contains(STORE_NAME)) {
-          db.createObjectStore(STORE_NAME, { keyPath: "id" });
+        if (!db || !db.objectStoreNames.contains(STORE_NAME)) {
+          backendType = "localstorage";
+          try {
+            db?.close();
+          } catch {
+          }
+          reject(new Error("queue object store unavailable"));
+          return;
         }
+        resolve(db);
       };
-      request.onsuccess = () => resolve(request.result);
       request.onerror = () => {
         backendType = "localstorage";
         reject(request.error);
@@ -1287,7 +1335,10 @@ function createOfflineQueue(config = {}) {
   }
   async function lsEnqueue(report) {
     const rows = lsRead();
-    rows.push(await wrapForStorage(report));
+    const row = await wrapForStorage(report);
+    const idx = rows.findIndex((r) => r.id === report.id);
+    if (idx >= 0) rows[idx] = row;
+    else rows.push(row);
     lsWrite(rows);
   }
   function lsDelete(id) {
@@ -1326,26 +1377,43 @@ function createOfflineQueue(config = {}) {
       return false;
     }
   }
-  async function enqueue(report) {
-    if (!enabled) return;
-    const currentSize = await size();
-    if (currentSize >= maxQueueSize) {
-      queueLog.warn("Offline queue full \u2014 dropping report", { maxQueueSize });
-      return;
+  async function readRows() {
+    const backend = detectBackend();
+    if (backend === "none") return { backend, rows: [] };
+    if (backend === "indexeddb") {
+      try {
+        return { backend, rows: await idbGetAll() };
+      } catch {
+        backendType = "localstorage";
+      }
     }
+    return { backend: "localstorage", rows: lsRead() };
+  }
+  async function writeRow(report) {
     const backend = detectBackend();
+    if (backend === "none") {
+      queueLog.debug("Offline queue: no storage backend, dropping report", { id: report.id });
+      return backend;
+    }
     if (backend === "indexeddb") {
       try {
         await idbEnqueue(report);
-        return;
+        return backend;
       } catch {
         backendType = "localstorage";
       }
     }
-    if (backend === "localstorage" || backendType === "localstorage") {
-      await lsEnqueue(report);
+    await lsEnqueue(report);
+    return "localstorage";
+  }
+  async function enqueue(report) {
+    if (!enabled) return;
+    const currentSize = await size();
+    if (currentSize >= maxQueueSize) {
+      queueLog.warn("Offline queue full \u2014 dropping report", { maxQueueSize });
       return;
     }
+    await writeRow(report);
   }
   function getBackoffDelay2(attempt) {
     return Math.min(1e3 * 2 ** attempt + Math.random() * 500, MAX_BACKOFF_MS);
@@ -1353,19 +1421,9 @@ function createOfflineQueue(config = {}) {
   function sleep2(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
-  async function flush(client) {
-    if (!enabled) return { sent: 0, failed: 0 };
-    let rows;
-    const backend = detectBackend();
-    if (backend === "indexeddb") {
-      try {
-        rows = await idbGetAll();
-      } catch {
-        rows = lsRead();
-      }
-    } else {
-      rows = lsRead();
-    }
+  async function runFlush(client) {
+    const { backend, rows: storedRows } = await readRows();
+    let rows = storedRows;
     const now2 = Date.now();
     const fresh = [];
     for (const row of rows) {
@@ -1394,59 +1452,84 @@ function createOfflineQueue(config = {}) {
       if (result.ok) {
         await removeRow(backend, rowId);
         sent++;
+        continue;
+      }
+      failed++;
+      if (result.error?.code === "CIRCUIT_OPEN") {
+        queueLog.debug("Offline queue: circuit open, deferring the rest of the batch", {
+          id: rowId,
+          remaining: batch.length - i
+        });
+        break;
+      }
+      const permanent = result.error?.code === "HTTP_400" || result.error?.code === "HTTP_413" || result.error?.code === "HTTP_422" || result.error?.code === "INGEST_ERROR" || result.error?.code === "VALIDATION_ERROR" || // A payload that exceeds the size guard will never shrink on its own;
+      // retrying re-serialises the multi-MB body every sync tick and wedges
+      // the queue (it matches neither permanent nor transient otherwise).
+      // SERIALIZE_FAILED (circular ref) is likewise unrecoverable on retry.
+      result.error?.code === "PAYLOAD_TOO_LARGE" || result.error?.code === "SERIALIZE_FAILED" || typeof result.error?.message === "string" && /invalid payload|description must be at least|validation/i.test(
+        result.error.message
+      );
+      const transient = !permanent && (result.error?.code === "NETWORK_ERROR" || result.error?.code === "HTTP_403" || result.error?.code === "HTTP_429" || result.error?.code === "HTTP_502" || result.error?.code === "HTTP_503" || result.error?.code === "HTTP_504" || typeof result.error?.code === "string" && result.error.code.startsWith("HTTP_5"));
+      if (permanent) {
+        await removeRow(backend, rowId);
       } else {
-        const permanent = result.error?.code === "HTTP_400" || result.error?.code === "HTTP_413" || result.error?.code === "HTTP_422" || result.error?.code === "INGEST_ERROR" || result.error?.code === "VALIDATION_ERROR" || // A payload that exceeds the size guard will never shrink on its own;
-        // retrying re-serialises the multi-MB body every sync tick and wedges
-        // the queue (it matches neither permanent nor transient otherwise).
-        // SERIALIZE_FAILED (circular ref) is likewise unrecoverable on retry.
-        result.error?.code === "PAYLOAD_TOO_LARGE" || result.error?.code === "SERIALIZE_FAILED" || typeof result.error?.message === "string" && /invalid payload|description must be at least|validation/i.test(
-          result.error.message
-        );
-        const transient = !permanent && (result.error?.code === "NETWORK_ERROR" || result.error?.code === "HTTP_403" || result.error?.code === "HTTP_429" || result.error?.code === "HTTP_502" || result.error?.code === "HTTP_503" || result.error?.code === "HTTP_504" || typeof result.error?.code === "string" && result.error.code.startsWith("HTTP_5"));
-        if (permanent) {
+        const nextAttempts = rowAttempts(row) + 1;
+        if (nextAttempts >= MAX_DELIVERY_ATTEMPTS) {
           await removeRow(backend, rowId);
-        } else if (transient) {
-          const nextAttempts = rowAttempts(row) + 1;
-          if (nextAttempts >= MAX_DELIVERY_ATTEMPTS) {
-            await removeRow(backend, rowId);
-            queueLog.warn("Offline queue: giving up on report after repeated failures", {
+          queueLog.warn("Offline queue: giving up on report after repeated failures", {
+            id: rowId,
+            attempts: nextAttempts,
+            code: result.error?.code
+          });
+        } else {
+          row.attempts = nextAttempts;
+          const persisted = await persistRow(backend, row);
+          if (persisted) {
+            queueLog.debug("Offline queue: delivery failed, will retry", {
               id: rowId,
               attempts: nextAttempts,
-              code: result.error?.code
+              code: result.error?.code,
+              classified: transient ? "transient" : "unclassified"
             });
           } else {
-            row.attempts = nextAttempts;
-            const persisted = await persistRow(backend, row);
-            if (persisted) {
-              queueLog.debug("Offline queue: transient failure, will retry", {
-                id: rowId,
-                attempts: nextAttempts,
-                code: result.error?.code
-              });
-            } else {
-              await removeRow(backend, rowId);
-              queueLog.warn("Offline queue: dropping report (attempt counter unpersistable)", {
-                id: rowId,
-                code: result.error?.code
-              });
-            }
+            await removeRow(backend, rowId);
+            queueLog.warn("Offline queue: dropping report (attempt counter unpersistable)", {
+              id: rowId,
+              code: result.error?.code
+            });
           }
         }
-        failed++;
-        if (i < batch.length - 1) {
-          await sleep2(getBackoffDelay2(i));
-        }
+      }
+      if (i < batch.length - 1) {
+        await sleep2(getBackoffDelay2(i));
       }
     }
     return { sent, failed };
   }
+  function flush(client) {
+    if (!enabled) return Promise.resolve({ sent: 0, failed: 0 });
+    if (inFlight) {
+      if (!followUp) {
+        followUp = inFlight.catch(() => void 0).then(() => {
+          followUp = null;
+          return flush(client);
+        });
+      }
+      return followUp;
+    }
+    const pass = runFlush(client).finally(() => {
+      if (inFlight === pass) inFlight = null;
+    });
+    inFlight = pass;
+    return pass;
+  }
   async function size() {
     const backend = detectBackend();
     if (backend === "indexeddb") {
       try {
         return await idbSize();
       } catch {
-        return lsRead().length;
+        backendType = "localstorage";
       }
     }
     return lsRead().length;