@typeship-ax/mcp 0.21.0 → 0.23.0

package/dist/core/http.js

@@ -1,7 +1,55 @@
 /**
- * Runtime core. Generated by typeship — https://typeship.dev
+ * Runtime core. Generated by Typeship — https://typeship.dev
  * Zero dependencies: built on the platform fetch API (Node 20+, browsers, edge).
  */
+/** Response headers that carry a request identifier, most specific first. */
+const REQUEST_ID_HEADERS = ["request-id", "x-request-id", "x-github-request-id", "twilio-request-id", "x-amzn-requestid", "x-slack-req-id", "cf-ray"];
+function requestIdFromHeaders(headers) {
+    for (const name of REQUEST_ID_HEADERS) {
+        const value = headers.get(name);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+/**
+ * Whether a response is a rate limit, and when to retry. A 429 always is. A
+ * 403 is when it says the quota is spent (`x-ratelimit-remaining: 0`) or asks
+ * the caller to wait (`Retry-After`), which is how GitHub signals its primary
+ * and secondary limits. Undefined for every other response.
+ */
+export function rateLimitInfo(status, headers, now = Date.now()) {
+    const retryAfter = headers.get("retry-after");
+    const remaining = headers.get("x-ratelimit-remaining") ?? headers.get("ratelimit-remaining");
+    const limited = status === 429 || (status === 403 && (retryAfter !== null || (remaining !== null && remaining.trim() === "0")));
+    if (!limited)
+        return undefined;
+    let waitMs;
+    if (retryAfter !== null && retryAfter.trim() !== "") {
+        const seconds = Number(retryAfter);
+        if (Number.isFinite(seconds))
+            waitMs = Math.max(seconds, 0) * 1000;
+        else if (!Number.isNaN(Date.parse(retryAfter)))
+            waitMs = Math.max(Date.parse(retryAfter) - now, 0);
+    }
+    const reset = headers.get("x-ratelimit-reset") ?? headers.get("ratelimit-reset");
+    if (waitMs === undefined && reset !== null && reset.trim() !== "" && Number.isFinite(Number(reset))) {
+        const value = Number(reset);
+        // An epoch timestamp (GitHub, Twitter) or seconds until the reset (the
+        // IETF RateLimit header fields).
+        waitMs = Math.max(value > 1e9 ? value * 1000 - now : value * 1000, 0);
+    }
+    if (waitMs === undefined)
+        return {};
+    return { retryAt: new Date(now + waitMs), retryAfterMs: waitMs };
+}
+function rateLimitStep(info) {
+    if (!info.retryAt)
+        return "Rate limited: wait before retrying.";
+    // Round up to the second so "wait until" is never early.
+    const at = new Date(Math.ceil(info.retryAt.getTime() / 1000) * 1000);
+    return "Rate limited: wait until " + at.toISOString().replace(/\.\d{3}Z$/, "Z") + ", then retry.";
+}
 /** Collapse a result into its data, throwing the typed error when !ok. */
 export function unwrap(result) {
     if (result.ok)
@@ -45,25 +93,46 @@ export class SdkError extends Error {
         this.requestId = requestId;
     }
 }
+function errorFields(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return {};
+    const value = body;
+    const nested = value.error && typeof value.error === "object" && !Array.isArray(value.error) ? value.error : undefined;
+    const first = Array.isArray(value.errors) && value.errors[0] && typeof value.errors[0] === "object" ? value.errors[0] : undefined;
+    return { error: nested, value, first };
+}
+/** The API's own error code: `error.code`, `code`, `error.type`, then
+ * `errors[0].code`; numeric codes (Twilio's 20404) as strings. */
 function errorCode(body, fallback) {
-    if (body && typeof body === "object" && !Array.isArray(body)) {
-        const value = body;
-        const first = Array.isArray(value.errors) ? value.errors[0] : undefined;
-        const code = value.code ?? first?.code;
+    const { error, value, first } = errorFields(body);
+    if (!value)
+        return fallback;
+    for (const code of [error?.code, value.code, error?.type, first?.code]) {
         if (typeof code === "string" && code.trim())
             return code;
+        if (typeof code === "number" && Number.isFinite(code))
+            return String(code);
     }
+    // Slack-style `{"ok": false, "error": "invalid_auth"}`: the error is a code.
+    if (typeof value.error === "string" && /^[A-Za-z][\w.-]{0,63}$/.test(value.error))
+        return value.error;
     return fallback;
 }
+/** The API's own message: `error.message`, `message`, `errors[0].message`,
+ * `detail`, `error_description`, then a string `error`. */
 function errorDetail(body) {
-    if (!body || typeof body !== "object" || Array.isArray(body))
+    const { error, value, first } = errorFields(body);
+    if (!value)
         return "";
-    const value = body;
-    const first = Array.isArray(value.errors) ? value.errors[0] : undefined;
-    const detail = value.message ?? value.error ?? value.detail ?? first?.message;
-    return typeof detail === "string" && detail.trim() ? ": " + detail : "";
+    for (const detail of [error?.message, value.message, first?.message, value.detail, value.error_description, value.error]) {
+        if (typeof detail === "string" && detail.trim())
+            return detail.trim();
+    }
+    return "";
 }
 function nextStep(status) {
+    if (status >= 200 && status < 300)
+        return "It arrived in a successful HTTP response; the body says why.";
     if (status === 401)
         return "Check the credential and retry.";
     if (status === 403)
@@ -72,6 +141,8 @@ function nextStep(status) {
         return "Check the requested identifier or path.";
     if (status === 409)
         return "Refresh the resource and retry the change.";
+    if (status === 413)
+        return "Send less data in one request.";
     if (status === 422 || status === 400)
         return "Correct the request and retry.";
     if (status === 429)
@@ -80,22 +151,131 @@ function nextStep(status) {
         return "Retry later; contact the API provider if this continues.";
     return "Inspect the error body and correct the request before retrying.";
 }
-/** Base class for every HTTP error response. */
+/** Base class for every HTTP error response. The message leads with the
+ * status and the API's own message ("HTTP 404: No such customer"), then the
+ * next step. `code` is the API's error code when the body names one. */
 export class ApiError extends SdkError {
     status;
     body;
     response;
-    constructor(message, status, body, response) {
-        super(message + errorDetail(body) + ". " + nextStep(status), errorCode(body, "http_" + status), status, body, response.requestId);
+    /** Set when the API said this call was rate limited (a 429, or a 403
+     * whose headers say the quota is spent): when to retry. */
+    rateLimit;
+    /** `summary` leads the message ("HTTP 404"); the API's message follows it. */
+    constructor(summary, status, body, response, own) {
+        const limit = response.rateLimit ?? (response.headers ? rateLimitInfo(status, response.headers) : undefined);
+        const detail = errorDetail(body);
+        super(
+        // An API message usually ends its own sentence; do not double it.
+        own?.message ?? (summary + (detail ? ": " + detail : "")).replace(/[.!?]+$/, "") + ". " + (limit ? rateLimitStep(limit) : nextStep(status)), own?.code ?? errorCode(body, limit ? "rate_limited" : "http_" + status), status, body, response.requestId);
         this.status = status;
         this.body = body;
         this.response = response;
+        if (limit)
+            this.rateLimit = limit;
+    }
+}
+/** HTTP 400: the API rejected the request as malformed. Raised for every
+ * 400, documented or not; `body` is typed where the operation declares it. */
+export class BadRequestError extends ApiError {
+    constructor(body, response) {
+        super("HTTP 400", 400, body, response);
+    }
+}
+/** HTTP 401: the credential is missing, invalid or expired. */
+export class UnauthorizedError extends ApiError {
+    constructor(body, response) {
+        super("HTTP 401", 401, body, response);
+    }
+}
+/** HTTP 403: the credential lacks access. A 403 that signals a rate limit
+ * raises RateLimitError instead. */
+export class ForbiddenError extends ApiError {
+    constructor(body, response) {
+        super("HTTP 403", 403, body, response);
+    }
+}
+/** HTTP 404: the resource or path does not exist. */
+export class NotFoundError extends ApiError {
+    constructor(body, response) {
+        super("HTTP 404", 404, body, response);
+    }
+}
+/** HTTP 409: the request conflicts with the resource's current state. */
+export class ConflictError extends ApiError {
+    constructor(body, response) {
+        super("HTTP 409", 409, body, response);
+    }
+}
+/** HTTP 422: the request was well formed but failed validation. */
+export class UnprocessableEntityError extends ApiError {
+    constructor(body, response) {
+        super("HTTP 422", 422, body, response);
+    }
+}
+/** The API rate limited the call: every 429, and a 403 whose headers say
+ * the quota is spent. `rateLimit.retryAt` says when to try again. */
+export class RateLimitError extends ApiError {
+    constructor(body, response) {
+        super("HTTP " + response.status, response.status, body, response);
+    }
+}
+/** Any 5xx: the API failed to handle a valid request. */
+export class ServerError extends ApiError {
+    constructor(body, response) {
+        super("HTTP " + response.status, response.status, body, response);
+    }
+}
+/** HTTP 304: a conditional request (`If-None-Match`, `If-Modified-Since`)
+ * matched, so the resource has not changed and the response has no body.
+ * Raised only when the caller sent a conditional header. `etag` and
+ * `lastModified` are the validators to send next time. */
+export class NotModifiedError extends ApiError {
+    /** The response's `ETag` header. */
+    etag;
+    /** The response's `Last-Modified` header. */
+    lastModified;
+    constructor(response) {
+        super("HTTP 304", 304, undefined, response, {
+            message: "HTTP 304: Not modified. The resource matches the validator sent in If-None-Match or If-Modified-Since; keep using the copy you have.",
+            code: "not_modified",
+        });
+        if (response.etag)
+            this.etag = response.etag;
+        if (response.lastModified)
+            this.lastModified = response.lastModified;
     }
 }
-/** A response status the spec didn't document. */
+/** The class raised for a status whatever the operation declares. */
+function statusFamily(status) {
+    switch (status) {
+        case 400: return BadRequestError;
+        case 401: return UnauthorizedError;
+        case 403: return ForbiddenError;
+        case 404: return NotFoundError;
+        case 409: return ConflictError;
+        case 422: return UnprocessableEntityError;
+        case 429: return RateLimitError;
+    }
+    return status >= 500 && status < 600 ? ServerError : undefined;
+}
+/** A 2xx response whose payload reported a failure: a declared envelope
+ * flag set to false (`{"ok": false}`, `{"success": false}`), or a GraphQL
+ * result that is one of the schema's error types. */
+export class PayloadError extends ApiError {
+    /** The GraphQL error type the result resolved to, for GraphQL operations. */
+    typename;
+    constructor(body, response, typename) {
+        super(typename ? "The operation returned " + typename : "The API reported a failure", response.status, body, response);
+        if (typename)
+            this.typename = typename;
+    }
+}
+/** A status with no family class (a 402, 405 or 410, say) that the
+ * operation did not document. */
 export class UnexpectedApiError extends ApiError {
     constructor(status, body, response) {
-        super("Unexpected HTTP status " + status, status, body, response);
+        super("HTTP " + status, status, body, response);
     }
 }
 /** A successful response declared JSON but carried a body that could not be parsed. */
@@ -267,12 +447,28 @@ function transportFailureMessage(method, url, cause) {
     }
     return method + " " + url + " failed: " + detail;
 }
-/** The request failed before a complete HTTP response arrived (network failure, timeout, abort, or truncated body). */
+function transportFailure(cause, signal) {
+    if (signal?.aborted)
+        return "aborted";
+    let node = cause;
+    for (let depth = 0; depth < 5 && node !== null && typeof node === "object"; depth++) {
+        if (node.name === "TimeoutError")
+            return "timeout";
+        node = node.cause;
+    }
+    return "transport_error";
+}
+const TRANSPORT_NEXT_STEP = {
+    aborted: ". The caller's AbortSignal cancelled the request.",
+    timeout: ". The request timed out; retry, or raise timeoutMs.",
+    transport_error: ". Check the connection and retry.",
+};
+/** The request failed before a complete HTTP response arrived (network failure, timeout, abort, or truncated body); `code` says which. */
 export class TransportError extends SdkError {
     cause;
     response;
-    constructor(message, cause, response) {
-        super(message + ". Check the connection and retry.", "transport_error", response?.status ?? null, undefined, response?.requestId);
+    constructor(message, cause, response, failure = "transport_error") {
+        super(message + TRANSPORT_NEXT_STEP[failure], failure, response?.status ?? null, undefined, response?.requestId);
         this.cause = cause;
         this.response = response;
     }
@@ -327,6 +523,7 @@ function isStreamBody(body) {
 }
 export class HttpCore {
     config;
+    schemaTables;
     /** Lowercased header names dropped on a cross-origin hop. */
     sensitiveHeaders;
     /** Whether this runtime follows redirects itself instead of letting the
@@ -345,7 +542,7 @@ export class HttpCore {
         // the target's CORS consent anyway.
         this.manualRedirects = custom.length > 0 && globalThis.document === undefined;
     }
-    /** The client-level value for an x-typeship-globals parameter. */
+    /** The client-level value for a global parameter. */
     globalValue(name) {
         return this.config.globals?.[name];
     }
@@ -367,11 +564,18 @@ export class HttpCore {
             req.options?.headers?.[req.idempotencyKey] === undefined
             ? crypto.randomUUID()
             : undefined;
-        const opSchemas = this.config.validate && req.schemaKey ? this.config.schemas?.[req.schemaKey] : undefined;
+        const tables = this.config.validate && req.schemaKey && this.config.loadSchemas
+            ? await (this.schemaTables ??= this.config.loadSchemas())
+            : undefined;
+        const opSchemas = tables && req.schemaKey ? tables.SCHEMAS[req.schemaKey] : undefined;
         if (opSchemas?.req && this.config.validate.requests
             && req.body !== undefined && (req.bodyKind ?? "json") === "json") {
             const violations = [];
-            validateAgainstSchema(req.body, opSchemas.req, "body", violations, this.config.schemaDefs);
+            // A GraphQL body is the {query, variables} envelope; the schema
+            // describes the variables.
+            let validated = req.body;
+            let label = "body";
+            validateAgainstSchema(validated, opSchemas.req, label, violations, tables.DEFS);
             if (violations.length > 0) {
                 const validationError = new ValidationError("request", violations);
                 if (this.config.validate.mode === "warn") {
@@ -385,6 +589,22 @@ export class HttpCore {
             }
         }
         let lastError;
+        let credentialsRefreshed = false;
+        // With an automatic Idempotency-Key, a retry that the API refuses as a
+        // duplicate still in progress (409/429) is about our own first attempt.
+        // Report that original failure instead, with its request id.
+        let original;
+        const errorFor = (response, body, responseMeta, limit) => {
+            // A documented status keeps its own class; a family status (404,
+            // 429, 5xx) raises the family class declared or not, so one catch
+            // covers it; ranges and default cover the rest.
+            const Ctor = limit ? RateLimitError
+                : req.errors?.[String(response.status)] ??
+                    statusFamily(response.status) ??
+                    req.errors?.[String(Math.floor(response.status / 100)) + "XX"] ??
+                    req.errors?.["default"];
+            return (Ctor ? new Ctor(body, responseMeta) : new UnexpectedApiError(response.status, body, responseMeta));
+        };
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             let response;
             const attemptStarted = Date.now();
@@ -394,15 +614,17 @@ export class HttpCore {
                 status: value.status,
                 durationMs: Date.now() - attemptStarted,
                 attempt: attempt + 1,
-                requestId: requestIdFromBody(body) ??
-                    value.headers.get("request-id") ??
-                    value.headers.get("x-request-id") ??
-                    undefined,
+                requestId: requestIdFromBody(body) ?? requestIdFromHeaders(value.headers),
             });
             try {
                 response = await this.send(req, timeoutMs, attempt, autoIdempotencyKey);
             }
             catch (cause) {
+                if (cause instanceof CredentialCallbackFailure) {
+                    const error = cause.error;
+                    await this.config.onError?.(error, { method: req.method, path: req.path });
+                    return { ok: false, error };
+                }
                 lastError = cause;
                 this.config.debug?.({
                     method: req.method,
@@ -412,13 +634,24 @@ export class HttpCore {
                     error: cause instanceof Error ? cause.message : String(cause),
                 });
                 if (attempt < maxRetries && retryAllowed && !req.options?.signal?.aborted) {
+                    if (autoIdempotencyKey)
+                        original = { error: new TransportError(transportFailureMessage(req.method, this.config.baseUrl.replace(/\/+$/, "") + req.path, cause), cause, undefined, transportFailure(cause)) };
                     await sleep(backoff(attempt, policy));
                     continue;
                 }
-                const error = new TransportError(transportFailureMessage(req.method, this.config.baseUrl.replace(/\/+$/, "") + req.path, cause), cause);
+                const error = new TransportError(transportFailureMessage(req.method, this.config.baseUrl.replace(/\/+$/, "") + req.path, cause), cause, undefined, transportFailure(cause, req.options?.signal));
                 await this.config.onError?.(error, { method: req.method, path: req.path });
                 return { ok: false, error };
             }
+            // A conditional request matched: nothing changed. Raised so a method
+            // keeps its non-null type, but not a failure: onError is not called.
+            if (response.status === 304) {
+                void response.body?.cancel().catch(() => { });
+                emitResponseDebug(response);
+                const notModified = { ...meta(response), notModified: true };
+                req.options?.onResponse?.(notModified);
+                return { ok: false, error: new NotModifiedError(notModified), response: notModified };
+            }
             if (response.ok) {
                 let data;
                 try {
@@ -427,17 +660,27 @@ export class HttpCore {
                 catch (cause) {
                     const parseError = cause instanceof ResponseParseError ? cause : undefined;
                     emitResponseDebug(response, parseError?.body);
-                    const error = (parseError ?? new TransportError("The response body read failed before completing", cause, meta(response)));
+                    req.options?.onResponse?.(parseError?.response ?? meta(response));
+                    const error = (parseError ?? new TransportError("The response body read failed before completing", cause, meta(response), transportFailure(cause, req.options?.signal)));
                     await this.config.onError?.(error, { method: req.method, path: req.path });
                     return { ok: false, error, response: parseError?.response ?? meta(response) };
                 }
                 emitResponseDebug(response, data);
                 const responseMeta = meta(response, data);
+                req.options?.onResponse?.(responseMeta);
                 let responseData = data;
+                // Checked before validation: a failure body rarely matches the
+                // success schema, and the failure is the news.
+                if (req.failureFlag && data && typeof data === "object" && !Array.isArray(data)
+                    && data[req.failureFlag] === false) {
+                    const payloadError = new PayloadError(data, responseMeta);
+                    await this.config.onError?.(payloadError, { method: req.method, path: req.path });
+                    return { ok: false, error: payloadError, response: responseMeta };
+                }
                 let shouldValidateResponse = responseData !== undefined;
                 if (opSchemas?.res && this.config.validate.responses && shouldValidateResponse) {
                     const violations = [];
-                    validateAgainstSchema(responseData, opSchemas.res, "response", violations, this.config.schemaDefs);
+                    validateAgainstSchema(responseData, opSchemas.res, "response", violations, tables.DEFS);
                     if (violations.length > 0) {
                         const validationError = new ValidationError("response", violations);
                         if (this.config.validate.mode === "warn") {
@@ -453,11 +696,22 @@ export class HttpCore {
                 return { ok: true, data, response: responseMeta };
             }
             // 429 is safe to retry regardless of idempotency; other retryable
-            // statuses only when the verb is idempotent.
-            const retryableStatus = retryableStatuses.has(response.status) &&
+            // statuses, and a rate-limited 403, only when the verb is idempotent.
+            const limit = rateLimitInfo(response.status, response.headers);
+            const retryableStatus = (retryableStatuses.has(response.status) || (limit !== undefined && response.status === 403)) &&
                 (retryAllowed || response.status === 429);
-            if (attempt < maxRetries && retryableStatus) {
-                const delay = retryAfterMs(response) ?? backoff(attempt, policy);
+            // A server-requested wait beyond the ceiling fails now, with the reset
+            // time in the error, rather than holding the caller.
+            const requestedWait = limit?.retryAfterMs ?? retryAfterMs(response);
+            const withinCeiling = requestedWait === undefined || requestedWait <= (this.config.maxRetryWaitMs ?? 60_000);
+            if (original && (response.status === 409 || response.status === 429)) {
+                void response.body?.cancel().catch(() => { });
+                emitResponseDebug(response);
+                await this.config.onError?.(original.error, { method: req.method, path: req.path });
+                return { ok: false, error: original.error, ...(original.response ? { response: original.response } : {}) };
+            }
+            if (attempt < maxRetries && retryableStatus && withinCeiling) {
+                const delay = requestedWait ?? backoff(attempt, policy);
                 let retryBody;
                 try {
                     retryBody = await parseBody(response, req.method);
@@ -466,9 +720,22 @@ export class HttpCore {
                     retryBody = undefined;
                 }
                 emitResponseDebug(response, retryBody);
+                if (autoIdempotencyKey && response.status >= 500) {
+                    const failedMeta = meta(response, retryBody);
+                    original = { error: errorFor(response, retryBody, failedMeta, limit), response: failedMeta };
+                }
                 await sleep(delay);
                 continue;
             }
+            // A rejected callback or cached token gets one fresh resolution; the
+            // resend does not spend the retry budget. Static credentials do not.
+            if (response.status === 401 && !credentialsRefreshed && this.refreshCredentials(req)) {
+                credentialsRefreshed = true;
+                void response.body?.cancel().catch(() => { });
+                emitResponseDebug(response);
+                attempt--;
+                continue;
+            }
             let body;
             try {
                 body = await parseBody(response, req.method);
@@ -478,12 +745,10 @@ export class HttpCore {
             }
             emitResponseDebug(response, body);
             const responseMeta = meta(response, body);
-            const Ctor = req.errors?.[String(response.status)] ??
-                req.errors?.[String(Math.floor(response.status / 100)) + "XX"] ??
-                req.errors?.["default"];
-            const error = (Ctor
-                ? new Ctor(body, responseMeta)
-                : new UnexpectedApiError(response.status, body, responseMeta));
+            req.options?.onResponse?.(responseMeta);
+            // A rate limit is its own error whatever the status: a 403 that means
+            // "wait" must not read as "your credential lacks access".
+            const error = errorFor(response, body, responseMeta, limit);
             await this.config.onError?.(error, { method: req.method, path: req.path });
             return { ok: false, error, response: responseMeta };
         }
@@ -492,6 +757,19 @@ export class HttpCore {
         await this.config.onError?.(error, { method: req.method, path: req.path });
         return { ok: false, error };
     }
+    /** Drop cached tokens behind the credential this request selected. True
+     * when a callback or cached token can resolve to a new value. */
+    refreshCredentials(req) {
+        const selected = req.security && this.config.credentials ? selectSecurity(req.security, this.config.credentials) : {};
+        let refreshable = false;
+        for (const value of [...Object.values(selected.headers ?? {}), ...Object.values(selected.query ?? {})]) {
+            if (typeof value !== "function")
+                continue;
+            refreshable = true;
+            markRejected(value);
+        }
+        return refreshable;
+    }
     /** SDK-facing call: resolve to the payload or throw its typed error. */
     async requestData(req) {
         return unwrap(await this.request(req));
@@ -603,7 +881,7 @@ export class HttpCore {
     }
     async buildUrl(req, authQuery) {
         const base = this.config.baseUrl.replace(/\/+$/, "");
-        const url = new URL(base + req.path);
+        const url = req.url !== undefined ? new URL(req.url, base) : new URL(base + req.path);
         for (const [k, v] of Object.entries(req.query ?? {})) {
             if (v === undefined || v === null)
                 continue;
@@ -622,8 +900,36 @@ export class HttpCore {
         return url.toString();
     }
 }
+/** A credential callback failed: surface the caller's own error unchanged
+ * instead of retrying it as a transport failure. */
+class CredentialCallbackFailure {
+    error;
+    constructor(error) { this.error = error; }
+}
 async function resolveAuthValue(value) {
-    return typeof value === "function" ? await value() : value;
+    if (typeof value !== "function")
+        return value;
+    try {
+        return await callCredential(value);
+    }
+    catch (error) {
+        // The SDK's own token request failures keep the transport retry path.
+        if (error instanceof TransportError)
+            throw error;
+        throw new CredentialCallbackFailure(error);
+    }
+}
+/** Callbacks without their own invalidate learn of a 401 on their next call. */
+const rejectedCallbacks = new WeakSet();
+function markRejected(value) {
+    if (value.invalidate)
+        value.invalidate();
+    else
+        rejectedCallbacks.add(value);
+}
+function callCredential(value) {
+    const rejected = rejectedCallbacks.delete(value);
+    return value({ rejected });
 }
 /** Default rendering for debug events (the boolean debug:true sink). */
 export function formatDebugEvent(name, event) {
@@ -637,10 +943,32 @@ export function formatDebugEvent(name, event) {
 /** Wrap a bearer credential (static or callback) as an Authorization value. */
 export function bearerAuth(token) {
     if (typeof token === "function") {
-        return async () => "Bearer " + (await token());
+        return Object.assign(async () => "Bearer " + (await callCredential(token)), { invalidate: () => markRejected(token) });
     }
     return "Bearer " + token;
 }
+/** The media type a local file is uploaded as, from its extension. A
+ * Worker module (.mjs) must arrive as application/javascript+module. */
+export function mediaTypeForPath(path) {
+    const extension = /\.([A-Za-z0-9]+)$/.exec(path)?.[1]?.toLowerCase() ?? "";
+    const types = {
+        mjs: "application/javascript+module", js: "application/javascript", cjs: "application/javascript", wasm: "application/wasm",
+        json: "application/json", jsonl: "application/jsonl", txt: "text/plain", md: "text/markdown", csv: "text/csv", html: "text/html",
+        xml: "application/xml", yaml: "application/yaml", yml: "application/yaml", pdf: "application/pdf", zip: "application/zip",
+        png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", svg: "image/svg+xml",
+        mp3: "audio/mpeg", wav: "audio/wav", ogg: "audio/ogg", flac: "audio/flac", m4a: "audio/mp4", mp4: "video/mp4", webm: "video/webm",
+    };
+    return types[extension] ?? "application/octet-stream";
+}
+/**
+ * Join a query array into one delimited value (`ids=1,2`) for parameters
+ * whose spec says `explode: false`. Other values pass through unchanged.
+ */
+export function delimited(value, separator) {
+    if (!Array.isArray(value))
+        return value;
+    return value.map((item) => (item instanceof Date ? item.toISOString() : String(item))).join(separator);
+}
 /**
  * Bracket-style deep encoding shared by query strings and form bodies:
  * { created: { gte: 5 } } -> created[gte]=5, { items: [{ id: "x" }] } ->
@@ -710,14 +1038,17 @@ function requestIdFromBody(body) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 function meta(response, body) {
+    const etag = response.headers.get("etag");
+    const lastModified = response.headers.get("last-modified");
+    const rateLimit = rateLimitInfo(response.status, response.headers);
     return {
         status: response.status,
         headers: response.headers,
         ...(body !== undefined ? { rawBody: body } : {}),
-        requestId: requestIdFromBody(body) ??
-            response.headers.get("request-id") ??
-            response.headers.get("x-request-id") ??
-            undefined,
+        requestId: requestIdFromBody(body) ?? requestIdFromHeaders(response.headers),
+        ...(etag ? { etag } : {}),
+        ...(lastModified ? { lastModified } : {}),
+        ...(rateLimit ? { rateLimit } : {}),
     };
 }
 /** AbortSignal.any is missing from some web and edge runtimes; compose the
@@ -745,16 +1076,17 @@ function composeSignals(signals) {
     }
     return controller.signal;
 }
+/** Retry-After on a retryable status that is not a rate limit (a 503). */
 function retryAfterMs(response) {
     const header = response.headers.get("retry-after");
     if (!header)
         return undefined;
     const seconds = Number(header);
     if (Number.isFinite(seconds))
-        return Math.min(seconds * 1000, 60_000);
+        return Math.max(seconds * 1000, 0);
     const date = Date.parse(header);
     if (!Number.isNaN(date))
-        return Math.min(Math.max(date - Date.now(), 0), 60_000);
+        return Math.max(date - Date.now(), 0);
     return undefined;
 }
 /** Exponential backoff with full jitter, capped at 10s by default. */
@@ -768,8 +1100,9 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export function toBase64(input) {
+    // Encode UTF-8 bytes: btoa alone rejects characters outside Latin-1.
     if (typeof btoa === "function")
-        return btoa(input);
+        return btoa(Array.from(new TextEncoder().encode(input), (byte) => String.fromCharCode(byte)).join(""));
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return globalThis.Buffer.from(input, "utf-8").toString("base64");
 }