@debugbundle/mcp 1.14.0 → 1.15.0

package/dist/main.cjs

@@ -1198,8 +1198,8 @@ var require_util = __commonJS({
       if (body == null) {
         return 0;
       } else if (isStream(body)) {
-        const state = body._readableState;
-        return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null;
+        const state2 = body._readableState;
+        return state2 && state2.objectMode === false && state2.ended === true && Number.isFinite(state2.length) ? state2.length : null;
       } else if (isBlobLike(body)) {
         return body.size != null ? body.size : null;
       } else if (isBuffer(body)) {
@@ -5814,7 +5814,7 @@ var require_formdata = __commonJS({
         }
       }
       [nodeUtil.inspect.custom](depth, options) {
-        const state = this.#state.reduce((a, b) => {
+        const state2 = this.#state.reduce((a, b) => {
           if (a[b.name]) {
             if (Array.isArray(a[b.name])) {
               a[b.name].push(b.value);
@@ -5828,7 +5828,7 @@ var require_formdata = __commonJS({
         }, { __proto__: null });
         options.depth ??= depth;
         options.colors ??= true;
-        const output = nodeUtil.formatWithOptions(options, state);
+        const output = nodeUtil.formatWithOptions(options, state2);
         return `FormData ${output.slice(output.indexOf("]") + 2)}`;
       }
       static {
@@ -7989,8 +7989,8 @@ var require_client_h2 = __commonJS({
       return body == null || util4.isBuffer(body) || util4.isBlobLike(body);
     }
     function hasResponseStarted(request) {
-      const state = request[kRequestStream]?.[kRequestStreamState];
-      return state?.responseReceived === true;
+      const state2 = request[kRequestStream]?.[kRequestStreamState];
+      return state2?.responseReceived === true;
     }
     function registerGoAwayRefusal(request) {
       const attempts = (request[kGoAwayReplayAttempts] ?? 0) + 1;
@@ -8131,16 +8131,16 @@ var require_client_h2 = __commonJS({
       };
     }
     function refH2Session(session) {
-      const state = session[kHTTP2SessionState];
-      if (state.refed === false) {
-        state.refed = true;
+      const state2 = session[kHTTP2SessionState];
+      if (state2.refed === false) {
+        state2.refed = true;
         session.ref();
       }
     }
     function unrefH2Session(session) {
-      const state = session[kHTTP2SessionState];
-      if (state.refed === true) {
-        state.refed = false;
+      const state2 = session[kHTTP2SessionState];
+      if (state2.refed === true) {
+        state2.refed = false;
         session.unref();
       }
     }
@@ -8166,25 +8166,25 @@ var require_client_h2 = __commonJS({
       }
     }
     function clearNoStreamsTimeout(session) {
-      const state = session[kHTTP2SessionState];
-      if (state?.noStreamsTimeout != null) {
-        clearTimeout(state.noStreamsTimeout);
-        state.noStreamsTimeout = null;
+      const state2 = session[kHTTP2SessionState];
+      if (state2?.noStreamsTimeout != null) {
+        clearTimeout(state2.noStreamsTimeout);
+        state2.noStreamsTimeout = null;
       }
     }
     function setNoStreamsTimeout(session) {
       const client = session[kClient];
-      const state = session[kHTTP2SessionState];
+      const state2 = session[kHTTP2SessionState];
       const timeout = client[kHeadersTimeout];
-      if (!timeout || state.noStreamsTimeout != null) {
+      if (!timeout || state2.noStreamsTimeout != null) {
         return;
       }
-      state.noStreamsTimeout = setTimeout(onNoStreamsTimeout, timeout, session).unref();
+      state2.noStreamsTimeout = setTimeout(onNoStreamsTimeout, timeout, session).unref();
     }
     function onNoStreamsTimeout(session) {
       const client = session[kClient];
-      const state = session[kHTTP2SessionState];
-      state.noStreamsTimeout = null;
+      const state2 = session[kHTTP2SessionState];
+      state2.noStreamsTimeout = null;
       if (client[kHTTP2Session] !== session || client[kMaxConcurrentStreams] !== 0 || client[kRunning] !== 0 || client[kPending] === 0) {
         return;
       }
@@ -8201,10 +8201,10 @@ var require_client_h2 = __commonJS({
       resetHttp2Session(session, err);
     }
     function clearHttp2IdleTimeout(session) {
-      const state = session[kHTTP2SessionState];
-      if (state?.idleTimeout != null) {
-        clearTimeout(state.idleTimeout);
-        state.idleTimeout = null;
+      const state2 = session[kHTTP2SessionState];
+      if (state2?.idleTimeout != null) {
+        clearTimeout(state2.idleTimeout);
+        state2.idleTimeout = null;
       }
     }
     function setHttp2IdleTimeout(session) {
@@ -8216,16 +8216,16 @@ var require_client_h2 = __commonJS({
         clearHttp2IdleTimeout(session);
         return;
       }
-      const state = session[kHTTP2SessionState];
-      if (state.idleTimeout == null) {
-        state.idleTimeout = setTimeout(onHttp2SessionIdleTimeout, client[kKeepAliveDefaultTimeout], session).unref();
+      const state2 = session[kHTTP2SessionState];
+      if (state2.idleTimeout == null) {
+        state2.idleTimeout = setTimeout(onHttp2SessionIdleTimeout, client[kKeepAliveDefaultTimeout], session).unref();
       }
     }
     function onHttp2SessionIdleTimeout(session) {
       const client = session[kClient];
       const socket = session[kSocket];
-      const state = session[kHTTP2SessionState];
-      state.idleTimeout = null;
+      const state2 = session[kHTTP2SessionState];
+      state2.idleTimeout = null;
       if (client[kHTTP2Session] !== session || session[kOpenStreams] !== 0 || client[kSize] !== 0 || session.closed || session.destroyed) {
         return;
       }
@@ -8254,10 +8254,10 @@ var require_client_h2 = __commonJS({
       this[kClient][kResume]();
     }
     function onHttp2SendPing(session) {
-      const state = session[kHTTP2SessionState];
-      if ((session.closed || session.destroyed) && state.ping.interval != null) {
-        clearInterval(state.ping.interval);
-        state.ping.interval = null;
+      const state2 = session[kHTTP2SessionState];
+      if ((session.closed || session.destroyed) && state2.ping.interval != null) {
+        clearInterval(state2.ping.interval);
+        state2.ping.interval = null;
         return;
       }
       session.ping(onPing.bind(session));
@@ -8337,7 +8337,7 @@ var require_client_h2 = __commonJS({
       client[kResume]();
     }
     function onHttp2SessionClose() {
-      const { [kClient]: client, [kHTTP2SessionState]: state, [kSocket]: socket } = this;
+      const { [kClient]: client, [kHTTP2SessionState]: state2, [kSocket]: socket } = this;
       const err = socket[kError] || this[kError] || new SocketError("closed", util4.getSocketInfo(socket));
       if (client[kHTTP2Session] === this) {
         client[kSocket] = null;
@@ -8346,9 +8346,9 @@ var require_client_h2 = __commonJS({
       }
       clearHttp2IdleTimeout(this);
       clearNoStreamsTimeout(this);
-      if (state.ping.interval != null) {
-        clearInterval(state.ping.interval);
-        state.ping.interval = null;
+      if (state2.ping.interval != null) {
+        clearInterval(state2.ping.interval);
+        state2.ping.interval = null;
       }
       if (client.destroyed) {
         assert6(client[kPending] === 0);
@@ -8409,27 +8409,27 @@ var require_client_h2 = __commonJS({
     }
     function onUpgradeStreamClose() {
       this.off("error", noop);
-      const state = this[kRequestStreamState];
+      const state2 = this[kRequestStreamState];
       this[kRequestStreamState] = null;
-      failUpgradeStream(state, new InformationalError("HTTP/2: stream closed before response headers"));
+      failUpgradeStream(state2, new InformationalError("HTTP/2: stream closed before response headers"));
       closeStreamSession(this);
     }
     function completeRequestStream() {
-      const state = this[kRequestStreamState];
-      if (state == null) {
+      const state2 = this[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
       releaseRequestStream(this);
-      if (state.pendingEnd && !state.request.aborted && !state.request.completed) {
-        state.request.onResponseEnd(state.trailers || {});
-      } else if (!state.request.aborted && !state.request.completed) {
+      if (state2.pendingEnd && !state2.request.aborted && !state2.request.completed) {
+        state2.request.onResponseEnd(state2.trailers || {});
+      } else if (!state2.request.aborted && !state2.request.completed) {
         util4.errorRequest(
-          state.client,
-          state.request,
+          state2.client,
+          state2.request,
           new InformationalError("HTTP/2: stream closed before the response was complete")
         );
       }
-      finalizeRequest(state);
+      finalizeRequest(state2);
       closeStreamSession(this);
       this[kRequestStreamState] = null;
     }
@@ -8471,11 +8471,11 @@ var require_client_h2 = __commonJS({
       if (stream == null) {
         return;
       }
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
-      const { request } = state;
+      const { request } = state2;
       if (request[kRequestStream] === stream) {
         detachRequestFromStream(request);
       }
@@ -8484,43 +8484,43 @@ var require_client_h2 = __commonJS({
         stream.once("error", noop);
       }
     }
-    function failUpgradeStream(state, err) {
-      if (state == null) {
+    function failUpgradeStream(state2, err) {
+      if (state2 == null) {
         return;
       }
-      const { request } = state;
-      if (state.responseReceived || request.aborted || request.completed) {
+      const { request } = state2;
+      if (state2.responseReceived || request.aborted || request.completed) {
         return;
       }
-      releaseUpgradeStream(state.stream);
-      state.abort(err, true);
+      releaseUpgradeStream(state2.stream);
+      state2.abort(err, true);
     }
     function onUpgradeStreamError() {
-      const state = this[kRequestStreamState];
+      const state2 = this[kRequestStreamState];
       if (typeof this.rstCode === "number" && this.rstCode !== 0) {
-        failUpgradeStream(state, new InformationalError(`HTTP/2: "stream error" received - code ${this.rstCode}`));
+        failUpgradeStream(state2, new InformationalError(`HTTP/2: "stream error" received - code ${this.rstCode}`));
       } else {
-        failUpgradeStream(state, new InformationalError("HTTP/2: stream errored before response headers"));
+        failUpgradeStream(state2, new InformationalError("HTTP/2: stream errored before response headers"));
       }
     }
     function onUpgradeStreamEnd() {
       failUpgradeStream(this[kRequestStreamState], new InformationalError("HTTP/2: stream half-closed (remote)"));
     }
     function onUpgradeStreamTimeout() {
-      const state = this[kRequestStreamState];
-      failUpgradeStream(state, new InformationalError(`HTTP/2: "stream timeout after ${state.headersTimeout}"`));
+      const state2 = this[kRequestStreamState];
+      failUpgradeStream(state2, new InformationalError(`HTTP/2: "stream timeout after ${state2.headersTimeout}"`));
     }
     function onUpgradeResponse(headers, _flags) {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      const { request } = state;
-      state.responseReceived = true;
+      const state2 = stream[kRequestStreamState];
+      const { request } = state2;
+      state2.responseReceived = true;
       const statusCode = headers[HTTP2_HEADER_STATUS];
       delete headers[HTTP2_HEADER_STATUS];
       try {
         request.onRequestUpgrade(statusCode, headers, stream);
       } catch (err) {
-        state.abort(err);
+        state2.abort(err);
         return;
       }
       if (request.aborted) {
@@ -8528,14 +8528,14 @@ var require_client_h2 = __commonJS({
       }
       removeUpgradeStreamListeners(stream);
       detachRequestFromStream(request);
-      finalizeRequest(state);
+      finalizeRequest(state2);
     }
-    function setupUpgradeStream(stream, state) {
-      const { request, headersTimeout, session } = state;
+    function setupUpgradeStream(stream, state2) {
+      const { request, headersTimeout, session } = state2;
       stream[kHTTP2Stream] = true;
       stream[kHTTP2Session] = session;
-      stream[kRequestStreamState] = state;
-      state.stream = stream;
+      stream[kRequestStreamState] = state2;
+      state2.stream = stream;
       bindRequestToStream(request, stream, releaseUpgradeStream);
       stream.once("response", onUpgradeResponse);
       stream.on("error", onUpgradeStreamError);
@@ -8546,13 +8546,13 @@ var require_client_h2 = __commonJS({
       ++session[kOpenStreams];
       stream.setTimeout(headersTimeout);
     }
-    function finalizeRequest(state, resetPendingIdx = false) {
-      if (state.requestFinalized) {
+    function finalizeRequest(state2, resetPendingIdx = false) {
+      if (state2.requestFinalized) {
         return;
       }
-      state.requestFinalized = true;
-      completeRequest(state.client, state.request, resetPendingIdx);
-      state.client[kResume]();
+      state2.requestFinalized = true;
+      completeRequest(state2.client, state2.request, resetPendingIdx);
+      state2.client[kResume]();
     }
     function openStream(client, request, session, abort, headers, options) {
       try {
@@ -8587,7 +8587,7 @@ var require_client_h2 = __commonJS({
       const headers = buildRequestHeaders(reqHeaders);
       headers[HTTP2_HEADER_AUTHORITY] = host || client[kHostAuthority];
       headers[HTTP2_HEADER_METHOD] = method;
-      const state = {
+      const state2 = {
         abort: null,
         body: request.body,
         bytesRead: 0,
@@ -8613,19 +8613,19 @@ var require_client_h2 = __commonJS({
         }
         err = err || new RequestAbortedError();
         util4.errorRequest(client, request, err);
-        if (state.stream != null) {
+        if (state2.stream != null) {
           clearRequestStream(request);
-          const stream2 = state.stream;
+          const stream2 = state2.stream;
           stream2.close();
           if (!stream2.destroyed) {
             util4.destroy(stream2);
           }
           client[kOnError](err);
-          finalizeRequest(state, resetPendingIdx);
+          finalizeRequest(state2, resetPendingIdx);
         }
-        util4.destroy(state.body, err);
+        util4.destroy(state2.body, err);
       };
-      state.abort = abort;
+      state2.abort = abort;
       let stream = null;
       try {
         request.onRequestStart(abort, null);
@@ -8656,7 +8656,7 @@ var require_client_h2 = __commonJS({
             unrefH2Session(session);
             return false;
           }
-          setupUpgradeStream(stream, state);
+          setupUpgradeStream(stream, state2);
           return true;
         }
         stream = openStream(client, request, session, abort, headers, { endStream: false, signal });
@@ -8664,13 +8664,13 @@ var require_client_h2 = __commonJS({
           unrefH2Session(session);
           return false;
         }
-        setupUpgradeStream(stream, state);
+        setupUpgradeStream(stream, state2);
         return true;
       }
       headers[HTTP2_HEADER_PATH] = path;
       headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
-      let body = state.body;
+      let body = state2.body;
       if (body && typeof body.read === "function") {
         body.read(0);
       }
@@ -8709,9 +8709,9 @@ var require_client_h2 = __commonJS({
         channels.sendHeaders.publish({ request, headers: header2, socket: session[kSocket] });
       }
       const shouldEndStream = body === null || contentLength === 0;
-      state.body = body;
-      state.contentLength = contentLength;
-      state.expectsPayload = expectsPayload;
+      state2.body = body;
+      state2.contentLength = contentLength;
+      state2.expectsPayload = expectsPayload;
       if (expectContinue) {
         headers[HTTP2_HEADER_EXPECT] = "100-continue";
       }
@@ -8720,8 +8720,8 @@ var require_client_h2 = __commonJS({
         return false;
       }
       stream[kHTTP2Stream] = true;
-      stream[kRequestStreamState] = state;
-      state.stream = stream;
+      stream[kRequestStreamState] = state2;
+      state2.stream = stream;
       clearHttp2IdleTimeout(session);
       ++session[kOpenStreams];
       if (headersTimeout) {
@@ -8765,11 +8765,11 @@ var require_client_h2 = __commonJS({
       if (stream == null) {
         return;
       }
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
-      const { request } = state;
+      const { request } = state2;
       if (request[kRequestStream] === stream) {
         detachRequestFromStream(request);
       }
@@ -8780,34 +8780,34 @@ var require_client_h2 = __commonJS({
     }
     function onData(chunk) {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
-      const { request, maxResponseSize, responseContentLength } = state;
+      const { request, maxResponseSize, responseContentLength } = state2;
       if (request.aborted || request.completed) {
         return;
       }
-      if (responseContentLength != null && state.bytesRead + chunk.length > responseContentLength) {
-        state.abort(new ResponseContentLengthMismatchError());
+      if (responseContentLength != null && state2.bytesRead + chunk.length > responseContentLength) {
+        state2.abort(new ResponseContentLengthMismatchError());
         return;
       }
-      if (maxResponseSize > -1 && state.bytesRead + chunk.length > maxResponseSize) {
-        state.abort(new ResponseExceededMaxSizeError());
+      if (maxResponseSize > -1 && state2.bytesRead + chunk.length > maxResponseSize) {
+        state2.abort(new ResponseExceededMaxSizeError());
         return;
       }
-      state.bytesRead += chunk.length;
+      state2.bytesRead += chunk.length;
       if (request.onResponseData(chunk) === false) {
         stream.pause();
       }
     }
     function onInterimResponse(headers) {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
-      const { request } = state;
+      const { request } = state2;
       if (request.aborted || request.completed) {
         return;
       }
@@ -8817,26 +8817,26 @@ var require_client_h2 = __commonJS({
     }
     function onResponse(headers) {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
-      const { request } = state;
+      const { request } = state2;
       stream.off("response", onResponse);
-      if (state.body != null && !state.bodySent && !stream.writableEnded) {
+      if (state2.body != null && !state2.bodySent && !stream.writableEnded) {
         stream.removeListener("continue", writeBodyH2);
         stream.end();
       }
       const statusCode = Number(headers[HTTP2_HEADER_STATUS]);
       delete headers[HTTP2_HEADER_STATUS];
       request.onResponseStarted();
-      state.responseReceived = true;
+      state2.responseReceived = true;
       if (request.method !== "HEAD" && statusCode !== 304) {
         const contentLength = headers[HTTP2_HEADER_CONTENT_LENGTH];
-        state.responseContentLength = contentLength == null ? null : Number(contentLength);
+        state2.responseContentLength = contentLength == null ? null : Number(contentLength);
       }
-      if (state.headersTimeout || state.bodyTimeout) {
-        stream.setTimeout(state.bodyTimeout);
+      if (state2.headersTimeout || state2.bodyTimeout) {
+        stream.setTimeout(state2.bodyTimeout);
       }
       if (request.aborted || request.completed) {
         releaseRequestStream(stream);
@@ -8849,34 +8849,34 @@ var require_client_h2 = __commonJS({
     }
     function onEnd() {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
-      const { request } = state;
+      const { request } = state2;
       stream.off("end", onEnd);
-      if (state.responseReceived) {
+      if (state2.responseReceived) {
         if (!request.aborted && !request.completed) {
-          if (state.responseContentLength != null && state.bytesRead !== state.responseContentLength) {
-            state.abort(new ResponseContentLengthMismatchError());
+          if (state2.responseContentLength != null && state2.bytesRead !== state2.responseContentLength) {
+            state2.abort(new ResponseContentLengthMismatchError());
             return;
           }
-          state.pendingEnd = true;
+          state2.pendingEnd = true;
           completeRequestStream.call(stream);
         }
       } else {
-        state.abort(new InformationalError("HTTP/2: stream half-closed (remote)"), true);
+        state2.abort(new InformationalError("HTTP/2: stream half-closed (remote)"), true);
       }
     }
-    function retryRefusedStream(stream, state) {
-      const { client, request } = state;
-      if (state.responseReceived || request.aborted || request.completed || request[kRefusedStreamRetry] || !canReplayRequest(request)) {
+    function retryRefusedStream(stream, state2) {
+      const { client, request } = state2;
+      if (state2.responseReceived || request.aborted || request.completed || request[kRefusedStreamRetry] || !canReplayRequest(request)) {
         return false;
       }
       request[kRefusedStreamRetry] = true;
       detachRequestStreamForClose(request);
-      state.stream = null;
-      state.requestFinalized = true;
+      state2.stream = null;
+      state2.requestFinalized = true;
       completeRequest(client, request);
       client[kQueue].splice(client[kPendingIdx], 0, request);
       client[kResume]();
@@ -8884,63 +8884,63 @@ var require_client_h2 = __commonJS({
     }
     function onError(err) {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
       stream.off("error", onError);
-      if (state.responseContentLength != null && state.bytesRead !== state.responseContentLength) {
+      if (state2.responseContentLength != null && state2.bytesRead !== state2.responseContentLength) {
         err = new ResponseContentLengthMismatchError();
       }
       if (typeof stream.rstCode === "number" && stream.rstCode !== NGHTTP2_NO_ERROR) {
         err.http2ErrorCode = stream.rstCode;
       }
-      if (stream.rstCode === NGHTTP2_REFUSED_STREAM && retryRefusedStream(stream, state)) {
+      if (stream.rstCode === NGHTTP2_REFUSED_STREAM && retryRefusedStream(stream, state2)) {
         return;
       }
-      state.abort(err);
+      state2.abort(err);
     }
     function onFrameError(type, code) {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
       stream.off("frameError", onFrameError);
-      state.abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`));
+      state2.abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`));
     }
     function onAborted() {
       this.off("data", onData);
     }
     function onTimeout() {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
       stream.off("timeout", onTimeout);
-      const err = state.responseReceived ? new BodyTimeoutError(`HTTP/2: "stream timeout after ${state.bodyTimeout}"`) : new HeadersTimeoutError(`HTTP/2: "headers timeout after ${state.headersTimeout}"`);
-      state.abort(err);
+      const err = state2.responseReceived ? new BodyTimeoutError(`HTTP/2: "stream timeout after ${state2.bodyTimeout}"`) : new HeadersTimeoutError(`HTTP/2: "headers timeout after ${state2.headersTimeout}"`);
+      state2.abort(err);
     }
     function onTrailers(trailers) {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      if (state == null) {
+      const state2 = stream[kRequestStreamState];
+      if (state2 == null) {
         return;
       }
-      const { request } = state;
+      const { request } = state2;
       stream.off("trailers", onTrailers);
       stream.off("data", onData);
       if (request.aborted || request.completed) {
         return;
       }
-      state.trailers = trailers;
+      state2.trailers = trailers;
     }
     function writeBodyH2() {
       const stream = this;
-      const state = stream[kRequestStreamState];
-      state.bodySent = true;
-      const { abort, body, client, contentLength, expectsPayload, request } = state;
+      const state2 = stream[kRequestStreamState];
+      state2.bodySent = true;
+      const { abort, body, client, contentLength, expectsPayload, request } = state2;
       if (!body || contentLength === 0) {
         writeBuffer(
           abort,
@@ -12185,7 +12185,7 @@ var require_retry_handler = __commonJS({
       onRequestUpgrade(_controller, statusCode, headers, socket) {
         this.handler.onRequestUpgrade?.(this.controllerProxy, statusCode, headers, socket);
       }
-      static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) {
+      static [kRetryHandlerDefaultRetry](err, { state: state2, opts }, cb) {
         const { statusCode, code, headers } = err;
         const { method, retryOptions } = opts;
         const {
@@ -12198,7 +12198,7 @@ var require_retry_handler = __commonJS({
           methods,
           retryAfter
         } = retryOptions;
-        const { counter } = state;
+        const { counter } = state2;
         if (code && code !== "UND_ERR_REQ_RETRY" && !errorCodes.includes(code)) {
           cb(err);
           return;
@@ -12816,24 +12816,24 @@ var require_readable = __commonJS({
       if (consume2.body === null) {
         return;
       }
-      const { _readableState: state } = consume2.stream;
-      if (state.bufferIndex) {
-        const start = state.bufferIndex;
-        const end = state.buffer.length;
+      const { _readableState: state2 } = consume2.stream;
+      if (state2.bufferIndex) {
+        const start = state2.bufferIndex;
+        const end = state2.buffer.length;
         for (let n = start; n < end; n++) {
-          consumePush(consume2, state.buffer[n]);
+          consumePush(consume2, state2.buffer[n]);
         }
       } else {
-        for (const chunk of state.buffer) {
+        for (const chunk of state2.buffer) {
           consumePush(consume2, chunk);
         }
       }
-      const decoder2 = state.decoder;
+      const decoder2 = state2.decoder;
       if (decoder2 != null && decoder2.lastNeed > 0) {
         consumePush(consume2, Buffer.from(decoder2.lastChar.subarray(0, decoder2.lastTotal - decoder2.lastNeed)));
       }
-      if (state.endEmitted) {
-        consumeEnd(consume2, state.encoding);
+      if (state2.endEmitted) {
+        consumeEnd(consume2, state2.encoding);
         return;
       }
       consume2.stream.on("end", function() {
@@ -16736,12 +16736,12 @@ var require_dns = __commonJS({
       #controller = null;
       #newOrigin = null;
       #firstTry = true;
-      constructor(state, { origin, handler: handler7, dispatch, newOrigin }, opts) {
+      constructor(state2, { origin, handler: handler7, dispatch, newOrigin }, opts) {
         super(handler7);
         this.#origin = origin;
         this.#newOrigin = newOrigin;
         this.#opts = { ...opts };
-        this.#state = state;
+        this.#state = state2;
         this.#dispatch = dispatch;
       }
       onResponseError(controller, err) {
@@ -19941,19 +19941,19 @@ var require_deduplication_handler = __commonJS({
           pendingTrailers: null,
           done: false
         };
-        const state = {
+        const state2 = {
           aborted: false,
           paused: false,
           reason: null
         };
         waitingHandler.controller = {
           resume: () => {
-            if (state.aborted) {
+            if (state2.aborted) {
               return;
             }
-            state.paused = false;
+            state2.paused = false;
             this.#flushWaitingHandler(waitingHandler);
-            if (this.#completed && waitingHandler.pendingTrailers && waitingHandler.bufferedChunks.length === 0 && !state.paused && !state.aborted) {
+            if (this.#completed && waitingHandler.pendingTrailers && waitingHandler.bufferedChunks.length === 0 && !state2.paused && !state2.aborted) {
               try {
                 waitingHandler.handler.onResponseEnd?.(waitingHandler.controller, waitingHandler.pendingTrailers);
               } catch (err) {
@@ -19965,31 +19965,31 @@ var require_deduplication_handler = __commonJS({
             this.#pruneDoneWaitingHandlers();
           },
           pause: () => {
-            if (!state.aborted) {
-              state.paused = true;
+            if (!state2.aborted) {
+              state2.paused = true;
             }
           },
           get paused() {
-            return state.paused;
+            return state2.paused;
           },
           get aborted() {
-            return state.aborted;
+            return state2.aborted;
           },
           get reason() {
-            return state.reason;
+            return state2.reason;
           },
           abort: (reason) => {
-            if (state.aborted) {
+            if (state2.aborted) {
               return;
             }
-            state.aborted = true;
-            state.reason = reason ?? null;
+            state2.aborted = true;
+            state2.reason = reason ?? null;
             waitingHandler.done = true;
             waitingHandler.pendingTrailers = null;
             waitingHandler.bufferedChunks = [];
             waitingHandler.bufferedBytes = 0;
             try {
-              handler7.onResponseError?.(waitingHandler.controller, state.reason ?? new RequestAbortedError());
+              handler7.onResponseError?.(waitingHandler.controller, state2.reason ?? new RequestAbortedError());
             } catch {
             }
           }
@@ -21225,17 +21225,17 @@ var require_response = __commonJS({
         response.status === 0
       );
     }
-    function makeFilteredResponse(response, state) {
-      state = {
+    function makeFilteredResponse(response, state2) {
+      state2 = {
         internalResponse: response,
-        ...state
+        ...state2
       };
       return new Proxy(response, {
         get(target, p) {
-          return p in state ? state[p] : target[p];
+          return p in state2 ? state2[p] : target[p];
         },
         set(target, p, value) {
-          assert6(!(p in state));
+          assert6(!(p in state2));
           target[p] = value;
           return true;
         }
@@ -66182,18 +66182,18 @@ var require_cluster = __commonJS({
           if (typeof res !== "string") {
             return callback();
           }
-          let state;
+          let state2;
           const lines = res.split("\r\n");
           for (let i = 0; i < lines.length; ++i) {
             const parts = lines[i].split(":");
             if (parts[0] === "cluster_state") {
-              state = parts[1];
+              state2 = parts[1];
               break;
             }
           }
-          if (state === "fail") {
-            debug3("cluster state not ok (%s)", state);
-            callback(null, state);
+          if (state2 === "fail") {
+            debug3("cluster state not ok (%s)", state2);
+            callback(null, state2);
           } else {
             callback();
           }
@@ -72564,6 +72564,97 @@ var coerce = {
 };
 var NEVER = INVALID;
 
+// ../../packages/shared-types/src/public-status.ts
+var PublicStatusIdSchema = external_exports.string().regex(/^[a-f0-9]{24}$/);
+var selection = external_exports.object({ project_id: external_exports.string().uuid(), check_ids: external_exports.array(external_exports.string().uuid()).max(50) }).strict();
+var PublicStatusSettingsSchema = external_exports.object({
+  title: external_exports.string().trim().min(1).max(120),
+  enabled: external_exports.boolean(),
+  projects: external_exports.array(selection).min(1).max(50)
+}).strict().superRefine((value, context) => {
+  if (new Set(value.projects.map((p) => p.project_id)).size !== value.projects.length || new Set(value.projects.flatMap((p) => p.check_ids)).size !== value.projects.reduce((n, p) => n + p.check_ids.length, 0) || value.projects.reduce((count, p) => count + p.check_ids.length, 0) > 500) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      message: "Choose distinct projects and checks within the publication limits."
+    });
+  }
+});
+var state = external_exports.enum(["unknown", "operational", "degraded", "down", "paused"]);
+var percentage = external_exports.number().min(0).max(100).nullable();
+var verifiedAt = external_exports.string().datetime({ offset: true }).nullable();
+var PublicStatusDaySchema = external_exports.object({
+  day: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  state,
+  impact: external_exports.enum(["none", "minor", "elevated", "outage"]),
+  total_checks: external_exports.number().int().nonnegative(),
+  successful_checks: external_exports.number().int().nonnegative(),
+  failed_checks: external_exports.number().int().nonnegative(),
+  degraded_checks: external_exports.number().int().nonnegative(),
+  downtime_seconds: external_exports.number().nonnegative()
+}).strict();
+var checkView = external_exports.object({
+  key: external_exports.string().max(40),
+  name: external_exports.string().max(120),
+  current_state: state,
+  uptime_percentage: percentage,
+  last_verified_at: verifiedAt,
+  days: external_exports.array(PublicStatusDaySchema).length(30)
+}).strict();
+var PublicStatusProjectSchema = checkView.extend({ checks: external_exports.array(checkView).max(50) }).strict();
+var PublicStatusPageSchema = external_exports.object({ title: external_exports.string().max(120), projects: external_exports.array(PublicStatusProjectSchema).max(50) }).strict();
+var PublicStatusManagementSchema = external_exports.object({
+  settings: PublicStatusSettingsSchema,
+  public_id: PublicStatusIdSchema.nullable(),
+  public_url: external_exports.string().url().nullable(),
+  access_mode: external_exports.enum(["manage", "preview"])
+}).strict();
+var PublicStatusOptionsQueryObjectSchema = external_exports.object({
+  cursor: external_exports.string().uuid().optional(),
+  check_project_id: external_exports.string().uuid().optional(),
+  check_cursor: external_exports.string().uuid().optional()
+}).strict();
+var PublicStatusOptionsQuerySchema = PublicStatusOptionsQueryObjectSchema.refine(
+  (v) => !v.check_cursor || !!v.check_project_id,
+  "A check cursor requires a project."
+).refine((v) => !v.cursor || !v.check_project_id, "Project and check pagination are separate.");
+var PublicStatusOptionsSchema = external_exports.object({
+  projects: external_exports.array(
+    external_exports.object({
+      project_id: external_exports.string().uuid(),
+      name: external_exports.string(),
+      checks: external_exports.array(external_exports.object({ check_id: external_exports.string().uuid(), name: external_exports.string() }).strict()).max(50),
+      next_check_cursor: external_exports.string().uuid().nullable()
+    }).strict()
+  ).max(50),
+  next_cursor: external_exports.string().uuid().nullable()
+}).strict();
+
+// ../../packages/retrieval-client/src/mutation-outcome.ts
+var MutationOutcomeUnconfirmedError = class extends Error {
+  constructor(status) {
+    super(
+      "mutation_outcome_unconfirmed: The operation may have succeeded, but its result could not be confirmed. Check the current state before retrying; do not automatically repeat the mutation."
+    );
+    this.status = status;
+    this.name = "MutationOutcomeUnconfirmedError";
+  }
+  code = "mutation_outcome_unconfirmed";
+  outcome = "unknown";
+  retrySafe = false;
+  toJSON() {
+    return {
+      error: this.code,
+      outcome: this.outcome,
+      retry_safe: this.retrySafe,
+      message: this.message
+    };
+  }
+};
+
+// ../../packages/node-http/src/index.ts
+var import_undici = __toESM(require_undici(), 1);
+var nodeFetch = import_undici.fetch;
+
 // ../../packages/shared-types/src/event-envelope.ts
 function createUuidV4() {
   const cryptoSource = globalThis.crypto;
@@ -75351,32 +75442,6 @@ var BundleV1Schema = external_exports.object({
   metadata: BundleMetadataSchema
 });
 
-// ../../packages/retrieval-client/src/mutation-outcome.ts
-var MutationOutcomeUnconfirmedError = class extends Error {
-  constructor(status) {
-    super(
-      "mutation_outcome_unconfirmed: The operation may have succeeded, but its result could not be confirmed. Check the current state before retrying; do not automatically repeat the mutation."
-    );
-    this.status = status;
-    this.name = "MutationOutcomeUnconfirmedError";
-  }
-  code = "mutation_outcome_unconfirmed";
-  outcome = "unknown";
-  retrySafe = false;
-  toJSON() {
-    return {
-      error: this.code,
-      outcome: this.outcome,
-      retry_safe: this.retrySafe,
-      message: this.message
-    };
-  }
-};
-
-// ../../packages/node-http/src/index.ts
-var import_undici = __toESM(require_undici(), 1);
-var nodeFetch = import_undici.fetch;
-
 // ../../packages/retrieval-client/src/index.ts
 var ProjectColorTagResponseSchema = external_exports.unknown().transform((value, context) => {
   if (value === void 0 || value === null) {
@@ -77702,6 +77767,122 @@ function createCliHttpClient(input2, dependencies) {
   };
 }
 
+// ../cli/src/public-status-commands.ts
+var PublicStatusApiError = class extends Error {
+  constructor(status, message3) {
+    super(message3);
+    this.status = status;
+  }
+};
+function createPublicStatusApi(http) {
+  const path = (scope3) => `/v1/projects/${encodeURIComponent(external_exports.string().uuid().parse(scope3.projectId))}/status-page`;
+  async function request(input2, schema) {
+    const result = await http.request(input2);
+    if (result.status !== 200) {
+      const error2 = external_exports.object({ error: external_exports.string() }).safeParse(result.body);
+      throw new PublicStatusApiError(
+        result.status,
+        error2.success ? error2.data.error : "Status request failed."
+      );
+    }
+    return schema.parse(result.body);
+  }
+  return {
+    get: (scope3) => request(
+      { method: "GET", path: path(scope3), bearerToken: scope3.bearerToken },
+      PublicStatusManagementSchema
+    ),
+    save: (scope3) => request(
+      {
+        method: "PUT",
+        path: path(scope3),
+        bearerToken: scope3.bearerToken,
+        body: PublicStatusSettingsSchema.parse(scope3.settings)
+      },
+      PublicStatusManagementSchema
+    ),
+    options: (scope3) => {
+      const query = PublicStatusOptionsQuerySchema.parse({
+        ...scope3.cursor ? { cursor: scope3.cursor } : {},
+        ...scope3.check_project_id ? { check_project_id: scope3.check_project_id } : {},
+        ...scope3.check_cursor ? { check_cursor: scope3.check_cursor } : {}
+      });
+      const params = new URLSearchParams(
+        Object.entries(query).filter(
+          (entry) => typeof entry[1] === "string"
+        )
+      ).toString();
+      return request(
+        {
+          method: "GET",
+          path: `${path(scope3)}/options${params ? `?${params}` : ""}`,
+          bearerToken: scope3.bearerToken
+        },
+        PublicStatusOptionsSchema
+      );
+    },
+    preview: (scope3) => request(
+      { method: "GET", path: `${path(scope3)}/preview`, bearerToken: scope3.bearerToken },
+      PublicStatusPageSchema
+    )
+  };
+}
+
+// src/public-status-tools.ts
+var scope = external_exports.object({ bearerToken: external_exports.string().min(1), projectId: external_exports.string().uuid() }).strict();
+var PUBLIC_STATUS_MCP_TOOL_NAMES = [
+  "get_public_status_page",
+  "save_public_status_page",
+  "list_public_status_page_options",
+  "preview_public_status_page"
+];
+var PUBLIC_STATUS_MCP_TOOL_CATALOG = [
+  {
+    name: PUBLIC_STATUS_MCP_TOOL_NAMES[0],
+    group: "public_status",
+    description: "Read a project's public status settings and share URL. Owners receive configuration; collaborators receive only the published link and title.",
+    inputSchema: scope
+  },
+  {
+    name: PUBLIC_STATUS_MCP_TOOL_NAMES[1],
+    group: "public_status",
+    description: "Save or publish/unpublish a public status page. Owner only. Explicit selections expose names and 30-day availability for chosen checks; other projects must share the same owner and account. Anchor project must be first. New checks remain private.",
+    inputSchema: scope.extend({ settings: PublicStatusSettingsSchema })
+  },
+  {
+    name: PUBLIC_STATUS_MCP_TOOL_NAMES[2],
+    group: "public_status",
+    description: "List a bounded page of same-owner/account projects and checks eligible for status publication. Owner only; continue with next_cursor.",
+    inputSchema: scope.extend(PublicStatusOptionsQueryObjectSchema.shape)
+  },
+  {
+    name: PUBLIC_STATUS_MCP_TOOL_NAMES[3],
+    group: "public_status",
+    description: "Preview the saved public projection, including unpublished settings. Owner only. Reads existing availability; never executes checks or exposes diagnostic details.",
+    inputSchema: scope
+  }
+];
+function createPublicStatusMcpTools(api) {
+  async function call(fn2) {
+    try {
+      return await fn2();
+    } catch (error2) {
+      throw new Error(
+        `mcp_tool_error:${error2 instanceof PublicStatusApiError ? error2.message : error2 instanceof external_exports.ZodError ? "invalid_status_input" : "unknown_error"}`
+      );
+    }
+  }
+  return {
+    get_public_status_page: (input2) => call(() => api.get(scope.parse(input2))),
+    save_public_status_page: (input2) => call(() => api.save(PUBLIC_STATUS_MCP_TOOL_CATALOG[1].inputSchema.parse(input2))),
+    list_public_status_page_options: (input2) => call(() => {
+      const parsed = PUBLIC_STATUS_MCP_TOOL_CATALOG[2].inputSchema.parse(input2);
+      return api.options(parsed);
+    }),
+    preview_public_status_page: (input2) => call(() => api.preview(scope.parse(input2)))
+  };
+}
+
 // ../cli/src/analytics-flow-commands.ts
 var AnalyticsFlowApiError = class extends Error {
   constructor(status, message3) {
@@ -77761,20 +77942,20 @@ function createAnalyticsFlowApi(http) {
 }
 
 // src/analytics-flow-tools.ts
-var scope = external_exports.object({ bearerToken: external_exports.string(), projectId: external_exports.string().uuid() });
-var item = scope.extend({ flowKey: AnalyticsFlowKeySchema });
+var scope2 = external_exports.object({ bearerToken: external_exports.string(), projectId: external_exports.string().uuid() });
+var item = scope2.extend({ flowKey: AnalyticsFlowKeySchema });
 var ANALYTICS_FLOW_MCP_TOOL_CATALOG = [
   {
     name: "list_analytics_flows",
     group: "analytics_flows",
     description: "List this project's named acquisition and activation flows, including archived definitions.",
-    inputSchema: scope
+    inputSchema: scope2
   },
   {
     name: "save_analytics_flow",
     group: "analytics_flows",
     description: "Create or replace a project flow with two to eight ordered steps and exact origins. Owner/admin only. Edits start a new report version.",
-    inputSchema: scope.extend({ definition: AnalyticsFlowDefinitionInputSchema })
+    inputSchema: scope2.extend({ definition: AnalyticsFlowDefinitionInputSchema })
   },
   {
     name: "archive_analytics_flow",
@@ -77800,7 +77981,7 @@ function createAnalyticsFlowMcpTools(api) {
     }
   }
   return {
-    list_analytics_flows: (input2) => call(() => api.list(scope.parse(input2))),
+    list_analytics_flows: (input2) => call(() => api.list(scope2.parse(input2))),
     save_analytics_flow: (input2) => call(() => api.save(ANALYTICS_FLOW_MCP_TOOL_CATALOG[1].inputSchema.parse(input2))),
     archive_analytics_flow: (input2) => call(() => api.archive(item.parse(input2))),
     get_analytics_flow_report: (input2) => call(() => {
@@ -79092,76 +79273,76 @@ var BudgetExceeded = class extends Error {
 function byteLength(value) {
   return new TextEncoder().encode(value).length;
 }
-function mask(state) {
-  state.redactionCount += 1;
+function mask(state2) {
+  state2.redactionCount += 1;
   return REDACTED2;
 }
-function sanitizeString(value, state, allowStructured) {
-  if (value.length > MAX_STRING_BYTES) return mask(state);
+function sanitizeString(value, state2, allowStructured) {
+  if (value.length > MAX_STRING_BYTES) return mask(state2);
   const length = byteLength(value);
-  if (length > MAX_STRING_BYTES) return mask(state);
-  state.textBytes += length;
-  if (state.textBytes > state.maxTotalBytes) throw new BudgetExceeded();
+  if (length > MAX_STRING_BYTES) return mask(state2);
+  state2.textBytes += length;
+  if (state2.textBytes > state2.maxTotalBytes) throw new BudgetExceeded();
   if (allowStructured && (value.startsWith("{") || value.startsWith("["))) {
     try {
       const parsed = JSON.parse(value);
       if (typeof parsed === "object" && parsed !== null) {
-        const nested = sanitizeValue(parsed, state, 0, false);
+        const nested = sanitizeValue(parsed, state2, 0, false);
         const encoded = JSON.stringify(nested);
-        if (encoded !== value) state.redactionCount += 1;
+        if (encoded !== value) state2.redactionCount += 1;
         return encoded;
       }
     } catch (error2) {
       if (error2 instanceof BudgetExceeded) throw error2;
     }
   }
-  const result = scrubCredentialText(value, state.extra);
-  if (result !== value) state.redactionCount += 1;
+  const result = scrubCredentialText(value, state2.extra);
+  if (result !== value) state2.redactionCount += 1;
   if ((value.startsWith("{") || value.startsWith("[")) && result === value && /(?:password|token|secret|authorization|cookie)["']?\s*[:=]/i.test(value)) {
-    return mask(state);
+    return mask(state2);
   }
   return result;
 }
-function sanitizeValue(value, state, depth, allowStructured) {
-  state.nodes += 1;
-  if (state.nodes > MAX_NODES) throw new BudgetExceeded();
-  if (depth > MAX_DEPTH) return mask(state);
-  if (typeof value === "string") return sanitizeString(value, state, allowStructured);
+function sanitizeValue(value, state2, depth, allowStructured) {
+  state2.nodes += 1;
+  if (state2.nodes > MAX_NODES) throw new BudgetExceeded();
+  if (depth > MAX_DEPTH) return mask(state2);
+  if (typeof value === "string") return sanitizeString(value, state2, allowStructured);
   if (value === null || typeof value === "boolean") return value;
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value !== "object") throw new TypeError("unsafe_input");
-  if (state.seen.has(value)) return "[Circular]";
-  state.seen.add(value);
+  if (state2.seen.has(value)) return "[Circular]";
+  state2.seen.add(value);
   try {
     if (Array.isArray(value)) {
-      if (value.length > MAX_ENTRIES) return mask(state);
+      if (value.length > MAX_ENTRIES) return mask(state2);
       return Array.from({ length: value.length }, (_, index) => {
         const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
         if (descriptor === void 0 || !("value" in descriptor)) throw new TypeError("unsafe_input");
-        return sanitizeValue(descriptor.value, state, depth + 1, allowStructured);
+        return sanitizeValue(descriptor.value, state2, depth + 1, allowStructured);
       });
     }
     if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
       throw new TypeError("unsafe_input");
     }
     const keys2 = Object.keys(value);
-    if (keys2.length > MAX_ENTRIES) return mask(state);
+    if (keys2.length > MAX_ENTRIES) return mask(state2);
     const result = {};
     for (const key of keys2) {
       if (key.length > 128) {
-        state.redactionCount += 1;
+        state2.redactionCount += 1;
         continue;
       }
-      state.textBytes += byteLength(key);
-      if (state.textBytes > state.maxTotalBytes) throw new BudgetExceeded();
-      const safeKey = scrubCredentialText(key, state.extra);
+      state2.textBytes += byteLength(key);
+      if (state2.textBytes > state2.maxTotalBytes) throw new BudgetExceeded();
+      const safeKey = scrubCredentialText(key, state2.extra);
       if (safeKey !== key) {
-        state.redactionCount += 1;
+        state2.redactionCount += 1;
         continue;
       }
       const descriptor = Object.getOwnPropertyDescriptor(value, key);
       if (descriptor === void 0 || !("value" in descriptor)) throw new TypeError("unsafe_input");
-      const safeValue = isSensitiveKey(key, state.keys) ? mask(state) : sanitizeValue(descriptor.value, state, depth + 1, allowStructured);
+      const safeValue = isSensitiveKey(key, state2.keys) ? mask(state2) : sanitizeValue(descriptor.value, state2, depth + 1, allowStructured);
       Object.defineProperty(result, key, {
         value: safeValue,
         enumerable: true,
@@ -79171,7 +79352,7 @@ function sanitizeValue(value, state, depth, allowStructured) {
     }
     return result;
   } finally {
-    state.seen.delete(value);
+    state2.seen.delete(value);
   }
 }
 function sanitizeTelemetry(value, options = {}) {
@@ -79184,7 +79365,7 @@ function sanitizeTelemetry(value, options = {}) {
     if (!Number.isInteger(maxTotalBytes) || maxTotalBytes < 1 || maxTotalBytes > 512 * 1024) {
       return { ok: false, reason: "unsafe_input" };
     }
-    const state = {
+    const state2 = {
       nodes: 0,
       textBytes: 0,
       redactionCount: 0,
@@ -79193,11 +79374,11 @@ function sanitizeTelemetry(value, options = {}) {
       extra,
       maxTotalBytes
     };
-    const sanitized = sanitizeValue(value, state, 0, true);
+    const sanitized = sanitizeValue(value, state2, 0, true);
     if (byteLength(JSON.stringify(sanitized)) > maxTotalBytes) {
       return { ok: false, reason: "budget_exceeded" };
     }
-    return { ok: true, value: sanitized, redactionCount: state.redactionCount };
+    return { ok: true, value: sanitized, redactionCount: state2.redactionCount };
   } catch (error2) {
     return { ok: false, reason: error2 instanceof BudgetExceeded ? "budget_exceeded" : "unsafe_input" };
   }
@@ -91321,17 +91502,17 @@ var InvalidClientMetadata = class extends OIDCProviderError {
   }
 };
 var InvalidScope = class extends OIDCProviderError {
-  constructor(description, scope2, options) {
+  constructor(description, scope3, options) {
     super(400, "invalid_scope", options);
     Error.captureStackTrace(this, this.constructor);
-    Object.assign(this, { scope: scope2, error_description: description, error_detail: this.error_detail });
+    Object.assign(this, { scope: scope3, error_description: description, error_detail: this.error_detail });
   }
 };
 var InsufficientScope = class extends OIDCProviderError {
-  constructor(description, scope2, options) {
+  constructor(description, scope3, options) {
     super(403, "insufficient_scope", options);
     Error.captureStackTrace(this, this.constructor);
-    Object.assign(this, { scope: scope2, error_description: description, error_detail: this.error_detail });
+    Object.assign(this, { scope: scope3, error_description: description, error_detail: this.error_detail });
   }
 };
 var InvalidRequest = class extends OIDCProviderError {
@@ -91574,10 +91755,10 @@ var consent_default = () => new prompt_default(
     const { oidc } = ctx;
     const encounteredScopes = new Set(oidc.grant.getOIDCScopeEncountered().split(" "));
     let missing;
-    for (const scope2 of oidc.requestParamOIDCScopes) {
-      if (!encounteredScopes.has(scope2)) {
+    for (const scope3 of oidc.requestParamOIDCScopes) {
+      if (!encounteredScopes.has(scope3)) {
         missing ||= [];
-        missing.push(scope2);
+        missing.push(scope3);
       }
     }
     if (missing?.length) {
@@ -91609,11 +91790,11 @@ var consent_default = () => new prompt_default(
       const encounteredScopes = new Set(oidc.grant.getResourceScopeEncountered(indicator).split(" "));
       const requestedScopes = ctx.oidc.requestParamScopes;
       const availableScopes = resourceServer.scopes;
-      for (const scope2 of requestedScopes) {
-        if (availableScopes.has(scope2) && !encounteredScopes.has(scope2)) {
+      for (const scope3 of requestedScopes) {
+        if (availableScopes.has(scope3) && !encounteredScopes.has(scope3)) {
           missing ||= {};
           missing[indicator] ||= [];
-          missing[indicator].push(scope2);
+          missing[indicator].push(scope3);
         }
       }
     }
@@ -92037,7 +92218,7 @@ async function findAccount(ctx, sub, token) {
   mustChange("findAccount", "use your own account model");
   return {
     accountId: sub,
-    async claims(use, scope2, claims, rejected) {
+    async claims(use, scope3, claims, rejected) {
       return { sub };
     }
   };
@@ -92974,9 +93155,9 @@ var Configuration = class {
         claimDefinedScopes.push(key);
       }
     });
-    claimDefinedScopes.forEach((scope2) => {
-      if (typeof scope2 === "string" && !this.scopes.has(scope2)) {
-        this.scopes.add(scope2);
+    claimDefinedScopes.forEach((scope3) => {
+      if (typeof scope3 === "string" && !this.scopes.has(scope3)) {
+        this.scopes.add(scope3);
       }
     });
   }
@@ -92992,9 +93173,9 @@ var Configuration = class {
     Object.entries(this.claims).forEach(([key, value]) => {
       if (Array.isArray(value)) {
         this.claims[key] = value.reduce((accumulator, claim) => {
-          const scope2 = accumulator;
-          scope2[claim] = null;
-          return scope2;
+          const scope3 = accumulator;
+          scope3[claim] = null;
+          return scope3;
         }, {});
       }
     });
@@ -93011,9 +93192,9 @@ var Configuration = class {
   }
   collectClaims() {
     const claims = /* @__PURE__ */ new Set();
-    this.scopes.forEach((scope2) => {
-      if (scope2 in this.claims) {
-        Object.keys(this.claims[scope2]).forEach(Set.prototype.add.bind(claims));
+    this.scopes.forEach((scope3) => {
+      if (scope3 in this.claims) {
+        Object.keys(this.claims[scope3]).forEach(Set.prototype.add.bind(claims));
       }
     });
     Object.entries(this.claims).forEach(([key, value]) => {
@@ -94232,9 +94413,9 @@ function interaction(it, options) {
   missingOIDCScope2.delete("offline_access");
   if (missingOIDCScope2.size) {
     __eta.res += "  <li>scopes:</li>\n  <ul>\n    ";
-    missingOIDCScope2.forEach((scope2) => {
+    missingOIDCScope2.forEach((scope3) => {
       __eta.res += "      <li>";
-      __eta.res += __eta.e(scope2);
+      __eta.res += __eta.e(scope3);
       __eta.res += "</li>\n    ";
     });
     __eta.res += "  </ul>\n";
@@ -94259,9 +94440,9 @@ function interaction(it, options) {
       __eta.res += "    <li>";
       __eta.res += __eta.e(indicator);
       __eta.res += ":</li>\n    <ul>\n      ";
-      scopes.forEach((scope2) => {
+      scopes.forEach((scope3) => {
         __eta.res += "        <li>";
-        __eta.res += __eta.e(scope2);
+        __eta.res += __eta.e(scope3);
         __eta.res += "</li>\n      ";
       });
       __eta.res += "    </ul>\n  ";
@@ -94656,8 +94837,8 @@ function devInteractions(provider) {
               grant.addOIDCClaims(details.missingOIDCClaims);
             }
             if (details.missingResourceScopes) {
-              for (const [indicator, scope2] of Object.entries(details.missingResourceScopes)) {
-                grant.addResourceScope(indicator, scope2.join(" "));
+              for (const [indicator, scope3] of Object.entries(details.missingResourceScopes)) {
+                grant.addResourceScope(indicator, scope3.join(" "));
               }
             }
             const result = { consent: { grantId: await grant.save() } };
@@ -97270,9 +97451,9 @@ var resolve_resource_default = async (ctx, model, config2, scopes = model.scopes
 };
 
 // ../../node_modules/.pnpm/oidc-provider@9.11.5/node_modules/oidc-provider/lib/helpers/account_claims.js
-async function getCtxAccountClaims(ctx, use, scope2, claims, rejected) {
+async function getCtxAccountClaims(ctx, use, scope3, claims, rejected) {
   return {
-    ...await ctx.oidc.account.claims(use, scope2, claims, rejected),
+    ...await ctx.oidc.account.claims(use, scope3, claims, rejected),
     sub: ctx.oidc.account.accountId
   };
 }
@@ -97422,15 +97603,15 @@ async function applyDpopBinding(ctx, dPoP, at) {
 async function resolveAndApplyResource(ctx, source, at, grant, {
   userinfo,
   resourceIndicators
-}, scope2) {
-  const resource = await resolve_resource_default(ctx, source, { userinfo, resourceIndicators }, scope2);
+}, scope3) {
+  const resource = await resolve_resource_default(ctx, source, { userinfo, resourceIndicators }, scope3);
   if (resource) {
     const resourceServerInfo = await resourceIndicators.getResourceServerInfo(ctx, resource, ctx.oidc.client);
     at.resourceServer = new ctx.oidc.provider.ResourceServer(resource, resourceServerInfo);
-    at.scope = grant.getResourceScopeFiltered(resource, scope2 || source.scopes);
+    at.scope = grant.getResourceScopeFiltered(resource, scope3 || source.scopes);
   } else {
     at.claims = source.claims;
-    at.scope = grant.getOIDCScopeFiltered(scope2 || source.scopes);
+    at.scope = grant.getOIDCScopeFiltered(scope3 || source.scopes);
   }
   return resource;
 }
@@ -97688,9 +97869,9 @@ var handler2 = async function clientCredentialsHandler(ctx) {
   const scopes = [...new Set(ctx.oidc.params.scope?.split(" "))];
   if (client.scope) {
     const allowList = new Set(client.scope.split(" "));
-    for (const scope2 of scopes.filter(Set.prototype.has.bind(statics))) {
-      if (!allowList.has(scope2)) {
-        throw new InvalidScope("requested scope is not allowed", scope2);
+    for (const scope3 of scopes.filter(Set.prototype.has.bind(statics))) {
+      if (!allowList.has(scope3)) {
+        throw new InvalidScope("requested scope is not allowed", scope3);
       }
     }
   }
@@ -97950,25 +98131,25 @@ var handler4 = async function refreshTokenHandler(ctx) {
   if (at.gty && !at.gty.endsWith(gty3)) {
     at.gty = `${at.gty} ${gty3}`;
   }
-  const scope2 = ctx.oidc.params.scope ? ctx.oidc.requestParamScopes : refreshToken.scopes;
+  const scope3 = ctx.oidc.params.scope ? ctx.oidc.requestParamScopes : refreshToken.scopes;
   await checkRar(ctx, () => {
   });
   const resource = await resolve_resource_default(
     ctx,
     refreshToken,
     { userinfo, resourceIndicators },
-    scope2
+    scope3
   );
   if (resource) {
     const resourceServerInfo = await resourceIndicators.getResourceServerInfo(ctx, resource, ctx.oidc.client);
     at.resourceServer = new ctx.oidc.provider.ResourceServer(resource, resourceServerInfo);
     at.scope = grant.getResourceScopeFiltered(
       resource,
-      [...scope2].filter(Set.prototype.has.bind(at.resourceServer.scopes))
+      [...scope3].filter(Set.prototype.has.bind(at.resourceServer.scopes))
     );
   } else {
     at.claims = refreshToken.claims;
-    at.scope = grant.getOIDCScopeFiltered(scope2);
+    at.scope = grant.getOIDCScopeFiltered(scope3);
   }
   if (richAuthorizationRequests.enabled && at.resourceServer) {
     at.rar = await richAuthorizationRequests.rarForRefreshTokenResponse(ctx, at.resourceServer);
@@ -97978,7 +98159,7 @@ var handler4 = async function refreshTokenHandler(ctx) {
   const idToken = await issueIdToken(ctx, refreshToken, at, grant, {
     conformIdTokenClaims,
     userinfo
-  }, scope2);
+  }, scope3);
   ctx.body = buildTokenResponse(at, accessToken, {
     idToken,
     refreshToken: refreshTokenValue,
@@ -98372,20 +98553,20 @@ var err_out_default = ({
   expose,
   message: message3,
   error_description: description,
-  scope: scope2
-}, state) => {
+  scope: scope3
+}, state2) => {
   if (expose) {
     return {
       error: message3,
       ...description !== void 0 ? { error_description: description } : void 0,
-      ...scope2 !== void 0 ? { scope: scope2 } : void 0,
-      ...state !== void 0 ? { state } : void 0
+      ...scope3 !== void 0 ? { scope: scope3 } : void 0,
+      ...state2 !== void 0 ? { state: state2 } : void 0
     };
   }
   return {
     error: "server_error",
     error_description: "oops! something went wrong",
-    ...state ? { state } : void 0
+    ...state2 ? { state: state2 } : void 0
   };
 };
 
@@ -98499,8 +98680,8 @@ var authorization_error_handler_default = (provider) => {
       recovery: oneRedirectUriClients
     }
   });
-  function getOutAndEmit(ctx, err, state) {
-    const out = { ...err_out_default(err, state), iss: ctx.oidc.provider.issuer };
+  function getOutAndEmit(ctx, err, state2) {
+    const out = { ...err_out_default(err, state2), iss: ctx.oidc.provider.issuer };
     if (err.expose) {
       provider.emit("authorization.error", ctx, err);
       debugError2("%o", out);
@@ -99656,8 +99837,8 @@ async function checkIdTokenHint(ctx, next) {
 
 // ../../node_modules/.pnpm/oidc-provider@9.11.5/node_modules/oidc-provider/lib/helpers/is_valid_scope.js
 var SCOPE_SYNTAX = /^[\x21\x23-\x5B\x5D-\x7E]+(?: [\x21\x23-\x5B\x5D-\x7E]+)*$/u;
-function isValidScope(scope2) {
-  return scope2 === void 0 || typeof scope2 === "string" && SCOPE_SYNTAX.test(scope2);
+function isValidScope(scope3) {
+  return scope3 === void 0 || typeof scope3 === "string" && SCOPE_SYNTAX.test(scope3);
 }
 
 // ../../node_modules/.pnpm/oidc-provider@9.11.5/node_modules/oidc-provider/lib/actions/authorization/check_scope.js
@@ -99681,9 +99862,9 @@ async function checkScope(PARAM_LIST3, ctx, next) {
   }
   if (client.scope) {
     const allowList = new Set(client.scope.split(" "));
-    for (const scope2 of scopes.filter(Set.prototype.has.bind(statics))) {
-      if (!allowList.has(scope2)) {
-        throw new InvalidScope("requested scope is not allowed", scope2);
+    for (const scope3 of scopes.filter(Set.prototype.has.bind(statics))) {
+      if (!allowList.has(scope3)) {
+        throw new InvalidScope("requested scope is not allowed", scope3);
       }
     }
   }
@@ -100084,9 +100265,9 @@ async function codeHandler(ctx) {
 async function idTokenHandler(ctx) {
   const claims = filter_claims_default(ctx.oidc.claims, "id_token", ctx.oidc.grant);
   const rejected = ctx.oidc.grant.getRejectedOIDCClaims();
-  const scope2 = ctx.oidc.grant.getOIDCScopeFiltered(ctx.oidc.requestParamScopes);
+  const scope3 = ctx.oidc.grant.getOIDCScopeFiltered(ctx.oidc.requestParamScopes);
   const idToken = new ctx.oidc.provider.IdToken({
-    ...await getCtxAccountClaims(ctx, "id_token", scope2, claims, rejected),
+    ...await getCtxAccountClaims(ctx, "id_token", scope3, claims, rejected),
     acr: ctx.oidc.acr,
     amr: ctx.oidc.amr,
     auth_time: ctx.oidc.session.authTime()
@@ -100098,7 +100279,7 @@ async function idTokenHandler(ctx) {
   if (conformIdTokenClaims && userinfo.enabled && ctx.oidc.params.response_type !== "id_token" && !ctx.oidc.params.resource) {
     idToken.scope = "openid";
   } else {
-    idToken.scope = scope2;
+    idToken.scope = scope3;
   }
   idToken.mask = claims;
   idToken.rejected = rejected;
@@ -101074,12 +101255,12 @@ function getSetWWWAuthenticateHeader({ tokenProperty = "accessToken", includeSco
       if (!err.expose || dpop === false && err.statusCode !== 401) throw err;
       const conf = weak_cache_default(ctx.oidc.provider);
       const dpopEnabled = dpop !== false && conf.features.dPoP.enabled;
-      const scope2 = includeScope ? err.scope : void 0;
+      const scope3 = includeScope ? err.scope : void 0;
       const algs = dpopEnabled ? conf.configuration.dPoPSigningAlgValues.join(" ") : void 0;
       if (err instanceof NoAccessTokenProvided) {
-        appendWWWAuthenticate(ctx, "Bearer", { realm: ctx.oidc.issuer, scope: scope2 });
+        appendWWWAuthenticate(ctx, "Bearer", { realm: ctx.oidc.issuer, scope: scope3 });
         if (dpopEnabled) {
-          appendWWWAuthenticate(ctx, "DPoP", { realm: ctx.oidc.issuer, scope: scope2, algs });
+          appendWWWAuthenticate(ctx, "DPoP", { realm: ctx.oidc.issuer, scope: scope3, algs });
         }
         throw err;
       }
@@ -101096,7 +101277,7 @@ function getSetWWWAuthenticateHeader({ tokenProperty = "accessToken", includeSco
         realm: ctx.oidc.issuer,
         error: err.error ?? err.message,
         error_description: err.error_description,
-        scope: scope2,
+        scope: scope3,
         ...scheme === "DPoP" ? { algs } : void 0
       });
       throw err;
@@ -101213,14 +101394,14 @@ var userinfo_default = [
   async function respond2(ctx) {
     const claims = filter_claims_default(ctx.oidc.accessToken.claims, "userinfo", ctx.oidc.grant);
     const rejected = ctx.oidc.grant.getRejectedOIDCClaims();
-    const scope2 = ctx.oidc.grant.getOIDCScopeFiltered(new Set((ctx.oidc.params.scope || ctx.oidc.accessToken.scope).split(" ")));
+    const scope3 = ctx.oidc.grant.getOIDCScopeFiltered(new Set((ctx.oidc.params.scope || ctx.oidc.accessToken.scope).split(" ")));
     const { client } = ctx.oidc;
     if (client.userinfoSignedResponseAlg || client.userinfoEncryptedResponseAlg) {
       const token = new ctx.oidc.provider.IdToken(
-        await getCtxAccountClaims(ctx, "userinfo", scope2, claims, rejected),
+        await getCtxAccountClaims(ctx, "userinfo", scope3, claims, rejected),
         { ctx }
       );
-      token.scope = scope2;
+      token.scope = scope3;
       token.mask = claims;
       token.rejected = rejected;
       ctx.body = await token.issue({
@@ -101230,10 +101411,10 @@ var userinfo_default = [
       ctx.type = "application/jwt; charset=utf-8";
     } else {
       const mask2 = new ctx.oidc.provider.Claims(
-        await getCtxAccountClaims(ctx, "userinfo", scope2, claims, rejected),
+        await getCtxAccountClaims(ctx, "userinfo", scope3, claims, rejected),
         { ctx }
       );
-      mask2.scope(scope2);
+      mask2.scope(scope3);
       mask2.mask(claims);
       mask2.rejected(rejected);
       ctx.body = await mask2.result();
@@ -102311,7 +102492,7 @@ var confirm2 = [
   checkXsrf("could not find logout details"),
   async function endSession(ctx) {
     const { oidc: { session, params } } = ctx;
-    const { state } = session;
+    const { state: state2 } = session;
     const {
       features: { backchannelLogout },
       cookies: { long: opts }
@@ -102320,7 +102501,7 @@ var confirm2 = [
       const clientIds = Object.keys(session.authorizations || {});
       const back = [];
       for (const clientId of clientIds) {
-        if (params.logout || clientId === state.clientId) {
+        if (params.logout || clientId === state2.clientId) {
           const client = await clientForLogout(ctx, clientId);
           if (client) {
             const sid = session.sidFor(client.clientId);
@@ -102337,8 +102518,8 @@ var confirm2 = [
       }
       await Promise.all(back);
     }
-    if (state.clientId) {
-      ctx.oidc.entity("Client", await clientForLogout(ctx, state.clientId));
+    if (state2.clientId) {
+      ctx.oidc.entity("Client", await clientForLogout(ctx, state2.clientId));
     }
     if (params.logout) {
       if (session.authorizations) {
@@ -102356,24 +102537,24 @@ var confirm2 = [
         null,
         opts
       );
-    } else if (state.clientId) {
-      const grantId = session.grantIdFor(state.clientId);
-      if (grantId && !session.authorizationFor(state.clientId).persistsLogout) {
+    } else if (state2.clientId) {
+      const grantId = session.grantIdFor(state2.clientId);
+      if (grantId && !session.authorizationFor(state2.clientId).persistsLogout) {
         await revoke(ctx, grantId);
       }
       session.state = void 0;
       if (session.authorizations) {
-        delete session.authorizations[state.clientId];
+        delete session.authorizations[state2.clientId];
       }
       session.resetIdentifier();
     }
-    const usePostLogoutUri = state.postLogoutRedirectUri;
-    const forwardClientId = !usePostLogoutUri && !params.logout && state.clientId;
+    const usePostLogoutUri = state2.postLogoutRedirectUri;
+    const forwardClientId = !usePostLogoutUri && !params.logout && state2.clientId;
     const uri = redirectUri(
-      usePostLogoutUri ? state.postLogoutRedirectUri : ctx.oidc.urlFor("end_session_success"),
+      usePostLogoutUri ? state2.postLogoutRedirectUri : ctx.oidc.urlFor("end_session_success"),
       {
-        ...usePostLogoutUri && state.state != null ? { state: state.state } : void 0,
-        ...forwardClientId ? { client_id: state.clientId } : void 0
+        ...usePostLogoutUri && state2.state != null ? { state: state2.state } : void 0,
+        ...forwardClientId ? { client_id: state2.clientId } : void 0
       }
     );
     ctx.oidc.provider.emit("end_session.success", ctx);
@@ -103302,8 +103483,8 @@ function getClaims(provider) {
       if (Object.keys(this.filter).length) {
         throw new Error("scope cannot be assigned after mask has been set");
       }
-      value.split(" ").forEach((scope2) => {
-        this.mask(claimConfig[scope2]);
+      value.split(" ").forEach((scope3) => {
+        this.mask(claimConfig[scope3]);
       });
       return this;
     }
@@ -103518,7 +103699,7 @@ var jwt_default = (provider, { opaque }) => {
         jti,
         iat,
         exp,
-        scope: scope2,
+        scope: scope3,
         clientId,
         "x5t#S256": x5t2,
         jkt: jkt2,
@@ -103543,7 +103724,7 @@ var jwt_default = (provider, { opaque }) => {
         iat,
         exp,
         authorization_details: rar,
-        scope: scope2 || void 0,
+        scope: scope3 || void 0,
         client_id: clientId,
         iss: provider.issuer,
         aud,
@@ -103993,8 +104174,8 @@ function getBaseModel(provider) {
     }
     ttlPercentagePassed() {
       const now = epoch_time_default();
-      const percentage = Math.floor(100 * ((now - this.iat) / (this.exp - this.iat)));
-      return Math.max(Math.min(100, percentage), 0);
+      const percentage2 = Math.floor(100 * ((now - this.iat) / (this.exp - this.iat)));
+      return Math.max(Math.min(100, percentage2), 0);
     }
     get isValid() {
       return !this.isExpired;
@@ -104692,8 +104873,8 @@ function getSchema(provider) {
     scopes() {
       if (this.scope) {
         const parsed = new Set(this.scope.split(" "));
-        parsed.forEach((scope2) => {
-          if (!scopes.has(scope2)) {
+        parsed.forEach((scope3) => {
+          if (!scopes.has(scope3)) {
             this.invalidate("scope must only contain Authorization Server supported scope values");
           }
         });
@@ -106097,9 +106278,9 @@ var grant_default = (provider) => class Grant extends apply([
       if (this.rejected) {
         const rejected = this.getOIDCScope.call(this.rejected).split(" ");
         const granted = new Set(this.openid.scope.split(" "));
-        for (const scope2 of rejected) {
-          if (scope2 !== "openid") {
-            granted.delete(scope2);
+        for (const scope3 of rejected) {
+          if (scope3 !== "openid") {
+            granted.delete(scope3);
           }
         }
         return [...granted].join(" ");
@@ -106121,19 +106302,19 @@ var grant_default = (provider) => class Grant extends apply([
     const granted = this.getOIDCScope().split(" ");
     return granted.filter(Set.prototype.has.bind(filter2)).join(" ");
   }
-  addOIDCScope(scope2) {
-    if (scope2 instanceof Set) {
-      scope2 = [...scope2].join(" ");
-    } else if (Array.isArray(scope2)) {
-      scope2 = scope2.join(" ");
-    } else if (typeof scope2 !== "string") {
+  addOIDCScope(scope3) {
+    if (scope3 instanceof Set) {
+      scope3 = [...scope3].join(" ");
+    } else if (Array.isArray(scope3)) {
+      scope3 = scope3.join(" ");
+    } else if (typeof scope3 !== "string") {
       throw new TypeError('"scope" must be a string');
     }
     this.openid ||= {};
     if (this.openid.scope) {
-      this.openid.scope = [.../* @__PURE__ */ new Set([...this.openid.scope.split(" "), ...scope2.split(" ")])].join(" ");
+      this.openid.scope = [.../* @__PURE__ */ new Set([...this.openid.scope.split(" "), ...scope3.split(" ")])].join(" ");
     } else {
-      this.openid.scope = scope2;
+      this.openid.scope = scope3;
     }
   }
   rejectOIDCScope(...args2) {
@@ -106153,8 +106334,8 @@ var grant_default = (provider) => class Grant extends apply([
       if (this.rejected) {
         const rejected = this.getResourceScope.call(this.rejected, resource).split(" ");
         const granted = new Set(this.resources[resource].split(" "));
-        for (const scope2 of rejected) {
-          granted.delete(scope2);
+        for (const scope3 of rejected) {
+          granted.delete(scope3);
         }
         return [...granted].join(" ");
       }
@@ -106178,22 +106359,22 @@ var grant_default = (provider) => class Grant extends apply([
     const granted = this.getResourceScope(resource).split(" ");
     return granted.filter(Set.prototype.has.bind(filter2)).join(" ");
   }
-  addResourceScope(resource, scope2) {
+  addResourceScope(resource, scope3) {
     if (typeof resource !== "string") {
       throw new TypeError('"resource" must be a string');
     }
-    if (scope2 instanceof Set) {
-      scope2 = [...scope2].join(" ");
-    } else if (Array.isArray(scope2)) {
-      scope2 = scope2.join(" ");
-    } else if (typeof scope2 !== "string") {
+    if (scope3 instanceof Set) {
+      scope3 = [...scope3].join(" ");
+    } else if (Array.isArray(scope3)) {
+      scope3 = scope3.join(" ");
+    } else if (typeof scope3 !== "string") {
       throw new TypeError('"scope" must be a string');
     }
     this.resources ||= {};
     if (this.resources[resource]) {
-      this.resources[resource] = [.../* @__PURE__ */ new Set([...this.resources[resource].split(" "), ...scope2.split(" ")])].join(" ");
+      this.resources[resource] = [.../* @__PURE__ */ new Set([...this.resources[resource].split(" "), ...scope3.split(" ")])].join(" ");
     } else {
-      this.resources[resource] = scope2;
+      this.resources[resource] = scope3;
     }
   }
   rejectResourceScope(...args2) {
@@ -107061,9 +107242,10 @@ function buildEligibilityCtes(organizationPredicate) {
     )
   `;
 }
-var LIST_AVAILABILITY_CHECKS_QUERY = `
+function buildAvailabilityChecksListQuery(organizationPredicate, checkPredicate, limitSql = "$3", cursorSql = "$4") {
+  return `
   WITH
-  ${buildEligibilityCtes("AND p.organization_id = $2::uuid")},
+  ${buildEligibilityCtes(`AND ${organizationPredicate}`)},
   ranked AS (
     SELECT
       c.id::text AS check_id,
@@ -107110,8 +107292,8 @@ var LIST_AVAILABILITY_CHECKS_QUERY = `
     LEFT JOIN monitored_project_ranks monitored_ranks
       ON monitored_ranks.organization_id = p.organization_id
       AND monitored_ranks.project_id = c.project_id
-    WHERE c.project_id = $1::uuid
-      AND p.organization_id = $2::uuid
+    WHERE ${checkPredicate}
+      AND ${organizationPredicate}
       AND c.deleted_at IS NULL
   )
   SELECT
@@ -107122,10 +107304,15 @@ var LIST_AVAILABILITY_CHECKS_QUERY = `
     NOT ranked.enabled OR ranked.organization_check_rank <= ranked.plan_organization_check_limit
       AS within_organization_active_limit
   FROM ranked
-  WHERE ($4::text IS NULL OR ranked.check_id = $4)
+  WHERE (${cursorSql}::text IS NULL OR ranked.check_id = ${cursorSql})
   ORDER BY ranked.created_at DESC
-  LIMIT $3
+  LIMIT ${limitSql}
 `;
+}
+var LIST_AVAILABILITY_CHECKS_QUERY = buildAvailabilityChecksListQuery(
+  "p.organization_id = $2::uuid",
+  "c.project_id = $1::uuid"
+);
 var CLAIM_DUE_AVAILABILITY_CHECKS_QUERY = `
   WITH due_organizations AS (
     SELECT DISTINCT p.organization_id
@@ -108434,8 +108621,41 @@ function defineStorageSchemaMigration(input2) {
   };
 }
 
-// ../../packages/storage/src/analytics-flow-schema.ts
+// ../../packages/storage/src/public-status-schema.ts
 var statements = [
+  `CREATE TABLE IF NOT EXISTS public_status_pages (
+    id uuid PRIMARY KEY, anchor_project_id uuid NOT NULL UNIQUE REFERENCES projects(id) ON DELETE CASCADE,
+    owner_user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    organization_id uuid NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+    public_id text NOT NULL UNIQUE CHECK (public_id ~ '^[a-f0-9]{24}$'),
+    title text NOT NULL CHECK (length(title) BETWEEN 1 AND 120), enabled boolean NOT NULL DEFAULT false,
+    created_at timestamptz NOT NULL DEFAULT now(), updated_at timestamptz NOT NULL DEFAULT now()
+  )`,
+  `CREATE TABLE IF NOT EXISTS public_status_page_projects (
+    page_id uuid NOT NULL REFERENCES public_status_pages(id) ON DELETE CASCADE,
+    project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    position integer NOT NULL CHECK (position BETWEEN 0 AND 49), PRIMARY KEY(page_id, project_id)
+  )`,
+  `CREATE TABLE IF NOT EXISTS public_status_page_checks (
+    page_id uuid NOT NULL, project_id uuid NOT NULL, check_id uuid NOT NULL REFERENCES availability_checks(id) ON DELETE CASCADE,
+    PRIMARY KEY(page_id, check_id), FOREIGN KEY(page_id, project_id) REFERENCES public_status_page_projects(page_id, project_id) ON DELETE CASCADE
+  )`,
+  "CREATE INDEX IF NOT EXISTS public_status_page_projects_project_idx ON public_status_page_projects(project_id)",
+  "CREATE INDEX IF NOT EXISTS public_status_page_checks_check_idx ON public_status_page_checks(check_id)"
+];
+var PUBLIC_STATUS_BOOTSTRAP_STATEMENTS = statements.map(
+  (s) => s.replaceAll(" IF NOT EXISTS", "")
+);
+var PUBLIC_STATUS_SCHEMA_MIGRATIONS = [
+  defineStorageSchemaMigration({
+    id: "202610080001_add_public_status_pages",
+    description: "Add opt-in, explicitly selected public availability pages.",
+    statements
+  })
+];
+
+// ../../packages/storage/src/analytics-flow-schema.ts
+var statements2 = [
   `CREATE TABLE IF NOT EXISTS analytics_flow_definitions (
     id uuid PRIMARY KEY, project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
     flow_key text NOT NULL, version integer NOT NULL DEFAULT 1, definition jsonb NOT NULL,
@@ -108468,18 +108688,18 @@ var statements = [
   )`,
   `CREATE INDEX IF NOT EXISTS analytics_flow_rollups_expiry_idx ON analytics_flow_rollups(cohort_date, flow_id)`
 ];
-var ANALYTICS_FLOW_BOOTSTRAP_STATEMENTS = statements.map(
+var ANALYTICS_FLOW_BOOTSTRAP_STATEMENTS = statements2.map(
   (statement) => statement.replaceAll(" IF NOT EXISTS", "")
 );
 var migration = {
   id: "202610030001_add_public_analytics_flows",
   description: "Add customer project flow definitions, bounded continuity and aggregate reports.",
-  statements
+  statements: statements2
 };
 var ANALYTICS_FLOW_SCHEMA_MIGRATIONS = [defineStorageSchemaMigration(migration)];
 
 // ../../packages/storage/src/browser-recovery-schema.ts
-var statements2 = [
+var statements3 = [
   `ALTER TABLE alert_deliveries ADD COLUMN IF NOT EXISTS coalescing_key text`,
   `CREATE INDEX IF NOT EXISTS alert_deliveries_coalescing_idx ON alert_deliveries (alert_id, coalescing_key, created_at) WHERE coalescing_key IS NOT NULL`,
   `CREATE TABLE IF NOT EXISTS browser_recovery_events (
@@ -108501,10 +108721,10 @@ var BROWSER_RECOVERY_MIGRATIONS = [
   defineStorageSchemaMigration({
     id: "202609220001_add_browser_recovery_context",
     description: "Index browser recovery context and separate burst suppression from alert cooldown identity",
-    statements: statements2
+    statements: statements3
   })
 ];
-var BROWSER_RECOVERY_BOOTSTRAP_STATEMENTS = statements2.filter((statement) => !statement.startsWith("ALTER TABLE")).map((statement) => statement.replaceAll(" IF NOT EXISTS", ""));
+var BROWSER_RECOVERY_BOOTSTRAP_STATEMENTS = statements3.filter((statement) => !statement.startsWith("ALTER TABLE")).map((statement) => statement.replaceAll(" IF NOT EXISTS", ""));
 
 // ../../packages/storage/src/availability-check-bootstrap-statements.ts
 var AVAILABILITY_CHECK_BOOTSTRAP_STATEMENTS = [
@@ -110480,7 +110700,8 @@ var STORAGE_BOOTSTRAP_STATEMENTS2 = [
   ...AVAILABILITY_CHECK_BOOTSTRAP_STATEMENTS,
   ...ANALYTICS_BOOTSTRAP_STATEMENTS,
   ...WORKER_JOB_BOOTSTRAP_STATEMENTS,
-  ...ANALYTICS_FLOW_BOOTSTRAP_STATEMENTS
+  ...ANALYTICS_FLOW_BOOTSTRAP_STATEMENTS,
+  ...PUBLIC_STATUS_BOOTSTRAP_STATEMENTS
 ];
 
 // ../../packages/storage/src/migrations.ts
@@ -112695,9 +112916,18 @@ var STORAGE_SCHEMA_MIGRATIONS2 = [
   ...ANALYTICS_STORAGE_SCHEMA_MIGRATIONS,
   ...OPENAI_OAUTH_STORAGE_SCHEMA_MIGRATIONS,
   ...WORKER_JOB_SCHEMA_MIGRATIONS,
-  ...ANALYTICS_FLOW_SCHEMA_MIGRATIONS
+  ...ANALYTICS_FLOW_SCHEMA_MIGRATIONS,
+  ...PUBLIC_STATUS_SCHEMA_MIGRATIONS
 ].sort((left, right) => left.id.localeCompare(right.id));
 
+// ../../packages/storage/src/public-status-store.ts
+var eligibleQuery = buildAvailabilityChecksListQuery(
+  "p.organization_id IN (SELECT organization_id FROM page)",
+  "c.project_id IN (SELECT project_id FROM public_status_page_projects WHERE page_id IN (SELECT id FROM page)) AND c.id IN (SELECT check_id FROM public_status_page_checks WHERE page_id IN (SELECT id FROM page))",
+  "500",
+  "NULL"
+);
+
 // ../cli/src/cloud-artifact-cache.ts
 var import_promises6 = require("node:fs/promises");
 var import_node_path6 = require("node:path");
@@ -113131,15 +113361,15 @@ async function readLocalState(dependencies) {
     throw error2;
   }
 }
-async function writeLocalState(state, dependencies) {
+async function writeLocalState(state2, dependencies) {
   const rootDirectory = getWorkspaceRoot2(dependencies);
   const writeFile = dependencies?.writeFile ?? import_promises7.writeFile;
-  await writeFile(getStateFilePath(rootDirectory), `${JSON.stringify(state, null, 2)}
+  await writeFile(getStateFilePath(rootDirectory), `${JSON.stringify(state2, null, 2)}
 `, "utf8");
 }
 async function updateLocalIncidentStatus(input2, dependencies) {
-  const state = await readLocalState(dependencies);
-  const incident = state.incidents[input2.incidentId];
+  const state2 = await readLocalState(dependencies);
+  const incident = state2.incidents[input2.incidentId];
   if (incident === void 0) {
     throw createReadError(404, "incident_not_found");
   }
@@ -113148,8 +113378,8 @@ async function updateLocalIncidentStatus(input2, dependencies) {
     status: input2.status,
     ...input2.status === "resolved" ? { resolved_at: (/* @__PURE__ */ new Date()).toISOString() } : { resolved_at: null }
   };
-  state.incidents[input2.incidentId] = nextIncident;
-  await writeLocalState(state, dependencies);
+  state2.incidents[input2.incidentId] = nextIncident;
+  await writeLocalState(state2, dependencies);
   return projectLocalEvidence(nextIncident);
 }
 async function listLocalIncidents(input2, dependencies) {
@@ -117192,13 +117422,13 @@ function sortIncidentRecord(incident) {
     source_events: [...incident.source_events].sort(compareEventEnvelopes)
   };
 }
-function serializeState(state) {
+function serializeState(state2) {
   const incidents = Object.fromEntries(
-    Object.entries(state.incidents).sort(([left], [right]) => left.localeCompare(right)).map(([incidentId2, incident]) => [incidentId2, sortIncidentRecord(incident)])
+    Object.entries(state2.incidents).sort(([left], [right]) => left.localeCompare(right)).map(([incidentId2, incident]) => [incidentId2, sortIncidentRecord(incident)])
   );
   return `${JSON.stringify({
     version: 1,
-    last_processed_event_file: state.last_processed_event_file,
+    last_processed_event_file: state2.last_processed_event_file,
     incidents
   }, null, 2)}
 `;
@@ -118460,7 +118690,7 @@ async function runValidateCommand(input2, dependencies = {}) {
     }
   }
   checks.push(...agentChecks(report).filter((check5) => check5.name !== "canonical-skill"));
-  autoFixAvailable ||= report.agents.some((agent) => [agent.instruction, agent.discovery].some((state) => state === "missing" || state === "stale"));
+  autoFixAvailable ||= report.agents.some((agent) => [agent.instruction, agent.discovery].some((state2) => state2 === "missing" || state2 === "stale"));
   const ignore = await ensureGitignore(rootDirectory, buildManagedGitignoreSection(), input2.fix === true);
   const gitignoreCheck = { name: "gitignore", status: ignore.present ? "ok" : "missing", message: ignore.changed ? `Updated ${GITIGNORE_FILE_PATH}` : `${ignore.present ? "Found" : "Missing"} managed ${GITIGNORE_FILE_PATH} entries` };
   if (gitignoreCheck.status === "missing") {
@@ -119789,6 +120019,7 @@ var MCP_TOOL_CATALOG_OPERATIONS = [
 
 // src/tool-catalog.ts
 var MCP_TOOL_CATALOG = [
+  ...PUBLIC_STATUS_MCP_TOOL_CATALOG,
   ...ANALYTICS_FLOW_MCP_TOOL_CATALOG,
   ...MCP_TOOL_CATALOG_FOUNDATION,
   ...MCP_TOOL_CATALOG_OPERATIONS,
@@ -120206,6 +120437,7 @@ async function createDefaultMcpTools(input2 = {}) {
         ...createAnalyticsJourneySampleApi(httpClient)
       }),
       ...createAnalyticsSettingsMcpTools(createAnalyticsSettingsApi(httpClient)),
+      ...createPublicStatusMcpTools(createPublicStatusApi(httpClient)),
       ...createAnalyticsFlowMcpTools(createAnalyticsFlowApi(httpClient)),
       ...createAnalyticsSavedFunnelMcpTools(createAnalyticsSavedFunnelApi(httpClient)),
       ...createCaptureRuleMcpTools(createCaptureRuleApi(httpClient)),
@@ -120229,7 +120461,7 @@ var import_node_readline = require("node:readline");
 var package_default = {
   name: "@debugbundle/mcp",
   mcpName: "com.debugbundle/mcp",
-  version: "1.14.0",
+  version: "1.15.0",
   private: false,
   description: "MCP server for runtime error reporting, incident response, health checks, debug bundles, and product analytics",
   license: "Apache-2.0",