@jeffusion/bungee-core 5.4.2 → 5.4.3

package/dist/main.js

@@ -12955,7 +12955,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@jeffusion/bungee-core",
-    version: "5.4.2",
+    version: "5.4.3",
     description: "Bungee reverse proxy core engine",
     main: "./dist/main.js",
     types: "./dist/main.d.ts",
@@ -30326,7 +30326,7 @@ class AccessLogWriter {
       entry.protocolOutcome = pendingOutcome.outcome;
       entry.protocolCode = pendingOutcome.code;
       entry.success = pendingOutcome.success;
-      entry.errorMessage ??= pendingOutcome.errorMessage;
+      entry.errorMessage = pendingOutcome.detailed ? pendingOutcome.errorMessage : entry.errorMessage ?? pendingOutcome.errorMessage;
     }
     this.writeQueue.push(entry);
     if (this.writeQueue.length >= 100) {
@@ -30392,7 +30392,7 @@ class AccessLogWriter {
           entry.protocolOutcome = pendingOutcome.outcome;
           entry.protocolCode = pendingOutcome.code;
           entry.success = pendingOutcome.success;
-          entry.errorMessage ??= pendingOutcome.errorMessage;
+          entry.errorMessage = pendingOutcome.detailed ? pendingOutcome.errorMessage : entry.errorMessage ?? pendingOutcome.errorMessage;
         }
         this.db.run("SAVEPOINT access_log_entry");
         try {
@@ -30479,7 +30479,7 @@ class AccessLogWriter {
       });
     }
   }
