@debugg-ai/debugg-ai-mcp 4.3.0 → 4.4.1

package/dist/services/tunnel/protocol/stream.js

@@ -0,0 +1,109 @@
+/**
+ * Debugg tunnel wire protocol v1 — one multiplexed stream as a node Duplex.
+ *
+ * A TunnelStream is the byte pipe for exactly one inbound browser connection.
+ * Both ends pipe it straight at a socket, so being a real Duplex (and honouring
+ * backpressure in both directions) is the whole point:
+ *
+ *   server:  socket.pipe(stream).pipe(socket)
+ *   client:  stream.pipe(net.connect(caddyLoopbackPort)).pipe(stream)
+ *
+ * Writes become DATA frames of at most MAX_DATA_PAYLOAD, gated by the stream's
+ * remaining credit. end() sends END. destroy() sends RST.
+ *
+ * All protocol state lives in the session; this class only forwards. The one
+ * piece of cleverness is the read() override, which is how the session learns
+ * how many bytes the application has actually consumed and therefore how much
+ * credit it may give back.
+ */
+import { Duplex } from 'node:stream';
+import { ErrorCode, MAX_DATA_PAYLOAD } from './constants.js';
+export class TunnelStream extends Duplex {
+    /** The stream id the server allocated. */
+    id;
+    /**
+     * Whitelisted OPEN metadata. Informational only — NEVER a dial target
+     * (see the SSRF note on bead debugg_ai_mcp-xkoh.1.2).
+     */
+    metadata;
+    host;
+    pendingResetCode;
+    pushedTotal = 0;
+    reportedConsumed = 0;
+    constructor(options) {
+        super({
+            // One frame's worth of writable buffer: enough to keep the wire busy,
+            // little enough that a piped producer is held back rather than drained.
+            writableHighWaterMark: MAX_DATA_PAYLOAD,
+            readableHighWaterMark: MAX_DATA_PAYLOAD,
+            allowHalfOpen: true,
+        });
+        this.id = options.id;
+        this.metadata = options.metadata;
+        this.host = options.host;
+    }
+    /**
+     * Abort both directions with RST(code). Defaults to ErrorCode.RESET. Use
+     * ErrorCode.UPSTREAM_UNREACHABLE when the local target could not be dialled,
+     * so the server can render DEBUGG_TUNNEL_UPSTREAM_REFUSED.
+     *
+     * Deliberately does not raise a local 'error': the side that chose to reset
+     * already knows, and an unhandled 'error' on a Duplex throws.
+     */
+    reset(code = ErrorCode.RESET) {
+        this.pendingResetCode = code;
+        this.destroy();
+    }
+    /**
+     * Hand the session's inbound bytes to the readable side.
+     *
+     * Never call push() directly: in flowing mode node delivers a pushed chunk
+     * straight to the 'data' listener without it ever entering the buffer or going
+     * through read(), so consumption has to be reconciled right here. Missing it
+     * means credit is never returned and a transfer larger than one window
+     * deadlocks — which is exactly what it did.
+     */
+    deliver(chunk) {
+        this.pushedTotal += chunk.length;
+        const accepted = this.push(chunk);
+        this.syncConsumed();
+        return accepted;
+    }
+    /** The peer half-closed: no more inbound bytes on this stream. */
+    deliverEnd() {
+        this.push(null);
+    }
+    /**
+     * Bytes that have left the readable buffer are bytes the application consumed,
+     * and those are what the session may grant back as WINDOW. Credit is never
+     * given for bytes still sitting in the buffer.
+     */
+    syncConsumed() {
+        const consumed = this.pushedTotal - this.readableLength;
+        const delta = consumed - this.reportedConsumed;
+        if (delta <= 0)
+            return;
+        this.reportedConsumed = consumed;
+        this.host.streamConsumed(this, delta);
+    }
+    read(size) {
+        const chunk = super.read(size);
+        this.syncConsumed();
+        return chunk;
+    }
+    _read() {
+        // Nothing to pull: the session pushes as DATA frames arrive, and flow
+        // control — not this callback — is what limits how much can be in flight.
+    }
+    _write(chunk, encoding, cb) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+        this.host.streamWrite(this, buf, cb);
+    }
+    _final(cb) {
+        this.host.streamFinal(this, cb);
+    }
+    _destroy(err, cb) {
+        this.host.streamDestroy(this, err, this.pendingResetCode);
+        cb(err);
+    }
+}

