mixdog 0.9.16 → 0.9.18

package/src/runtime/channels/backends/discord.mjs

@@ -23,6 +23,14 @@ import { normalizeAccess, safeAttName } from "./discord-access.mjs";
 import { MAX_ATTACHMENT_BYTES, downloadSingleAttachment } from "./discord-attachments.mjs";
 import * as gateway from "./discord-gateway.mjs";
 const MAX_CHUNK_LIMIT = MAX_DISCORD_MESSAGE;
+// Per-attempt cap for a single discord.js fetch/send. Without it a wedged
+// socket (network blip, "other side closed") leaves the await pending forever,
+// which upstream leaves the forwarder's `sending` flag stuck and silences all
+// outbound. On timeout we treat the client as dead and reset+reconnect it.
+const SEND_ATTEMPT_TIMEOUT_MS = 30_000;
+// After a timed-out send is reset, cap how long we wait for the original
+// (abandoned) promise to actually settle before giving up with unknown outcome.
+const SETTLE_CAP_MS = 15_000;
 const RECENT_SENT_CAP = 200;
 class DiscordBackend {
   name = "discord";
@@ -74,11 +82,57 @@ class DiscordBackend {
     if (this.client) this.client.destroy();
     this._connectPromise = null;
   }
+  // ── Self-heal helpers ──────────────────────────────────────────────
+  /** Race a discord.js op-promise against a per-attempt timeout so a wedged
+   *  socket can't hang the outbound path. On timeout the rejection carries
+   *  `_timeout` so the caller knows the underlying op is still in flight (and
+   *  must be settled/adopted, not blindly retried → duplicate). */
+  _withTimeout(promise, label) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        const e = new Error(`${label} timed out after ${SEND_ATTEMPT_TIMEOUT_MS}ms`);
+        e._timeout = true;
+        reject(e);
+      }, SEND_ATTEMPT_TIMEOUT_MS);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+  }
+  /** True when an error means the client is dead (aborted, "other side
+   *  closed", or our per-attempt timeout) and must be reset+reconnected. */
+  _shouldResetClient(err) {
+    if (err?.name === "AbortError" || err?.code === "ABORT_ERR") return true;
+    const msg = String(err?.message || err || "").toLowerCase();
+    return msg.includes("aborted") || msg.includes("other side closed") ||
+      msg.includes("socket hang up") || msg.includes("econnreset") || msg.includes("timed out");
+  }
+  /** Destroy the wedged client and rebuild it via connect() so the next
+   *  fetch/send (and the forwarder's queue-head-preserving retry) hits a fresh
+   *  gateway/REST client. Serialized behind a single in-flight reset so
+   *  concurrent callers await the SAME reconnect instead of racing multiple
+   *  destroy()/login() cycles. */
+  async _resetClient() {
+    if (this._resetPromise) return this._resetPromise;
+    this._resetPromise = (async () => {
+      try { this.client?.destroy?.(); } catch {}
+      this.client = null;
+      this._connectPromise = null;
+      await this.connect();
+    })().finally(() => { this._resetPromise = null; });
+    return this._resetPromise;
+  }
+  /** Health-check the gateway; reset+reconnect if the ws is not READY. Called
+   *  by the owner re-claim self-heal path. (discord.js Status.Ready === 0) */
+  async healthCheck() {
+    if (this.client && this.client.ws?.status === 0) return;
+    await this._resetClient();
+  }
   resetSendCount() {
     this.sendCount = 0;
   }
   startTyping(channelId) {
     this.stopTyping(channelId);
+    if (!this.client) return;
     const ch = this.client.channels.cache.get(channelId);
     if (ch && "sendTyping" in ch) {
       void ch.sendTyping().catch(() => {
@@ -172,13 +226,38 @@ class DiscordBackend {
         // resumes at this chunk index instead of re-sending 0..i-1.
         let attempt = 0;
         for (;;) {
+          const sendPromise = ch.send(payload);
           try {
-            const sent = await ch.send(payload);
+            const sent = await this._withTimeout(sendPromise, "discord send");
             this.noteSent(sent.id);
             sentIds.push(sent.id);
             break;
           } catch (err) {
             attempt++;
+            if (err?._timeout) {
+              // Watchdog abandoned the send but the socket may still deliver.
+              // Destroy the client to tear down the in-flight REST socket so the
+              // ORIGINAL promise settles, then AWAIT + adopt its real outcome:
+              // delivered → done (no retry → no duplicate); else requeue against
+              // the fresh client via a resume token.
+              try { await this._resetClient(); } catch {}
+              // Cap the settlement wait: destroy() should abort the in-flight
+              // socket, but never hang here if it doesn't. On unknown outcome
+              // throw retryable (duplicate risk accepted over a permanent hang).
+              sendPromise.catch(() => {}); // swallow a late rejection
+              const settled = await Promise.race([
+                sendPromise.then((v) => ({ ok: true, v }), () => ({ ok: false })),
+                new Promise((r) => setTimeout(() => r({ ok: false }), SETTLE_CAP_MS))
+              ]);
+              if (settled.ok) {
+                this.noteSent(settled.v.id);
+                sentIds.push(settled.v.id);
+                break;
+              }
+              const e = err instanceof Error ? err : new Error(String(err));
+              e.resumeToken = { hash: contentHash, nextChunkIdx: i, sentIds: [...sentIds], prefixed: applyPrefix, limit };
+              throw e;
+            }
             const status = err?.status ?? err?.code ?? err?.httpStatus;
             // Classify: PERMANENT = a 4xx client error (unknown channel/message,
             // missing access/permissions, 404 …) that will never succeed on
@@ -192,7 +271,15 @@ class DiscordBackend {
               e.permanent = true;
               throw e;
             }
-            if (attempt >= 3) {
+            // Dead client (abort / "other side closed" / per-attempt timeout):
+            // destroy + reconnect so the forwarder's transient-retry path hits a
+            // fresh client, and throw a resume token now instead of burning the
+            // remaining attempts on a stale channel handle bound to the old client.
+            const dead = this._shouldResetClient(err);
+            if (dead) {
+              try { await this._resetClient(); } catch {}
+            }
+            if (dead || attempt >= 3) {
               // Attach an opaque resume token pointing at the chunk that failed
               // (i). sentIds holds every chunk already delivered (including any
               // seeded from a prior token).
@@ -301,13 +388,13 @@ class DiscordBackend {
     const msg = await ch.messages.fetch(messageId);
     await msg.delete();
   }
-  async downloadAttachment(chatId, messageId) {
+  async downloadAttachment(chatId, messageId, opts = {}) {
     const ch = await this.fetchAllowedChannel(chatId);
     const msg = await ch.messages.fetch(messageId);
     if (msg.attachments.size === 0) return [];
     const results = [];
     for (const att of msg.attachments.values()) {
-      const path = await this.downloadSingleAttachment(att);
+      const path = await this.downloadSingleAttachment(att, opts);
       results.push({
         id: att.id,
         path,
@@ -526,7 +613,10 @@ class DiscordBackend {
   }
   // ── Channel helpers ────────────────────────────────────────────────
   async fetchTextChannel(id) {
-    const ch = await this.client.channels.fetch(id);
+    if (!this.client) await this.connect();
+    const p = this.client.channels.fetch(id);
+    p.catch(() => {}); // if the watchdog wins, don't leak an unhandled rejection
+    const ch = await this._withTimeout(p, "discord channels.fetch");
     if (!ch || !ch.isTextBased()) {
       throw new Error(`channel ${id} not found or not text-based`);
     }
@@ -571,8 +661,8 @@ class DiscordBackend {
       throw new Error(`refusing to send channel state: ${f}`);
     }
   }
-  async downloadSingleAttachment(att) {
-    return downloadSingleAttachment(att, this.inboxDir);
+  async downloadSingleAttachment(att, opts = {}) {
+    return downloadSingleAttachment(att, this.inboxDir, opts);
   }
 }
 export {

package/src/runtime/channels/index.mjs

@@ -305,6 +305,11 @@ const forwarder = new OutputForwarder({
   removeReaction: (ch, mid, emoji) => {
     if (!channelBridgeActive) return Promise.resolve();
     return backend.removeReaction(ch, mid, emoji);
+  },
+  // Watchdog backstop: force the backend to tear down + rebuild a wedged
+  // client so an over-budget send fails fast and the queue releases.
+  resetBackend: async () => {
+    if (typeof backend?._resetClient === "function") await backend._resetClient();
   }
 }, statusState);
 forwarder.setOnIdle(() => {
@@ -323,7 +328,11 @@ forwarder.setOnIdle(() => {
 forwarder.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
 function applyTranscriptBinding(channelId, transcriptPath, options = {}) {
   if (!transcriptPath) return;
-  forwarder.setContext(channelId, transcriptPath, { replayFromStart: options.replayFromStart, catchUpFromPersisted: options.catchUpFromPersisted });
+  forwarder.setContext(channelId, transcriptPath, {
+    replayFromStart: options.replayFromStart,
+    catchUpFromPersisted: options.catchUpFromPersisted,
+    recoverUnsyncedTail: options.recoverUnsyncedTail,
+  });
   const boundTranscriptPath = forwarder.transcriptPath || transcriptPath;
   forwarder.startWatch();
   void memoryIngestTranscript(boundTranscriptPath, { cwd: options.cwd });
@@ -336,14 +345,31 @@ function applyTranscriptBinding(channelId, transcriptPath, options = {}) {
   refreshActiveInstance(INSTANCE_ID, { channelId, transcriptPath: boundTranscriptPath }, { onlyIfOwned: true });
   if (options.persistStatus !== false) {
     statusState.update((state) => {
+      const wasSameTranscript = typeof state.transcriptPath === "string"
+        && state.transcriptPath
+        && sameResolvedPath(state.transcriptPath, boundTranscriptPath);
+      const prevSentCount = Number(state.sentCount ?? 0);
+      const nextSentCount = Number(forwarder.sentCount ?? 0);
       state.channelId = channelId;
       state.transcriptPath = boundTranscriptPath;
       state.lastFileSize = forwarder.lastFileSize;
-      state.sentCount = forwarder.sentCount;
-      state.lastSentHash = forwarder.lastHash;
-      state.lastSentTime = 0;
-      state.sessionIdle = false;
-      state.sessionCwd = options.cwd ?? null;
+      if (wasSameTranscript) {
+        state.sentCount = Math.max(
+          Number.isFinite(prevSentCount) ? prevSentCount : 0,
+          Number.isFinite(nextSentCount) ? nextSentCount : 0,
+        );
+        if (forwarder.lastHash) state.lastSentHash = forwarder.lastHash;
+        else if (typeof state.lastSentHash !== "string") state.lastSentHash = "";
+        if (!Number.isFinite(Number(state.lastSentTime))) state.lastSentTime = 0;
+        if (typeof state.sessionIdle !== "boolean") state.sessionIdle = false;
+      } else {
+        state.sentCount = forwarder.sentCount;
+        state.lastSentHash = forwarder.lastHash;
+        state.lastSentTime = 0;
+        state.sessionIdle = false;
+      }
+      if (options.cwd !== undefined) state.sessionCwd = options.cwd ?? null;
+      else if (!wasSameTranscript) state.sessionCwd = null;
     });
   }
 }
@@ -421,7 +447,8 @@ async function rebindTranscriptContext(channelId, options = {}) {
       applyTranscriptBinding(channelId, explicitTranscriptPath, {
         replayFromStart: Boolean(options.catchUp),
         catchUpFromPersisted: options.catchUpFromPersisted,
-        persistStatus: options.persistStatus
+        persistStatus: options.persistStatus,
+        recoverUnsyncedTail: options.recoverUnsyncedTail,
       });
       if (options.catchUp || options.catchUpFromPersisted) {
         await forwarder.forwardNewText();
@@ -452,6 +479,7 @@ async function rebindTranscriptContext(channelId, options = {}) {
         applyTranscriptBinding(channelId, bound.transcriptPath, {
           replayFromStart,
           catchUpFromPersisted: options.catchUpFromPersisted,
+          recoverUnsyncedTail: options.recoverUnsyncedTail,
           persistStatus: options.persistStatus,
           cwd: bound.sessionCwd,
         });
@@ -497,6 +525,7 @@ async function rebindTranscriptContext(channelId, options = {}) {
       applyTranscriptBinding(channelId, pendingTranscriptPath, {
         replayFromStart: !samePersisted,
         catchUpFromPersisted: samePersisted,
+        recoverUnsyncedTail: options.recoverUnsyncedTail,
         cwd: pendingTranscriptCwd,
         persistStatus: options.persistStatus,
       });
@@ -512,7 +541,11 @@ async function rebindTranscriptContext(channelId, options = {}) {
     }
   }
   if (previousPath && options.fallbackPrevious !== false) {
-    applyTranscriptBinding(channelId, previousPath, { catchUpFromPersisted: true, cwd: statusState.read().sessionCwd });
+    applyTranscriptBinding(channelId, previousPath, {
+      catchUpFromPersisted: true,
+      recoverUnsyncedTail: options.recoverUnsyncedTail,
+      cwd: statusState.read().sessionCwd
+    });
     if (fs.existsSync(previousPath)) {
       await forwarder.forwardNewText();
     } else {
@@ -631,7 +664,8 @@ async function bindPersistedTranscriptIfAny() {
   const bound = await rebindTranscriptContext(currentStatus.channelId, {
     previousPath: getPersistedTranscriptPath(),
     persistStatus: true,
-    catchUpFromPersisted: true
+    catchUpFromPersisted: true,
+    recoverUnsyncedTail: true,
   });
   if (bound) {
     process.stderr.write(`mixdog: initial transcript bind: ${bound}
@@ -710,8 +744,40 @@ function syncOwnedWebhookAndEventRuntime({ reload = false } = {}) {
     webhookServer = null;
   }
 }
+let _ownedRuntimeSelfHealing = false;
+// Explicit restore path for an already-connected owner. The 3s ownership tick
+// must not run this implicitly: re-binding status on every tick can move the
+// transcript cursor to EOF, and probing the gateway during Discord's own
+// reconnect window can reset a healthy reconnect loop. Keep this for explicit
+// activation/reload recovery only.
+async function selfHealOwnedRuntime(options = {}) {
+  const shouldRestoreBinding = options.restoreBinding === true;
+  const shouldResetBackend = options.resetBackend === true;
+  if (!shouldRestoreBinding && !shouldResetBackend) return;
+  if (_ownedRuntimeSelfHealing) return;
+  _ownedRuntimeSelfHealing = true;
+  try {
+    if (shouldRestoreBinding) {
+      await bindPersistedTranscriptIfAny().catch((e) => {
+        process.stderr.write(`mixdog: self-heal bindPersistedTranscriptIfAny failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
+      });
+    }
+    if (shouldResetBackend && typeof backend?._resetClient === "function") {
+      await backend._resetClient().catch((e) => {
+        process.stderr.write(`mixdog: self-heal backend reset failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
+      });
+    }
+    // Nudge the forwarder to drain anything the rebind/reconnect surfaced.
+    void forwarder.forwardNewText().catch(() => {});
+  } finally {
+    _ownedRuntimeSelfHealing = false;
+  }
+}
 async function startOwnedRuntime(options = {}) {
-  if (bridgeRuntimeConnected) return;
+  if (bridgeRuntimeConnected) {
+    if (!bridgeRuntimeStarting) await selfHealOwnedRuntime(options);
+    return;
+  }
   if (bridgeRuntimeStarting) return;
   if (!channelBridgeActive) return;
   bridgeRuntimeStarting = true;
@@ -928,8 +994,13 @@ async function refreshBridgeOwnership(options = {}) {
     if (active && active.instanceId && active.instanceId !== INSTANCE_ID) {
       if (bridgeRuntimeConnected) {
         await stopOwnedRuntime("ownership lost (newer remote session)");
-        notifyRemoteSuperseded();
       }
+      // Notify the parent UNCONDITIONALLY (not only when we were connected):
+      // a loser whose backend never connected (seat stolen mid-connect,
+      // connect failed, or already in standby) must still drop its Remote
+      // indicator. The parent handler is idempotent — it only acts while
+      // remoteEnabled is still true — so repeat ticks are harmless.
+      notifyRemoteSuperseded();
       return;
     }
     // No live owner — claim the empty seat and start.
@@ -1658,6 +1729,26 @@ backend.onMessage = (msg) => {
     });
   })();
 };
+const NETWORK_ERR_RE = /fetch failed|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|network|timeout|aborted|TimeoutError/i;
+function isNetworkError(err) {
+  const s = `${err?.code ?? ""} ${err?.name ?? ""} ${err?.message ?? err ?? ""}`;
+  return NETWORK_ERR_RE.test(s);
+}
+async function retryOnNetwork(fn, { attempts = 3, baseDelayMs = 300, label = "op" } = {}) {
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i === attempts - 1 || !isNetworkError(err)) throw err;
+      const delay = baseDelayMs * (i + 1);
+      process.stderr.write(`mixdog: ${label} network failure (attempt ${i + 1}/${attempts}), retrying in ${delay}ms: ${err?.message || err}\n`);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastErr;
+}
 async function handleInbound(msg, route, options = {}) {
   const handleStartMs = Date.now();
   let text = msg.text;
@@ -1668,11 +1759,19 @@ async function handleInbound(msg, route, options = {}) {
       text = text || "[voice message]";
     } else {
       try {
-        const files = await backend.downloadAttachment(msg.chatId, msg.messageId);
+        const files = await retryOnNetwork(
+          // Short per-attempt timeout (vs the 180s default) bounds worst-case
+          // blockage of the serial inboundQueue on a bad voice message.
+          () => backend.downloadAttachment(msg.chatId, msg.messageId, { timeoutMs: 20_000 }),
+          { label: "voice.download" }
+        );
         // concurrency handled inside transcribeVoice queue; loop is sequential so last att wins
         for (const f of voiceAtts.map(a => files.find(df => df.id === a.id) ?? null).filter(Boolean)) {
           const _t0 = Date.now();
-          const transcript = await transcribeVoice(f.path, { attachmentId: f.id });
+          const transcript = await retryOnNetwork(
+            () => transcribeVoice(f.path, { attachmentId: f.id }),
+            { label: "voice.transcription" }
+          );
           const _elapsed = Date.now() - _t0;
           if (transcript) {
             text = transcript;
@@ -1683,8 +1782,12 @@ async function handleInbound(msg, route, options = {}) {
           }
         }
       } catch (err) {
-        process.stderr.write(`mixdog: voice.transcription error: ${err}\n`);
-        text = text || `[voice message \u2014 transcription error: ${err?.message || err}]`;
+        const netFail = isNetworkError(err);
+        process.stderr.write(`mixdog: voice.transcription error${netFail ? " (network, retries exhausted)" : ""}: ${err}\n`);
+        const marker = netFail
+          ? "[attachment: voice transcription failed (network)]"
+          : `[voice message \u2014 transcription error: ${err?.message || err}]`;
+        text = text ? `${text} ${marker}` : marker;
       }
     }
   }
@@ -1953,15 +2056,39 @@ if (_isWorkerMode && process.send) {
   })
   void (async () => {
     const startedAt = performance.now()
-    try {
-      await start()
-      bootProfile("worker:ready", { ms: (performance.now() - startedAt).toFixed(1) })
-      process.send({ type: 'ready' })
-    } catch (e) {
-      bootProfile("worker:failed", { ms: (performance.now() - startedAt).toFixed(1), error: e?.message || String(e) })
-      process.stderr.write(`[channels-worker] start() failed: ${e && (e.message || e)}\n`)
-      process.send({ type: 'ready', degraded: true, error: e?.message || String(e) })
+    const MAX_START_ATTEMPTS = 3
+    const BASE_BACKOFF_MS = 250
+    const isTransientStartErr = (err) =>
+      err?.code === 'ELOCKTIMEOUT' || /atomic lock timeout/i.test(err?.message || '')
+    let lastErr
+    for (let attempt = 1; attempt <= MAX_START_ATTEMPTS; attempt++) {
+      if (_channelsStopInFlight) return
+      try {
+        await start()
+        bootProfile("worker:ready", { ms: (performance.now() - startedAt).toFixed(1), attempt })
+        process.send({ type: 'ready' })
+        return
+      } catch (e) {
+        lastErr = e
+        const transient = isTransientStartErr(e)
+        bootProfile("worker:start-failed", { attempt, transient, error: e?.message || String(e) })
+        process.stderr.write(`[channels-worker] start() failed (attempt ${attempt}/${MAX_START_ATTEMPTS}, transient=${transient}): ${e && (e.message || e)}\n`)
+        if (!transient || attempt >= MAX_START_ATTEMPTS) break
+        const backoff = BASE_BACKOFF_MS * attempt + Math.floor(Math.random() * BASE_BACKOFF_MS)
+        await new Promise((r) => setTimeout(r, backoff))
+        if (_channelsStopInFlight) return
+      }
     }
+    // A stop landed while we were failing — let clean shutdown proceed, never exit over it.
+    if (_channelsStopInFlight) return
+    // Terminal failure: do NOT mask as a (degraded) ready. Exit non-zero so the
+    // parent's exit-before-ready path respawns or rejects startRemote instead of
+    // silently losing remote output forwarding.
+    bootProfile("worker:failed", { ms: (performance.now() - startedAt).toFixed(1), error: lastErr?.message || String(lastErr) })
+    process.stderr.write(`[channels-worker] start() giving up after ${MAX_START_ATTEMPTS} attempts: ${lastErr && (lastErr.message || lastErr)}\n`)
+    // Exit 2 = terminal (non-transient) start failure: parent must reject, not respawn.
+    // Exit 1 = exhausted transient retries: parent may respawn.
+    process.exit(isTransientStartErr(lastErr) ? 1 : 2)
   })()
 }
 

package/src/runtime/channels/lib/crash-log.mjs

@@ -86,15 +86,33 @@ ${err instanceof Error ? err.stack : ""}
 // already retried elsewhere (atomic-file.mjs RETRY_CODES) — a single
 // occurrence must NOT be fatal, only a run of 3+ in a row without an
 // intervening distinct/successful event.
-const BENIGN_CRASH_CODES = new Set(["EPERM", "EACCES", "EBUSY"]);
+const BENIGN_CRASH_CODES = new Set([
+  "EPERM", "EACCES", "EBUSY",
+  // Transient transport blips: a raw http/https ClientRequest (or an
+  // undici socket) can emit these when a keep-alive connection is torn
+  // down mid-flight (Discord gateway flapping, proxy resets). One blip
+  // must NOT kill the worker — it is benign; only a repeat storm within
+  // the streak window force-exits (see _fatalCrash).
+  "ECONNRESET", "ETIMEDOUT", "ECONNREFUSED", "EPIPE", "EHOSTUNREACH",
+  "ENETUNREACH", "ENETDOWN", "EAI_AGAIN", "ERR_STREAM_PREMATURE_CLOSE",
+  "UND_ERR_SOCKET", "UND_ERR_CONNECT_TIMEOUT", "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT", "UND_ERR_ABORTED",
+]);
+// Some transient socket errors arrive with no `.code` (notably the classic
+// "socket hang up" thrown by node:_http_client socketOnEnd — the exact crash
+// this guard exists for). Match those by message so they classify benign too.
+const BENIGN_CRASH_MESSAGE_RE = /socket hang up|ECONNRESET|ETIMEDOUT|EPIPE|UND_ERR_/i;
 const BENIGN_CRASH_FATAL_THRESHOLD = 3;
 // "In a row" needs a time dimension: benign errors minutes/hours apart are
 // independent contention events, not a corrupted-state run. Only count a
 // streak when hits land within this window of the previous one.
 const BENIGN_CRASH_STREAK_WINDOW_MS = 60_000;
 function _isBenignCrash(err) {
-  const code = err?.code || (/\b(EPERM|EACCES|EBUSY)\b/.exec(String(err?.message || err)) || [])[0];
-  return BENIGN_CRASH_CODES.has(code);
+  const msg = String(err?.message || err);
+  const code = err?.code
+    || (/\b(EPERM|EACCES|EBUSY|ECONNRESET|ETIMEDOUT|ECONNREFUSED|EPIPE|EHOSTUNREACH|ENETUNREACH|ENETDOWN|EAI_AGAIN|UND_ERR_[A-Z_]+)\b/.exec(msg) || [])[0];
+  if (BENIGN_CRASH_CODES.has(code)) return true;
+  return BENIGN_CRASH_MESSAGE_RE.test(msg);
 }
 
 export {