@debugbundle/cli 1.14.0 → 1.16.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 output2 = nodeUtil.formatWithOptions(options, state);
+        const output2 = nodeUtil.formatWithOptions(options, state2);
         return `FormData ${output2.slice(output2.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();
           }
@@ -74592,6 +74592,136 @@ var CaptureRulesFileSchema = external_exports.object({
   rules: external_exports.array(CaptureRuleSchema)
 });
 
+// ../../packages/shared-types/src/browser-resource-providers.ts
+var PROVIDERS = [
+  {
+    name: "Google Tag Manager",
+    role: "tag_manager",
+    hosts: ["www.googletagmanager.com"],
+    paths: ["/gtm.js"]
+  },
+  {
+    name: "Google tag (Analytics / Ads)",
+    role: "analytics",
+    hosts: ["www.googletagmanager.com"],
+    paths: ["/gtag/js"]
+  },
+  {
+    name: "Google Analytics",
+    role: "analytics",
+    hosts: ["www.google-analytics.com", "ssl.google-analytics.com"],
+    paths: ["/analytics.js", "/ga.js"]
+  },
+  {
+    name: "Meta Pixel",
+    role: "advertising",
+    hosts: ["connect.facebook.net"],
+    paths: [/^\/[a-z]{2}_[A-Z]{2}\/fbevents\.js$/]
+  },
+  {
+    name: "Microsoft Clarity",
+    role: "analytics",
+    hosts: ["www.clarity.ms"],
+    paths: [/^\/tag\/[A-Za-z0-9]+$/]
+  },
+  {
+    name: "Hotjar",
+    role: "analytics",
+    hosts: ["static.hotjar.com"],
+    paths: [/^\/c\/hotjar-[0-9]+\.js$/]
+  },
+  {
+    name: "Cloudflare Web Analytics",
+    role: "analytics",
+    hosts: ["static.cloudflareinsights.com"],
+    paths: ["/beacon.min.js"]
+  },
+  {
+    name: "Yandex Metrica",
+    role: "analytics",
+    hosts: ["mc.yandex.ru", "mc.yandex.com"],
+    paths: ["/metrika/tag.js"]
+  },
+  {
+    name: "WordPress.com / Jetpack Stats",
+    role: "analytics",
+    hosts: ["stats.wp.com"],
+    paths: [/^\/e-[0-9]{6}\.js$/]
+  },
+  {
+    name: "Microsoft Advertising UET",
+    role: "advertising",
+    hosts: ["bat.bing.com"],
+    paths: ["/bat.js"]
+  },
+  {
+    name: "LinkedIn Insight",
+    role: "advertising",
+    hosts: ["snap.licdn.com"],
+    paths: ["/li.lms-analytics/insight.min.js"]
+  },
+  {
+    name: "TikTok Pixel",
+    role: "advertising",
+    hosts: ["analytics.tiktok.com"],
+    paths: ["/i18n/pixel/events.js"]
+  },
+  { name: "Pinterest Tag", role: "advertising", hosts: ["s.pinimg.com"], paths: ["/ct/core.js"] },
+  {
+    name: "X Pixel",
+    role: "advertising",
+    hosts: ["static.ads-twitter.com", "platform.twitter.com"],
+    paths: ["/uwt.js", "/oct.js"]
+  },
+  {
+    name: "Segment",
+    role: "analytics",
+    hosts: ["cdn.segment.com"],
+    paths: [/^\/analytics\.js\/v1\/[A-Za-z0-9_-]+\/analytics\.min\.js$/]
+  },
+  {
+    name: "Mixpanel",
+    role: "analytics",
+    hosts: ["cdn.mxpnl.com"],
+    paths: ["/libs/mixpanel-2-latest.min.js", "/libs/mixpanel-js/dist/mixpanel.module.js"]
+  },
+  {
+    name: "Amplitude",
+    role: "analytics",
+    hosts: ["cdn.amplitude.com"],
+    paths: [
+      /^\/libs\/analytics-browser-[0-9]+\.[0-9]+\.[0-9]+-min\.js(?:\.gz)?$/,
+      /^\/script\/[A-Za-z0-9_-]+\.js$/
+    ]
+  },
+  {
+    name: "PostHog",
+    role: "analytics",
+    hosts: ["us-assets.i.posthog.com", "eu-assets.i.posthog.com", "app.posthog.com"],
+    paths: ["/static/array.js"]
+  },
+  {
+    name: "Plausible",
+    role: "analytics",
+    hosts: ["plausible.io"],
+    paths: [/^\/js\/pa-[A-Za-z0-9_-]+\.js$/, /^\/js\/script(?:\.[a-z-]+)*\.js$/]
+  },
+  {
+    name: "Google sign-in",
+    role: "authentication",
+    hosts: ["accounts.google.com"],
+    paths: ["/gsi/client"]
+  }
+];
+function identifyBrowserResourceProvider(host, path) {
+  if (host === null) return null;
+  return PROVIDERS.find(
+    (provider) => provider.hosts.includes(host) && provider.paths.some(
+      (pattern) => typeof pattern === "string" ? path === pattern : pattern.test(path)
+    )
+  ) ?? null;
+}
+
 // ../../packages/shared-types/src/browser-resource.ts
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -74650,18 +74780,10 @@ function describeBrowserResource(value) {
   let role = location.first_party === true ? "application_asset" : "unknown";
   let provider = null;
   if (type === "script") {
-    if (location.host === "www.googletagmanager.com" && location.path === "/gtm.js") {
-      provider = "Google Tag Manager";
-      role = "tag_manager";
-    } else if (location.host === "connect.facebook.net" && /^\/[a-z]{2}_[A-Z]{2}\/fbevents\.js$/.test(location.path)) {
-      provider = "Meta Pixel";
-      role = "advertising";
-    } else if (location.host === "www.clarity.ms" && /^\/tag\/[A-Za-z0-9]+$/.test(location.path)) {
-      provider = "Microsoft Clarity";
-      role = "analytics";
-    } else if (location.host === "accounts.google.com" && location.path === "/gsi/client") {
-      provider = "Google sign-in";
-      role = "authentication";
+    const recognized = identifyBrowserResourceProvider(location.host, location.path);
+    if (recognized !== null) {
+      provider = recognized.name;
+      role = recognized.role;
     }
   }
   const file = location.path.split("/").filter(Boolean).at(-1) ?? location.path;
@@ -74685,7 +74807,8 @@ function describeBrowserResourceInterruption(value) {
   const readyState = page?.["ready_state"];
   const tag2 = typeof target?.["tag_name"] === "string" ? target["tag_name"].toLowerCase() : null;
   const rel = typeof attributes?.["rel"] === "string" ? attributes["rel"].trim().toLowerCase() : null;
-  if (visibility !== "hidden" && visibility !== "prerender" && visibility !== "unloaded" || readyState !== "loading" && readyState !== "interactive" || tag2 !== "link" || rel !== "preload" && rel !== "modulepreload" && rel !== "prefetch") return null;
+  if (visibility !== "hidden" && visibility !== "prerender" && visibility !== "unloaded" || readyState !== "loading" && readyState !== "interactive" || tag2 !== "link" || rel !== "preload" && rel !== "modulepreload" && rel !== "prefetch")
+    return null;
   return {
     visibility_state: visibility,
     ready_state: readyState,
@@ -75746,6 +75869,71 @@ var AnalyticsMetricsQuerySchema = external_exports.object({
   limit: external_exports.coerce.number().int().min(1).max(100).optional().default(10)
 }).strict();
 
+// ../../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/shared-types/src/index.ts
 var SeveritySchema = external_exports.enum(["low", "medium", "high", "critical"]);
 var BundleSdkSchema = external_exports.object({
@@ -76210,7 +76398,7 @@ function buildSkill() {
     "",
     "- Inspect the primary failure and routes: one resource can span pages, route coverage may be incomplete, and historical incidents stay separate. Related tracker evidence does not explain an application exception.",
     '- If the cause is unknown, say "possibly blocked by privacy tools." Network/CSP/provider failures remain possible; provider recognition proves neither Pi-hole blocking nor optionality.',
-    "- Review exact host/path, service, environment and opaque resource-error scope; never widen to a whole host. Google sign-in, app assets and unknown dependencies have no automatic resource noise recommendation.",
+    "- Review exact resource host/path/type, service, environment and opacity, or the returned exact fingerprint when evidence is incomplete; never widen to a whole host. All resource incidents can offer explicit controls. Provider recognition does not establish that a dependency is optional; do not suppress authentication, app assets or unknown dependencies automatically.",
     "- For confirmed optional dependencies, context (demote) retains diagnostics without new incidents/alerts/automation and may remain billable. Drop discards future matches; choose it only when evidence has no diagnostic value. Explain the tradeoff; neither deletes history. Use the returned suggestion ID.",
     "- Check existing/disabled rules. Empty suggestions or pending/failed bundles do not justify broader rules. Applying requires user authorization and owner/admin access; preview is read-only. Verify subsequent matching and protected captures before claiming improvement; live tests need authorization.",
     "- The official OpenAI connection cannot suggest or apply rules. When it is the only connection, review returned evidence and hand off through a returned safe dashboard URL; never invent tools or switch credentials.",
@@ -77311,76 +77499,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,
@@ -77390,7 +77578,7 @@ function sanitizeValue(value, state, depth, allowStructured) {
     }
     return result;
   } finally {
-    state.seen.delete(value);
+    state2.seen.delete(value);
   }
 }
 function sanitizeTelemetry(value, options = {}) {
@@ -77403,7 +77591,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,
@@ -77412,11 +77600,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" };
   }
@@ -84630,8 +84818,8 @@ async function readAgentAuthState(filePath = agentAuthFilePath()) {
     throw new Error("agent_auth_unavailable");
   }
 }
-async function persistAgentAuthState(state, filePath = agentAuthFilePath()) {
-  const parsed = AgentAuthSchema.parse(state);
+async function persistAgentAuthState(state2, filePath = agentAuthFilePath()) {
+  const parsed = AgentAuthSchema.parse(state2);
   await (0, import_promises7.mkdir)((0, import_node_path7.dirname)(filePath), { recursive: true, mode: 448 });
   const tmp = `${filePath}.${(0, import_node_crypto2.randomUUID)()}.tmp`;
   const file = await (0, import_promises7.open)(tmp, "wx", 384);
@@ -93219,19 +93407,19 @@ var err_out_default = ({
   message: message3,
   error_description: description,
   scope
-}, state) => {
+}, state2) => {
   if (expose) {
     return {
       error: message3,
       ...description !== void 0 ? { error_description: description } : void 0,
       ...scope !== void 0 ? { scope } : void 0,
-      ...state !== void 0 ? { state } : 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
   };
 };
 
@@ -93345,8 +93533,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);
@@ -97157,7 +97345,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 }
@@ -97166,7 +97354,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);
@@ -97183,8 +97371,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) {
@@ -97202,24 +97390,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);
@@ -98839,8 +99027,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;
@@ -101907,9 +102095,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,
@@ -101956,8 +102145,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
@@ -101968,10 +102157,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
@@ -103280,8 +103474,41 @@ function defineStorageSchemaMigration(input3) {
   };
 }
 
-// ../../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,
@@ -103314,18 +103541,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 (
@@ -103347,10 +103574,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 = [
@@ -105326,7 +105553,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
@@ -107541,9 +107769,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"
+);
+
 // src/local-retrieval-store.ts
 var CONNECTION_FILE_PATH2 = ".debugbundle/local/connection.json";
 var STATE_FILE_PATH = ".debugbundle/local/state.json";
@@ -107743,15 +107980,15 @@ async function readLocalState(dependencies) {
     throw error2;
   }
 }
-async function writeLocalState(state, dependencies) {
+async function writeLocalState(state2, dependencies) {
   const rootDirectory = getWorkspaceRoot(dependencies);
   const writeFile = dependencies?.writeFile ?? import_promises9.writeFile;
-  await writeFile(getStateFilePath(rootDirectory), `${JSON.stringify(state, null, 2)}
+  await writeFile(getStateFilePath(rootDirectory), `${JSON.stringify(state2, null, 2)}
 `, "utf8");
 }
 async function updateLocalIncidentStatus(input3, dependencies) {
-  const state = await readLocalState(dependencies);
-  const incident = state.incidents[input3.incidentId];
+  const state2 = await readLocalState(dependencies);
+  const incident = state2.incidents[input3.incidentId];
   if (incident === void 0) {
     throw createReadError(404, "incident_not_found");
   }
@@ -107760,8 +107997,8 @@ async function updateLocalIncidentStatus(input3, dependencies) {
     status: input3.status,
     ...input3.status === "resolved" ? { resolved_at: (/* @__PURE__ */ new Date()).toISOString() } : { resolved_at: null }
   };
-  state.incidents[input3.incidentId] = nextIncident;
-  await writeLocalState(state, dependencies);
+  state2.incidents[input3.incidentId] = nextIncident;
+  await writeLocalState(state2, dependencies);
   return projectLocalEvidence(nextIncident);
 }
 async function listLocalIncidents(input3, dependencies) {
@@ -108094,8 +108331,8 @@ async function cleanProcessedEventFiles(input3, dependencies) {
   const stat = dependencies.stat ?? import_promises11.stat;
   const rootDirectory = (dependencies.cwd ?? process.cwd)();
   const eventsDirectoryPath = (0, import_node_path11.join)(rootDirectory, LOCAL_EVENTS_DIRECTORY_PATH);
-  const state = await readLocalState(dependencies);
-  const lastProcessedEventFile = state.last_processed_event_file;
+  const state2 = await readLocalState(dependencies);
+  const lastProcessedEventFile = state2.last_processed_event_file;
   let eventFileNames;
   try {
     eventFileNames = (await readdir(eventsDirectoryPath)).filter((fileName) => fileName.endsWith(".events.json")).sort();
@@ -108181,8 +108418,8 @@ function sortLocalIncidentRemovalPriority(left, right) {
 async function applyLocalIncidentRetention(dependencies) {
   const rm = dependencies.rm ?? import_promises11.rm;
   const rootDirectory = (dependencies.cwd ?? process.cwd)();
-  const state = await readLocalState(dependencies);
-  const incidents = Object.values(state.incidents);
+  const state2 = await readLocalState(dependencies);
+  const incidents = Object.values(state2.incidents);
   if (incidents.length <= LOCAL_INCIDENT_RETENTION_LIMIT) {
     return {
       removed: 0,
@@ -108190,7 +108427,7 @@ async function applyLocalIncidentRetention(dependencies) {
     };
   }
   const incidentsToRemove = incidents.slice().sort(sortLocalIncidentRemovalPriority).slice(0, incidents.length - LOCAL_INCIDENT_RETENTION_LIMIT);
-  const nextIncidents = { ...state.incidents };
+  const nextIncidents = { ...state2.incidents };
   for (const incident of incidentsToRemove) {
     delete nextIncidents[incident.incident_id];
     await rm(resolveWorkspacePath(rootDirectory, incident.bundle_path), { force: true });
@@ -108198,7 +108435,7 @@ async function applyLocalIncidentRetention(dependencies) {
   }
   await writeLocalState(
     {
-      ...state,
+      ...state2,
       incidents: nextIncidents
     },
     dependencies
@@ -110403,14 +110640,14 @@ async function promptForInteractiveLoginSelection() {
       ].join("\n") + "\n"
     );
     for (; ; ) {
-      const selection = (await readlineInterface.question("Selection [1-4]: ")).trim();
-      if (selection === "1") {
+      const selection2 = (await readlineInterface.question("Selection [1-4]: ")).trim();
+      if (selection2 === "1") {
         return { kind: "github" };
       }
-      if (selection === "2") {
+      if (selection2 === "2") {
         return { kind: "github-device" };
       }
-      if (selection === "3") {
+      if (selection2 === "3") {
         const bearerToken = (await readlineInterface.question("Paste your member token: ")).trim();
         if (bearerToken.length > 0) {
           return {
@@ -110421,7 +110658,7 @@ async function promptForInteractiveLoginSelection() {
         import_node_process.stdout.write("Member token cannot be empty.\n");
         continue;
       }
-      if (selection === "4") {
+      if (selection2 === "4") {
         return { kind: "cancel" };
       }
       import_node_process.stdout.write("Enter 1, 2, 3, or 4.\n");
@@ -110551,20 +110788,20 @@ async function maybePromptForLoginInput(input3, dependencies) {
   if (!interactive) {
     return input3;
   }
-  const selection = await (dependencies?.promptForInteractiveLogin ?? promptForInteractiveLoginSelection)();
-  if (selection.kind === "cancel") {
+  const selection2 = await (dependencies?.promptForInteractiveLogin ?? promptForInteractiveLoginSelection)();
+  if (selection2.kind === "cancel") {
     return {
       exitCode: 4,
       output: "Authentication cancelled."
     };
   }
-  if (selection.kind === "member-token") {
+  if (selection2.kind === "member-token") {
     return {
       ...input3,
-      bearerToken: selection.bearerToken
+      bearerToken: selection2.bearerToken
     };
   }
-  if (selection.kind === "github-device") {
+  if (selection2.kind === "github-device") {
     return {
       ...input3,
       githubDevice: true
@@ -114057,13 +114294,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(([incidentId, incident]) => [incidentId, sortIncidentRecord(incident)])
+    Object.entries(state2.incidents).sort(([left], [right]) => left.localeCompare(right)).map(([incidentId, incident]) => [incidentId, 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)}
 `;
@@ -117910,6 +118147,10 @@ var CLI_USAGE_LINES = [
   "  debugbundle probe activate <project-id> --label-pattern <pattern> [--service <name>] [--environment <name>] [--ttl-seconds <n>] [--trigger-ttl-seconds <n>] [--auth-file <path>] [--json]",
   "  debugbundle probe list <project-id> [--auth-file <path>] [--json]",
   "  debugbundle probe deactivate <project-id> <activation-id> [--auth-file <path>] [--json]",
+  "  debugbundle health status get --project-id <id> [--auth-file <path>] [--json]",
+  "  debugbundle health status save --project-id <id> --settings-json <json> [--auth-file <path>] [--json]",
+  "  debugbundle health status options --project-id <id> [--cursor <project-id> | --check-project-id <project-id> [--check-cursor <check-id>]] [--auth-file <path>] [--json]",
+  "  debugbundle health status preview --project-id <id> [--auth-file <path>] [--json]",
   "  debugbundle health checks list --project-id <id> [--limit <n>] [--auth-file <path>] [--json]",
   "  debugbundle health checks get <check-id> --project-id <id> [--auth-file <path>] [--json]",
   "  debugbundle health checks create --project-id <id> --name <name> --url <url> --interval-seconds <n> [--method <GET|HEAD>] [--expected-status-min <code>] [--expected-status-max <code>] [--timeout-ms <n>] [--failure-threshold <n>] [--recovery-threshold <n>] [--environment <name>] [--service <name|null>] [--enabled <true|false>] [--auth-file <path>] [--json]",
@@ -118091,7 +118332,7 @@ async function runValidateCommand(input3, 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(), input3.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") {
@@ -123238,6 +123479,142 @@ async function handleTokenCommand(parsedArgv, dependencies) {
   throw new CliInputError("Unknown token command.");
 }
 
+// src/public-status-commands.ts
+var PublicStatusApiError = class extends Error {
+  constructor(status, message3) {
+    super(message3);
+    this.status = status;
+  }
+};
+function createPublicStatusApi(http) {
+  const path = (scope) => `/v1/projects/${encodeURIComponent(external_exports.string().uuid().parse(scope.projectId))}/status-page`;
+  async function request(input3, schema) {
+    const result = await http.request(input3);
+    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: (scope) => request(
+      { method: "GET", path: path(scope), bearerToken: scope.bearerToken },
+      PublicStatusManagementSchema
+    ),
+    save: (scope) => request(
+      {
+        method: "PUT",
+        path: path(scope),
+        bearerToken: scope.bearerToken,
+        body: PublicStatusSettingsSchema.parse(scope.settings)
+      },
+      PublicStatusManagementSchema
+    ),
+    options: (scope) => {
+      const query = PublicStatusOptionsQuerySchema.parse({
+        ...scope.cursor ? { cursor: scope.cursor } : {},
+        ...scope.check_project_id ? { check_project_id: scope.check_project_id } : {},
+        ...scope.check_cursor ? { check_cursor: scope.check_cursor } : {}
+      });
+      const params = new URLSearchParams(
+        Object.entries(query).filter(
+          (entry) => typeof entry[1] === "string"
+        )
+      ).toString();
+      return request(
+        {
+          method: "GET",
+          path: `${path(scope)}/options${params ? `?${params}` : ""}`,
+          bearerToken: scope.bearerToken
+        },
+        PublicStatusOptionsSchema
+      );
+    },
+    preview: (scope) => request(
+      { method: "GET", path: `${path(scope)}/preview`, bearerToken: scope.bearerToken },
+      PublicStatusPageSchema
+    )
+  };
+}
+async function publicStatusWithAuthCommand(input3, dependencies) {
+  return runAuthenticatedCliCommand(input3, {
+    dependencies,
+    async createApi(authInput, deps) {
+      const authState = await (deps?.readAuthState ?? readCliAuthState)(authInput);
+      return {
+        authState,
+        api: createPublicStatusApi(
+          (deps?.createHttpClient ?? createCliHttpClient)({ baseUrl: authState.base_url })
+        )
+      };
+    },
+    async runCommand(auth, api) {
+      try {
+        const scope = { projectId: input3.projectId, bearerToken: auth.bearer_token };
+        const result = input3.action === "save" ? await api.save({
+          ...scope,
+          settings: PublicStatusSettingsSchema.parse(input3.settings)
+        }) : input3.action === "options" ? await api.options({
+          ...scope,
+          ...input3.cursor ? { cursor: input3.cursor } : {},
+          ...input3.check_project_id ? { check_project_id: input3.check_project_id } : {},
+          ...input3.check_cursor ? { check_cursor: input3.check_cursor } : {}
+        }) : input3.action === "preview" ? await api.preview(scope) : await api.get(scope);
+        return { exitCode: 0, output: JSON.stringify(result, null, input3.json ? void 0 : 2) };
+      } catch (error2) {
+        return {
+          exitCode: error2 instanceof PublicStatusApiError ? error2.status === 401 ? 2 : error2.status === 404 ? 3 : [400, 403, 409].includes(error2.status) ? 4 : 1 : error2 instanceof external_exports.ZodError ? 4 : 1,
+          output: error2 instanceof Error ? error2.message : "Status request failed."
+        };
+      }
+    }
+  });
+}
+
+// src/management-status-command-handler.ts
+async function handleStatusCommand(parsed, dependencies) {
+  const action = requirePositional(parsed, 2, "action");
+  if (!["get", "save", "options", "preview"].includes(action))
+    throw new CliInputError("Unknown health status command.");
+  expectNoUnknownOptions(parsed, [
+    "project-id",
+    "auth-file",
+    "json",
+    ...action === "save" ? ["settings-json"] : action === "options" ? ["cursor", "check-project-id", "check-cursor"] : []
+  ]);
+  ensureNoExtraPositionals(parsed, 3);
+  const projectId = readStringOption(parsed, "project-id");
+  if (!projectId) throw new CliInputError("Missing required option --project-id.");
+  let settings;
+  if (action === "save") {
+    try {
+      settings = PublicStatusSettingsSchema.parse(
+        JSON.parse(readStringOption(parsed, "settings-json") ?? "null")
+      );
+    } catch {
+      throw new CliInputError(
+        "--settings-json must contain a title, enabled flag and explicit project/check selections."
+      );
+    }
+  }
+  const cursor = readStringOption(parsed, "cursor");
+  const checkProjectId = readStringOption(parsed, "check-project-id");
+  const checkCursor = readStringOption(parsed, "check-cursor");
+  return (dependencies.publicStatusCommand ?? publicStatusWithAuthCommand)(
+    appendCommonAuthOptions(parsed, {
+      action,
+      projectId,
+      ...settings === void 0 ? {} : { settings },
+      ...cursor === void 0 ? {} : { cursor },
+      ...checkProjectId === void 0 ? {} : { check_project_id: checkProjectId },
+      ...checkCursor === void 0 ? {} : { check_cursor: checkCursor }
+    })
+  );
+}
+
 // src/health-check-commands.ts
 var HealthCheckApiError = class extends Error {
   status;
@@ -123825,6 +124202,7 @@ function readRequiredName(parsedArgv) {
 }
 async function handleHealthCommand(parsedArgv, dependencies) {
   const resource = requirePositional(parsedArgv, 1, "resource");
+  if (resource === "status") return handleStatusCommand(parsedArgv, dependencies);
   if (resource !== "checks") {
     throw new CliInputError("Unknown health command.");
   }
@@ -126953,7 +127331,7 @@ async function handleCaptureRuleCommand2(parsedArgv, dependencies) {
 // package.json
 var package_default = {
   name: "@debugbundle/cli",
-  version: "1.14.0",
+  version: "1.16.0",
   private: false,
   description: "Command-line interface for DebugBundle",
   license: "Apache-2.0",