package/dist/services/tunnel/protocol/transport.js

@@ -0,0 +1,106 @@
+/**
+ * Debugg tunnel wire protocol v1 — transport seam.
+ *
+ * TunnelSession never touches a websocket directly. It talks to a FrameTransport,
+ * which is what lets the unit tests drive a session frame by frame (and with fake
+ * timers) while the integration tests run the same session over a real `ws`
+ * socket. `ws` is referenced only structurally here, so this module keeps its
+ * "node: built-ins only" property and stays embeddable in the tunnel server.
+ */
+/** RFC 6455: the connection dropped without a close handshake. */
+const ABNORMAL_CLOSURE = 1006;
+/** ws hands out Buffer, ArrayBuffer, or an array of Buffers for a fragmented message. */
+function toBytes(data) {
+    if (Buffer.isBuffer(data))
+        return data;
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (ArrayBuffer.isView(data))
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    if (Array.isArray(data) && data.every((part) => Buffer.isBuffer(part)))
+        return Buffer.concat(data);
+    return undefined;
+}
+function reasonToString(reason) {
+    if (typeof reason === 'string')
+        return reason;
+    if (Buffer.isBuffer(reason))
+        return reason.toString('utf8');
+    if (reason instanceof ArrayBuffer)
+        return Buffer.from(reason).toString('utf8');
+    return '';
+}
+/**
+ * Adapt a ws WebSocket (client or server side) to a FrameTransport.
+ *
+ * Responsibilities: normalise inbound data to a Uint8Array, reject text messages
+ * as invalid, and make sure the session is told exactly once that the socket is
+ * gone — whichever of 'close' and 'error' happens to fire, and in whichever
+ * order.
+ */
+export function webSocketTransport(ws) {
+    let handlers;
+    let closed = false;
+    let socketError;
+    const reportClose = (code, reason) => {
+        if (closed)
+            return;
+        closed = true;
+        handlers?.onClose(code, reason);
+    };
+    return {
+        send(frame, cb) {
+            if (closed) {
+                cb(new Error('websocket is closed'));
+                return;
+            }
+            try {
+                ws.send(frame, (err) => cb(err ?? null));
+            }
+            catch (err) {
+                cb(err);
+            }
+        },
+        close(code, reason) {
+            try {
+                ws.close(code, reason);
+            }
+            catch {
+                /* already closing; the close event still settles the session */
+            }
+        },
+        terminate() {
+            try {
+                ws.terminate();
+            }
+            catch {
+                /* nothing left to tear down */
+            }
+        },
+        setHandlers(next) {
+            handlers = next;
+            ws.on('message', (data, isBinary) => {
+                if (closed)
+                    return;
+                if (!isBinary) {
+                    next.onInvalidMessage('text message');
+                    return;
+                }
+                const bytes = toBytes(data);
+                if (!bytes) {
+                    next.onInvalidMessage('message was not binary data');
+                    return;
+                }
+                next.onFrame(bytes);
+            });
+            ws.on('error', (err) => {
+                // ws emits 'close' after 'error' for a live socket, so hold the reason
+                // and let the close path report it — unless no close ever arrives.
+                socketError = err;
+            });
+            ws.on('close', (code, reason) => {
+                reportClose(code || ABNORMAL_CLOSURE, reasonToString(reason) || socketError?.message || '');
+            });
+        },
+    };
+}

package/dist/services/tunnel/transport.js

@@ -0,0 +1,15 @@
+/**
+ * TunnelTransport — the one step of tunnel creation that differs between ngrok
+ * and the debugg tunnel server.
+ *
+ * STUB (bead debugg_ai_mcp-xkoh.5.3, phase 2.1). Types and signatures only; the
+ * implementations arrive in phase 4.1 (debugg_ai_mcp-xkoh.5.7).
+ *
+ * Everything above this seam is unchanged: handlers, utils/tunnelContext.ts,
+ * the per-session Caddy instance, PortLock, URL rewriting, the retry ladder,
+ * the idle timer and the session keying all behave exactly as they do today
+ * (docs/debugg-tunnel-server-design-2026-09-19.md §5). TunnelManager picks an
+ * implementation from the provision response and calls it where it calls
+ * ngrok.connect() today.
+ */
+export {};