-  updateProtocolOutcome(requestId, outcome, success, code) {
+  updateProtocolOutcome(requestId, outcome, success, code, diagnosticMessage) {
     if (!requestId)
       return;
     if (!this.pendingProtocolOutcomeUpdates.has(requestId) && this.pendingProtocolOutcomeUpdates.size >= AccessLogWriter.MAX_PENDING_UPDATES) {
@@ -30487,18 +30487,19 @@ class AccessLogWriter {
       if (oldest)
         this.pendingProtocolOutcomeUpdates.delete(oldest);
     }
-    const errorMessage = outcome === "failed" || outcome === "incomplete" ? `Response stream ${outcome}${code ? ` (${code})` : ""}` : undefined;
-    this.pendingProtocolOutcomeUpdates.set(requestId, { outcome, success, code, errorMessage });
+    const errorMessage = diagnosticMessage ?? (outcome === "failed" || outcome === "incomplete" ? `Response stream ${outcome}${code ? ` (${code})` : ""}` : undefined);
+    const detailed = diagnosticMessage !== undefined;
+    this.pendingProtocolOutcomeUpdates.set(requestId, { outcome, success, code, errorMessage, detailed });
     for (const entry of this.writeQueue) {
       if (entry.requestId === requestId) {
         entry.protocolOutcome = outcome;
         entry.protocolCode = code;
         entry.success = success;
-        entry.errorMessage ??= errorMessage;
+        entry.errorMessage = detailed ? errorMessage : entry.errorMessage ?? errorMessage;
       }
     }
     try {
-      const result = this.db.query("UPDATE access_logs SET protocol_outcome = ?, protocol_code = ?, success = ?, error_message = COALESCE(error_message, ?) WHERE request_id = ?").run(outcome, code || null, success ? 1 : 0, errorMessage ?? null, requestId);
+      const result = this.db.query("UPDATE access_logs SET protocol_outcome = ?, protocol_code = ?, success = ?, error_message = CASE WHEN ? THEN ? ELSE COALESCE(error_message, ?) END WHERE request_id = ?").run(outcome, code || null, success ? 1 : 0, detailed ? 1 : 0, errorMessage ?? null, errorMessage ?? null, requestId);
       if (result.changes > 0)
         this.pendingProtocolOutcomeUpdates.delete(requestId);
     } catch (error) {
@@ -34917,6 +34918,13 @@ var init_plugin_manager = __esm(() => {
 });
 
 // src/logger/request-logger.ts
+function diagnosticMessage(error) {
+  if (!error)
+    return;
+  const kind = [error.code, error.type].filter(Boolean).join(" / ");
+  return `[${error.source}] ${kind ? `${kind}: ` : ""}${error.message}`;
+}
+
 class RequestLogger {
   requestId;
   startTime;
@@ -34941,6 +34949,7 @@ class RequestLogger {
   completionPromise = null;
   fileLogEntry = null;
   fileLogWritten = false;
+  protocolError;
   dependencies;
   constructor(req, failoverOptions, dependencies = {}) {
     this.dependencies = {
@@ -35062,6 +35071,10 @@ class RequestLogger {
     if (this.originalRequestBody && this.dependencies.bodyStorage) {
       originalReqBodyId = await this.saveBody(this.originalRequestBody, "original-request");
     }
+    const protocolError = options?.protocolError ?? this.protocolError;
+    const errorMessage = diagnosticMessage(protocolError) ?? options?.errorMessage;
+    if (protocolError)
+      this.addStep("response_error", protocolError);
     const logEntry = {
       requestId: this.requestId,
       timestamp: this.startTime,
@@ -35086,7 +35099,8 @@ class RequestLogger {
       protocolOutcome: options?.protocolOutcome,
       protocolCode: options?.protocolCode,
       success: options?.success,
-      ...options
+      ...options,
+      errorMessage
     };
     this.fileLogEntry = {
       requestId: this.requestId,
@@ -35102,7 +35116,7 @@ class RequestLogger {
       transformedPath: this.transformedPath || undefined,
       authSuccess: options?.authSuccess,
       authLevel: options?.authLevel,
-      errorMessage: options?.errorMessage,
+      errorMessage,
       reqBodyId: reqBodyId || undefined,
       respBodyId: respBodyId || undefined,
       reqHeaderId: reqHeaderId || undefined,
@@ -35161,8 +35175,9 @@ class RequestLogger {
   updateStreamResponseBodyId(bodyId) {
     this.dependencies.accessLogWriter.updateResponseBodyId(this.requestId, bodyId);
   }
-  updateProtocolOutcome(outcome, success, code) {
-    this.dependencies.accessLogWriter.updateProtocolOutcome(this.requestId, outcome, success, code);
+  updateProtocolOutcome(outcome, success, code, error) {
+    this.protocolError = error;
+    this.dependencies.accessLogWriter.updateProtocolOutcome(this.requestId, outcome, success, code, diagnosticMessage(error));
   }
   getRequestId() {
     return this.requestId;
@@ -37430,6 +37445,9 @@ function immutableSnapshot(value) {
 function isSafeUpstreamHttpError(originalResponse, originalStatus, rawResponse, finalResponse, completion) {
   return (originalStatus < 200 || originalStatus >= 300) && rawResponse.response !== originalResponse && rawResponse.response.status === originalStatus && finalResponse.status === originalStatus && (originalResponse.body === null || originalResponse.bodyUsed) && completion.status === "failed" && completion.code === "upstream_http_error";
 }
+function isSafeAdaptedErrorResponse(originalResponse, rawResponse, finalResponse, completion) {
+  return completion.status === "failed" && completion.error !== undefined && rawResponse.response !== originalResponse && (originalResponse.body === null || originalResponse.bodyUsed) && rawResponse.response.status >= 400 && rawResponse.response.status < 600 && finalResponse.status === rawResponse.response.status && rawResponse.response.headers.get("content-type")?.split(";", 1)[0].trim().toLowerCase() === "application/json";
+}
 function inspectManagedCredential(upstream) {
   const endpoint = upstream;
   if (!isManagedBy(endpoint.managedBy))
@@ -37947,6 +37965,7 @@ async function proxyRequest(requestSnapshot, route, upstream, requestLog, config
     redirect: "manual",
     keepalive: true,
     verbose: false,
+    timeout: false,
     signal: attemptSignal
   };
   try {
@@ -37983,6 +38002,7 @@ async function proxyRequest(requestSnapshot, route, upstream, requestLog, config
         redirect: fetchOptions.redirect,
         keepalive: fetchOptions.keepalive,
         verbose: fetchOptions.verbose,
+        timeout: fetchOptions.timeout,
         hasBody: Boolean(fetchOptions.body),
         headerCount
       },
@@ -38149,7 +38169,8 @@ async function proxyRequest(requestSnapshot, route, upstream, requestLog, config
         routeId,
         upstreamId: upstream_id,
         attemptId: attemptOptions?.attemptId ?? requestId,
-        signal: attemptSignal
+        signal: attemptSignal,
+        redactDiagnostic: (message) => sanitizeMessage(message, credentialSecrets)
       }), attemptSignal, (lateResult) => {
         if (lateResult.response.body)
           lateResult.response.body.cancel("request aborted").catch(() => {
@@ -38246,7 +38267,7 @@ async function proxyRequest(requestSnapshot, route, upstream, requestLog, config
       transportCompletion.settle({ status: "completed" });
       const outcome = await abortable(strictCompletion, attemptSignal);
       logger.info({ request: requestLog, httpStatus: proxyRes.status, protocolOutcome: outcome.status }, "Upstream response protocol completed");
-      if (outcome.status !== "completed" && !isSafeUpstreamHttpError(originalResponse, originalStatus, rawResponse, proxyRes, outcome)) {
+      if (outcome.status !== "completed" && !isSafeUpstreamHttpError(originalResponse, originalStatus, rawResponse, proxyRes, outcome) && !isSafeAdaptedErrorResponse(originalResponse, rawResponse, proxyRes, outcome)) {
         throw new Error(`raw response completed with ${outcome.status}:${"code" in outcome ? outcome.code : ""}`);
       }
     }
@@ -41049,7 +41070,7 @@ async function handleRequest(req, config, runtimeContextOrSelector = {}, selecto
           result.streamCompletionState.clientCancelled = outcome.status === "cancelled";
           result.streamCompletionState.interrupted = outcome.status === "failed" || outcome.status === "incomplete";
         }
-        attemptLogger.updateProtocolOutcome(outcome.status, persistedSuccess, "code" in outcome ? outcome.code : undefined);
+        attemptLogger.updateProtocolOutcome(outcome.status, persistedSuccess, "code" in outcome ? outcome.code : undefined, "error" in outcome ? outcome.error : undefined);
         try {
           await onOutcome?.(outcome);
         } finally {
@@ -41595,6 +41616,7 @@ async function handleRequest(req, config, runtimeContextOrSelector = {}, selecto
             errorMessage: result.response.status >= 400 ? `Upstream returned error status: ${result.response.status}` : undefined,
             protocolOutcome: outcome.status,
             protocolCode: "code" in outcome ? outcome.code : undefined,
+            protocolError: "error" in outcome ? outcome.error : undefined,
             success: outcome.status === "completed" && result.response.status < 400
           });
         } catch (logError) {
@@ -41610,6 +41632,7 @@ async function handleRequest(req, config, runtimeContextOrSelector = {}, selecto
             upstream: selectedUpstream.target,
             protocolOutcome: outcome.status,
             protocolCode: "code" in outcome ? outcome.code : undefined,
+            protocolError: "error" in outcome ? outcome.error : undefined,
             success: outcome.status === "completed" && result.response.status < 400
           });
         } catch (logError) {
@@ -41810,6 +41833,7 @@ async function handleRequest(req, config, runtimeContextOrSelector = {}, selecto
                 errorMessage: result.response.status >= 400 ? `Upstream returned error status: ${result.response.status}` : undefined,
                 protocolOutcome: outcome.status,
                 protocolCode: "code" in outcome ? outcome.code : undefined,
+                protocolError: "error" in outcome ? outcome.error : undefined,
                 success: outcome.status === "completed" && result.response.status < 400
               });
             } catch (logError) {
@@ -41837,6 +41861,7 @@ async function handleRequest(req, config, runtimeContextOrSelector = {}, selecto
                 upstream: selectedUpstream.target,
                 protocolOutcome: outcome.status,
                 protocolCode: "code" in outcome ? outcome.code : undefined,
+                protocolError: "error" in outcome ? outcome.error : undefined,
                 success: outcome.status === "completed" && result.response.status < 400
               });
             } catch (logError) {
@@ -41864,6 +41889,7 @@ async function handleRequest(req, config, runtimeContextOrSelector = {}, selecto
             errorMessage: `Upstream returned retryable status code: ${result.response.status}`,
             protocolOutcome: outcome.status,
             protocolCode: "code" in outcome ? outcome.code : undefined,
+            protocolError: "error" in outcome ? outcome.error : undefined,
             success: false
           });
         } catch (logError) {

package/dist/plugins/chatgpt-oauth/index.js

@@ -14823,15 +14823,47 @@ function definePlugin(plugin) {
   return plugin;
 }
 
+// plugins/chatgpt-oauth/server/error-diagnostics.ts
+var MAX_MESSAGE_CHARS = 1024;
+function errorDiagnostic(value, source, fallback, redact) {
+  const object = value !== null && typeof value === "object" ? value : {};
+  const clean = (value) => {
+    let text = value.slice(0, 16384);
+    text = redact?.(text) ?? text;
+    text = text.replace(/\bBearer\s+[^\s,;"'<>]+/gi, "Bearer [REDACTED]").replace(/\b(?:sk-[\w-]+|eyJ[\w-]+\.[\w-]+\.[\w-]+)/g, "[REDACTED]").replace(/((?:authorization|access_token|refresh_token|id_token|api[_-]?key|cookie)["']?\s*[=:]\s*["']?)[^\s,;&"'<>]+/gi, "$1[REDACTED]").replace(/[\x00-\x1f\x7f]+/g, " ");
+    return text.slice(0, MAX_MESSAGE_CHARS).trim();
+  };
+  const identifier = (value) => {
+    if (typeof value !== "string")
+      return;
+    const text = clean(value);
+    return /^[a-zA-Z0-9_.-]{1,128}$/.test(text) ? text : undefined;
+  };
+  const cause = source === "transport" && object.cause !== null && typeof object.cause === "object" ? object.cause : {};
+  const message = clean([
+    typeof object.message === "string" ? object.message : "",
+    typeof cause.message === "string" ? cause.message : ""
+  ].filter(Boolean).join("; "));
+  const code = identifier(object.code ?? cause.code);
+  const type = identifier(source === "transport" ? object.name ?? object.type : object.type);
+  return { source, message: message || fallback, ...code ? { code } : {}, ...type ? { type } : {} };
+}
+function upstreamErrorDiagnostic(value, fallback, redact) {
+  const object = value !== null && typeof value === "object" ? value : {};
+  return errorDiagnostic(object.response?.error ?? object.error ?? object, "upstream", fallback, redact);
+}
+
 // plugins/chatgpt-oauth/server/codex-protocol.ts
 class CodexProtocolError extends Error {
   kind;
   reason;
-  constructor(kind, message, reason) {
+  diagnostic;
+  constructor(kind, message, reason, diagnostic) {
     super(message);
     this.name = "CodexProtocolError";
     this.kind = kind;
     this.reason = reason;
+    this.diagnostic = diagnostic;
   }
 }
 var UNSUPPORTED_RESPONSES_FIELDS = [
@@ -15349,9 +15381,11 @@ class CodexResponseProcessor {
   toolIndex = 0;
   outputOrder = 0;
   sawDone = false;
+  redactDiagnostic;
   constructor(options = {}) {
     this.includeUsage = options.includeUsage ?? (options.request ? streamIncludesUsage(options.request) : false);
     this.target = options.target ?? "chat";
+    this.redactDiagnostic = options.redactDiagnostic;
   }
   validateOutputItem(item) {
     if (this.target === "responses")
@@ -15456,18 +15490,18 @@ class CodexResponseProcessor {
       return [];
     }
     if (type === "response.failed" || data.response?.status === "failed")
-      throw new CodexProtocolError("failed", "Codex response failed");
+      throw new CodexProtocolError("failed", "Codex response failed", undefined, upstreamErrorDiagnostic(data, "Codex response failed", this.redactDiagnostic));
     if (this.sawDone && !this.terminal)
       throw new CodexProtocolError("incomplete", "Codex emitted an event after [DONE] without a terminal response");
     if (this.terminal) {
       if (type === "error" || type === "response.failed")
-        throw new CodexProtocolError("failed", "Codex response failed after terminal event");
+        throw new CodexProtocolError("failed", "Codex response failed after terminal event", undefined, upstreamErrorDiagnostic(data, "Codex response failed after terminal event", this.redactDiagnostic));
       if (type === "response.completed" || type === "response.incomplete")
         return [];
       return [];
     }
     if (type === "error")
-      throw new CodexProtocolError("failed", "Codex response contained an error event");
+      throw new CodexProtocolError("failed", "Codex response contained an error event", undefined, upstreamErrorDiagnostic(data, "Codex response contained an error event", this.redactDiagnostic));
     if (type === "response.created" || type === "response.in_progress") {
       const response = data.response ?? {};
       this.responseId ||= String(response.id ?? "");
@@ -15861,10 +15895,10 @@ function responseHeaders(response, contentType) {
   headers.set("content-type", contentType);
   return headers;
 }
-function safeErrorBody() {
-  return JSON.stringify({ error: { message: "Upstream response could not be adapted", type: "upstream_error", code: "upstream_error" } });
+function errorBody(error, fallbackCode = "upstream_error") {
+  return { message: error?.message ?? "Upstream response could not be adapted", type: error?.type ?? "upstream_error", code: error?.code ?? fallbackCode };
 }
-function completionFromError(error) {
+function completionFromError(error, redact) {
   if (error instanceof CodexProtocolError) {
     if (error.kind === "cancelled")
       return { status: "cancelled" };
@@ -15872,12 +15906,54 @@ function completionFromError(error) {
       return { status: "incomplete", code: "incomplete" };
     if (error.kind === "unexpected_eof")
       return { status: "failed", code: "unexpected_eof" };
-    return { status: "failed", code: error.kind };
+    return { status: "failed", code: error.kind, ...error.diagnostic ? {
+      error: errorDiagnostic(error.diagnostic, error.diagnostic.source, error.message, redact)
+    } : {} };
   }
   if (error instanceof CodexModelsError) {
     return error.kind === "aborted" ? { status: "cancelled" } : { status: "failed", code: error.kind };
   }
-  return { status: "failed", code: "body_error" };
+  return { status: "failed", code: "body_error", error: errorDiagnostic(error, "transport", "Upstream response body could not be read", redact) };
+}
+async function readHttpError(response, context) {
+  if (!response.body)
+    return { status: "failed", code: "upstream_http_error" };
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  const signal = AbortSignal.any([context.signal, AbortSignal.timeout(1000)]);
+  let text = "";
+  let bytes = 0;
+  try {
+    for (;; ) {
+      const next = await readWithSignal(reader, signal);
+      if (next.done)
+        break;
+      bytes += next.value?.byteLength ?? 0;
+      if (bytes > MAX_DISCARD_BYTES) {
+        reader.cancel("body_limit").catch(() => {
+          return;
+        });
+        return { status: "failed", code: "body_limit" };
+      }
+      text += decoder.decode(next.value, { stream: true });
+    }
+    const body = JSON.parse(text + decoder.decode());
+    const error = body?.error;
+    if (error && typeof error === "object" && !Array.isArray(error)) {
+      return { status: "failed", code: "upstream_http_error", error: errorDiagnostic(error, "upstream", "Upstream returned an HTTP error", context.redactDiagnostic) };
+    }
+  } catch (error) {
+    reader.cancel("error capture stopped").catch(() => {
+      return;
+    });
+    if (context.signal.aborted)
+      return { status: "cancelled" };
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {}
+  }
+  return { status: "failed", code: "upstream_http_error" };
 }
 function joinCompletion(upstream, body, signal) {
   const safe = (promise) => promise.catch(() => ({ status: "failed", code: "upstream_completion" }));
@@ -15995,7 +16071,7 @@ function serialize(event) {
 
 `;
 }
-function protocolStreamBody(source, target, includeUsage, signal) {
+function protocolStreamBody(source, target, includeUsage, signal, redact) {
   const protocolController = new AbortController;
   const onAbort = () => protocolController.abort(signal.reason ?? "cancelled");
   if (signal.aborted)
@@ -16013,7 +16089,7 @@ function protocolStreamBody(source, target, includeUsage, signal) {
   const completion = new Promise((resolve) => {
     resolveCompletion = resolve;
   });
-  const processor = new CodexResponseProcessor({ target, includeUsage });
+  const processor = new CodexResponseProcessor({ target, includeUsage, redactDiagnostic: redact });
   let terminalOutcome;
   const events = parseCodexSSE(source, { signal: protocolController.signal });
   const iterator = async function* () {
@@ -16040,8 +16116,18 @@ function protocolStreamBody(source, target, includeUsage, signal) {
 `;
       settle(outcome);
     } catch (error) {
-      const outcome = completionFromError(error);
+      const outcome = completionFromError(error, redact);
       settle(outcome.status === "cancelled" ? terminalOutcome ?? outcome : outcome);
+      if (outcome.status === "failed" && outcome.error) {
+        const safe = errorBody(outcome.error, outcome.code);
+        yield target === "responses" ? `event: error
+data: ${JSON.stringify({ type: "error", code: safe.code, message: safe.message, param: null, error: safe })}
+
+` : `data: ${JSON.stringify({ error: safe })}
+
+`;
+        return;
+      }
       throw error;
     } finally {
       signal.removeEventListener("abort", onAbort);
@@ -16152,8 +16238,8 @@ class ChatgptOauthAdapter {
       current.adaptedResponses.add(response);
       return response;
     };
-    const errorResponse = (status, completion) => {
-      const response = mark(new Response(safeErrorBody(), {
+    const errorResponse = (status, completion, error) => {
+      const response = mark(new Response(JSON.stringify({ error: errorBody(error) }), {
         status,
         statusText: result.response.statusText,
         headers: responseHeaders(result.response, "application/json; charset=utf-8")
@@ -16162,8 +16248,8 @@ class ChatgptOauthAdapter {
       return { response, completion };
     };
     if (!result.response.ok) {
-      const bodyCompletion = discardBody(result.response, context.signal).then((outcome) => outcome.status === "completed" ? { status: "failed", code: "upstream_http_error" } : outcome);
-      return errorResponse(result.response.status, joinCompletion(result.completion, bodyCompletion, context.signal));
+      const failure = await readHttpError(result.response, context);
+      return errorResponse(result.response.status, joinCompletion(result.completion, Promise.resolve(failure), context.signal), "error" in failure ? failure.error : undefined);
     }
     if (state.target === "models") {
       if (!isJsonContentType(result.response)) {
@@ -16188,7 +16274,8 @@ class ChatgptOauthAdapter {
         completion.then(cleanup, cleanup);
         return { response, completion };
       } catch (error) {
-        return errorResponse(502, joinCompletion(result.completion, Promise.resolve(completionFromError(error)), context.signal));
+        const failure = completionFromError(error, context.redactDiagnostic);
+        return errorResponse(502, joinCompletion(result.completion, Promise.resolve(failure), context.signal), "error" in failure ? failure.error : undefined);
       }
     }
     const contentType = result.response.headers.get("content-type");
@@ -16199,7 +16286,7 @@ class ChatgptOauthAdapter {
       return errorResponse(502, joinCompletion(result.completion, bodyCompletion, context.signal));
     }
     if (state.stream) {
-      const converted = protocolStreamBody(result.response.body, state.target, state.includeUsage, context.signal);
+      const converted = protocolStreamBody(result.response.body, state.target, state.includeUsage, context.signal, context.redactDiagnostic);
       const streamCompletion = joinCompletion(result.completion, converted.completion, context.signal);
       streamCompletion.then(cleanup, cleanup);
       return {
@@ -16211,7 +16298,8 @@ class ChatgptOauthAdapter {
       const stateResult = await consumeCodexResponse(result.response.body, {
         signal: context.signal,
         request: { stream_options: { include_usage: state.includeUsage } },
-        target: state.target
+        target: state.target,
+        redactDiagnostic: context.redactDiagnostic
       });
       const body = state.target === "chat" ? responsesToChatCompletion(stateResult.response) : stateResult.response;
       const protocolCompletion = Promise.resolve(stateResult.terminal === "completed" ? { status: "completed" } : { status: "incomplete", code: "incomplete" });
@@ -16219,9 +16307,9 @@ class ChatgptOauthAdapter {
       nonStreamCompletion.then(cleanup, cleanup);
       return { response: mark(new Response(JSON.stringify(body), { status: result.response.status, statusText: result.response.statusText, headers: responseHeaders(result.response, "application/json; charset=utf-8") })), completion: nonStreamCompletion };
     } catch (error) {
-      const failure = completionFromError(error);
+      const failure = completionFromError(error, context.redactDiagnostic);
       const failedCompletion = joinCompletion(result.completion, Promise.resolve(failure), context.signal);
-      return errorResponse(502, failedCompletion);
+      return errorResponse(502, failedCompletion, "error" in failure ? failure.error : undefined);
     }
   }
 }
@@ -16252,4 +16340,4 @@ export {
   server_default as default
 };
 
-//# debugId=A763904920EABC5C64756E2164756E21
+//# debugId=D19FB0DB9863C8D864756E2164756E21