package/dist/services/tunnels.js

@@ -4,6 +4,7 @@
  * Called before executeWorkflow so the tunnel URL is known before execution starts.
  */
 import { Telemetry, TelemetryEvents } from '../utils/telemetry.js';
+import { isValidTunnelDomain, registerTunnelDomain, } from '../utils/tunnelDomains.js';
 /**
  * Typed error thrown by provision() when the backend/ngrok path fails.
  * Carries diagnostic fields a retry wrapper (bead 7nx) can use to decide
@@ -80,11 +81,29 @@ export function classifyProvisionError(err) {
 }
 const DEFAULT_BACKOFF_MS = [500, 1500, 3000];
 const DEFAULT_MAX_ATTEMPTS = 3;
+/** The transports this client can actually drive, best first. */
+export const SUPPORTED_TRANSPORTS = Object.freeze(['debugg', 'ngrok']);
+/** A relay URL must be wss, except against a loopback backend (local dev, tests). */
+function isAcceptableRelayUrl(relayUrl) {
+    let url;
+    try {
+        url = new URL(relayUrl);
+    }
+    catch {
+        return false;
+    }
+    if (url.protocol === 'wss:')
+        return true;
+    if (url.protocol !== 'ws:')
+        return false;
+    const host = url.hostname.replace(/^\[|\]$/g, '').toLowerCase();
+    return host === 'localhost' || host === '127.0.0.1' || host === '::1';
+}
 export const createTunnelsService = (tx) => {
     async function provision(purpose = 'workflow') {
         let response;
         try {
-            response = await tx.post('api/v1/tunnels/', { purpose });
+            response = await tx.post('api/v1/tunnels/', { purpose, transports: [...SUPPORTED_TRANSPORTS] });
         }
         catch (err) {
             throw classifyProvisionError(err);
@@ -95,12 +114,61 @@ export const createTunnelsService = (tx) => {
                 retryable: false,
             });
         }
-        return {
+        // No `transport` means an old backend that predates negotiation, which only
+        // ever hands out ngrok keys.
+        const transport = (response.transport ?? 'ngrok');
+        if (!SUPPORTED_TRANSPORTS.includes(transport)) {
+            throw new TunnelProvisionError({
+                message: `Tunnel provisioning selected transport "${response.transport}", which this client cannot speak ` +
+                    `(it offered ${SUPPORTED_TRANSPORTS.join(', ')}). Update @debugg-ai/debugg-ai-mcp.`,
+                retryable: false,
+            });
+        }
+        const result = {
             tunnelId: response.tunnelId,
             tunnelKey: response.tunnelKey,
             keyId: response.keyId,
             expiresAt: response.expiresAt,
+            transport,
         };
+        if (transport === 'debugg') {
+            // Every one of these is non-retryable: retrying cannot turn a malformed
+            // response into a usable one, and TunnelManager must never be handed a
+            // debugg token with nowhere to send it.
+            if (!response.relayUrl || !response.tunnelDomain) {
+                throw new TunnelProvisionError({
+                    message: 'Tunnel provisioning selected the debugg transport but omitted relayUrl or tunnelDomain',
+                    retryable: false,
+                });
+            }
+            if (!isAcceptableRelayUrl(response.relayUrl)) {
+                throw new TunnelProvisionError({
+                    message: `Tunnel provisioning returned a relayUrl that is not wss (${response.relayUrl}); ` +
+                        'refusing to send the tunnel key over it',
+                    retryable: false,
+                });
+            }
+            if (!isValidTunnelDomain(response.tunnelDomain)) {
+                throw new TunnelProvisionError({
+                    message: `Tunnel provisioning returned an unusable tunnelDomain (${response.tunnelDomain})`,
+                    retryable: false,
+                });
+            }
+            // Registering it here is what stops a tunnel URL leaking: everything that
+            // recognises or rewrites a tunnel hostname reads this same registry, so a
+            // domain the backend moves to is covered the moment it is handed to us.
+            registerTunnelDomain(response.tunnelDomain, 'debugg');
+            result.relayUrl = response.relayUrl;
+            result.tunnelDomain = response.tunnelDomain;
+        }
+        return result;
+    }
+    async function revoke(provisionInfo) {
+        if (provisionInfo.transport === 'debugg') {
+            await tx.post(`api/v1/tunnels/${provisionInfo.tunnelId}/revoke/`, {});
+            return;
+        }
+        await tx.post('api/v1/ngrok/revoke/', { ngrokKeyId: provisionInfo.keyId });
     }
     async function provisionWithRetry(opts = {}) {
         const maxAttempts = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
@@ -144,5 +212,5 @@ export const createTunnelsService = (tx) => {
             retryable: false,
         });
     }
-    return { provision, provisionWithRetry };
+    return { provision, provisionWithRetry, revoke };
 };

package/dist/utils/localReachability.js

@@ -17,6 +17,8 @@ import { createConnection } from 'node:net';
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { Readable } from 'node:stream';
+import { tunnelDomainFor } from './tunnelDomains.js';
+import { getControlProbe } from '../services/tunnel/probeRegistry.js';
 export async function probeLocalPort(port, opts = {}) {
     const host = opts.host ?? '127.0.0.1';
     const timeoutMs = opts.timeoutMs ?? 1500;
@@ -91,7 +93,16 @@ const TRANSIENT_CAUSE_CODES = new Set([
  * other, and coupling them would make this module depend on policy it has no
  * business knowing.
  */
-const ENDPOINT_NOT_FOUND_CODES = new Set(['ERR_NGROK_3200']);
+const ENDPOINT_NOT_FOUND_CODES = new Set([
+    'ERR_NGROK_3200',
+    // The debugg analogue. The server already holds a browser request for
+    // RECONNECT_GRACE_MS (5s) while a client reconnects before rendering this,
+    // but a reconnect that outlasts the grace window would otherwise evict a
+    // tunnel that is about to come back, so confirm it across the ladder too.
+    // DEBUGG_TUNNEL_UNKNOWN is deliberately NOT here: the id is gone, and
+    // re-probing cannot change that answer.
+    'DEBUGG_TUNNEL_OFFLINE',
+]);
 // ─ HTTP/1.1 probe transport (bead kmzb) ──────────────────────────────────────
 /**
  * `fetch`-shaped GET that speaks HTTP/1.1, because the global fetch cannot.
@@ -241,6 +252,16 @@ export async function probeTunnelHealth(tunnelUrl, opts = {}) {
 }
 async function probeOnce(tunnelUrl, opts, started) {
     const timeoutMs = opts.timeoutMs ?? 5000;
+    // A debugg tunnel hostname resolves only inside our VPC, so it cannot be
+    // fetched from the user's machine at all. Its health question goes over the
+    // tunnel's own control websocket instead, and the server answers it by
+    // making a REAL request through the public ingress path — same ALB, same
+    // nginx, same routing a browser takes. Everything below this branch (the
+    // retry ladder, the confirm-across-retries rule, the result shape the
+    // handlers render) is shared by both transports.
+    if (tunnelDomainFor(tunnelUrl)?.transport === 'debugg') {
+        return probeOverControlChannel(tunnelUrl, timeoutMs, started);
+    }
     // Bead kmzb: HTTP/1.1, not the global fetch — see http1Fetch.
     const fetchImpl = opts.fetchFn ?? http1Fetch;
     const controller = new AbortController();
@@ -345,6 +366,118 @@ async function probeOnce(tunnelUrl, opts, started) {
         };
     }
 }
+// ─ Control-channel probe (debugg transport) ──────────────────────────────────
+/**
+ * Ask the tunnel server to fetch `path` back through this tunnel and report
+ * what it got. Maps PROBE_RESULT onto the same TunnelHealthProbeResult the
+ * HTTP path produces — the mapping is pinned on bead debugg_ai_mcp-xkoh.1.2 §9
+ * and must not be re-derived here.
+ */
+async function probeOverControlChannel(tunnelUrl, timeoutMs, started) {
+    const elapsed = () => Date.now() - started;
+    const probe = getControlProbe(tunnelUrl);
+    if (!probe) {
+        // No live control channel in this process for that hostname, and the URL
+        // is unreachable any other way. The tunnel is not coming back on its own,
+        // so report it gone and let the disposition policy clear the leftovers.
+        return {
+            retryable: false,
+            result: {
+                healthy: false,
+                code: 'NGROK_ERROR',
+                ngrokErrorCode: 'DEBUGG_TUNNEL_UNKNOWN',
+                detail: 'no live debugg tunnel session in this process for this hostname',
+                elapsedMs: elapsed(),
+            },
+        };
+    }
+    let probeResult;
+    try {
+        probeResult = await probe(probePathOf(tunnelUrl), { timeoutMs });
+    }
+    catch (err) {
+        // The probe API's contract is that it never throws. Belt and braces: a
+        // probe we could not run is not evidence of a fault.
+        return {
+            retryable: true,
+            result: {
+                healthy: false,
+                code: 'NETWORK_ERROR',
+                detail: err instanceof Error ? err.message : String(err),
+                elapsedMs: elapsed(),
+            },
+        };
+    }
+    const { status, marker, error } = probeResult;
+    if (marker) {
+        const notFound = ENDPOINT_NOT_FOUND_CODES.has(marker);
+        return {
+            retryable: notFound,
+            result: {
+                healthy: false,
+                status,
+                code: 'NGROK_ERROR',
+                ngrokErrorCode: marker,
+                detail: notFound
+                    ? `the tunnel server returned ${marker} — no client is connected for this tunnel`
+                    : `the tunnel server returned ${marker} — tunnel established but traffic could not reach the dev server`,
+                elapsedMs: elapsed(),
+            },
+        };
+    }
+    if (status !== undefined) {
+        if (status === 502 || status === 504) {
+            return {
+                retryable: false,
+                result: {
+                    healthy: false,
+                    status,
+                    code: 'BAD_GATEWAY',
+                    detail: `tunnel returned ${status} without an error marker — gateway is rejecting upstream`,
+                    elapsedMs: elapsed(),
+                },
+            };
+        }
+        // Any other status means traffic reached the dev server, which is healthy
+        // from the TUNNEL's point of view. A user's own 404 is a user concern.
+        return { retryable: false, result: { healthy: true, status, elapsedMs: elapsed() } };
+    }
+    if (error === 'TIMEOUT') {
+        // Not retried, for the same reason the HTTP path does not: a hanging
+        // tunnel must not cost three times the timeout budget.
+        return {
+            retryable: false,
+            result: {
+                healthy: false,
+                code: 'TIMEOUT',
+                detail: `tunnel health probe timed out after ${timeoutMs}ms`,
+                elapsedMs: elapsed(),
+            },
+        };
+    }
+    // Anything else (RESET, CLOSED, ...) is a connection-level failure. It is
+    // retried, because a session that is mid-reconnect reports exactly this and
+    // recovers within the ladder.
+    return {
+        retryable: true,
+        result: {
+            healthy: false,
+            code: 'NETWORK_ERROR',
+            detail: `tunnel control channel reported ${error ?? 'an unknown failure'}`,
+            elapsedMs: elapsed(),
+        },
+    };
+}
+/** The path (with search) a probe should request, defaulting to root. */
+function probePathOf(tunnelUrl) {
+    try {
+        const url = new URL(tunnelUrl);
+        return `${url.pathname}${url.search}` || '/';
+    }
+    catch {
+        return '/';
+    }
+}
 // ─ helpers ───────────────────────────────────────────────────────────────────
 async function readCapped(res, maxBytes) {
     if (!res.body)
@@ -375,8 +508,32 @@ async function readCapped(res, maxBytes) {
     }
     return out;
 }
+/**
+ * The debugg tunnel server's error markers, spelled out rather than matched by
+ * a `DEBUGG_TUNNEL_[A-Z_]+` pattern.
+ *
+ * A pattern would also match this repo's own `DEBUGG_TUNNEL_FAULT_MODE` env var
+ * (services/ngrok/tunnelFaultInjection.ts). This function is used on RUN
+ * EVIDENCE as well as on response bodies (testPageChangesHandler's
+ * findNgrokErrorMarker), so a log line mentioning that variable would otherwise
+ * be read as proof that the browser hit our error page, and a genuine UI
+ * failure would be reclassified as an infrastructure fault.
+ */
+const DEBUGG_TUNNEL_MARKERS = Object.freeze([
+    'DEBUGG_TUNNEL_OFFLINE',
+    'DEBUGG_TUNNEL_UNKNOWN',
+    'DEBUGG_TUNNEL_UPSTREAM_REFUSED',
+]);
+const MARKER_PATTERN = new RegExp(`ERR_NGROK_\\d+|${DEBUGG_TUNNEL_MARKERS.join('|')}`);
+/**
+ * The stable error marker a tunnel put in front of the user's app, from either
+ * transport: ngrok's `ERR_NGROK_*` or the debugg server's `DEBUGG_TUNNEL_*`.
+ *
+ * Name kept (and with it `TunnelHealthProbeResult.ngrokErrorCode` and
+ * `code: 'NGROK_ERROR'`) because handlers echo these into tool output;
+ * renaming them is part of deleting ngrok, not of adding a transport.
+ */
 export function extractNgrokErrorCode(body) {
-    // ngrok error pages surface codes like "ERR_NGROK_8012", "ERR_NGROK_3200", etc.
-    const match = body.match(/ERR_NGROK_\d+/);
+    const match = body.match(MARKER_PATTERN);
     return match ? match[0] : undefined;
 }

package/dist/utils/tunnelContext.js

@@ -61,12 +61,15 @@ export function findExistingTunnel(ctx) {
  * @param tunnelId  - ID to use as the ngrok subdomain (only takes effect the
  *                    first time this session creates a tunnel)
  * @param keyId     - Backend key ID; stored on the tunnel so it is revoked on stop
- * @param revokeKey - Callback that revokes the backend key (called when tunnel stops)
+ * @param revokeKey - Callback that revokes the backend tunnel (called when tunnel stops)
+ * @param selection - The provision response's transport fields. Omitted means
+ *                    ngrok, which is what an old backend implies, so every
+ *                    existing caller keeps its meaning.
  */
-export async function ensureTunnel(ctx, tunnelKey, tunnelId, keyId, revokeKey) {
+export async function ensureTunnel(ctx, tunnelKey, tunnelId, keyId, revokeKey, selection) {
     if (!ctx.isLocalhost)
         return ctx;
-    const info = await tunnelManager.ensureSessionTunnel(getSessionKey(), tunnelKey, tunnelId, keyId, revokeKey);
+    const info = await tunnelManager.ensureSessionTunnel(getSessionKey(), tunnelKey, tunnelId, keyId, revokeKey, selection);
     return { ...ctx, tunnelId: info.tunnelId, targetUrl: retargetTunnelUrl(info.tunnelUrl, ctx.originalUrl) };
 }
 /**

package/dist/utils/tunnelDisposition.js

@@ -72,7 +72,22 @@ const logger = new Logger({ module: 'tunnelDisposition' });
  * a "frozen" Set still succeeds silently. Freezing the array is a real runtime
  * guarantee; the lookup Set is derived from it and kept private.
  */
-const ENDPOINT_GONE_CODES = Object.freeze(['ERR_NGROK_3200']);
+const ENDPOINT_GONE_CODES = Object.freeze([
+    'ERR_NGROK_3200',
+    // The debugg tunnel server's equivalents (bead debugg_ai_mcp-xkoh.1.2 §10).
+    // Both are served BY THE EDGE ABOUT A HOSTNAME IT DOES NOT ROUTE, which is
+    // the inclusion criterion above:
+    //   DEBUGG_TUNNEL_OFFLINE — no client is connected. Confirmed across
+    //     probeTunnelHealth's retry ladder before it gets here, because the
+    //     server renders it after a 5s grace window that a slow reconnect can
+    //     outlast.
+    //   DEBUGG_TUNNEL_UNKNOWN — unknown or revoked tunnel id. Definitive.
+    // DEBUGG_TUNNEL_UPSTREAM_REFUSED is deliberately absent: like ERR_NGROK_8012
+    // it means the TUNNEL served us that page and is alive, while the user's dev
+    // server is what refused.
+    'DEBUGG_TUNNEL_OFFLINE',
+    'DEBUGG_TUNNEL_UNKNOWN',
+]);
 const ENDPOINT_GONE_LOOKUP = new Set(ENDPOINT_GONE_CODES);
 /** The allowlist, as an immutable list. Read-only by construction. */
 export const ENDPOINT_GONE_NGROK_CODES = ENDPOINT_GONE_CODES;