@zackbart/connecta 0.28.0 → 0.29.0

package/dist/auth-elicitation.js

@@ -0,0 +1,283 @@
+import { createRequestStateCodec, inputRequired, ProtocolError, INVALID_PARAMS, PROTOCOL_VERSION_META_KEY, CLIENT_CAPABILITIES_META_KEY, } from "@modelcontextprotocol/server";
+import { Effect } from "effect";
+import { runEdge, withDeadlineEffect } from "./runtime/run.js";
+import { closeScope } from "./runtime/connector-scope.js";
+import { storedCredentialShape } from "./credential-rules.js";
+import { authRecoveryFacts, bindReplayReads, classificationDigest } from "./invocation-auth.js";
+import { CatalogService } from "./catalog-service.js";
+import { DownstreamElicitation, MAX_RELAY_STATE_CHARS, } from "./downstream-input.js";
+import { canonicalState as canonical, requestDigest as digest, stateObject as object, invalidRequestState as invalidState, REQUEST_STATE_TTL_MS as TTL_MS, MAX_INPUT_ROUNDS as MAX_ROUNDS, } from "./request-state.js";
+const INPUT_KEY = "connecta_auth";
+const MESSAGE = "Connect this service in your browser, then retry the request.";
+function failure(code, message) {
+    const structuredContent = { ok: false, error: { code, message, retryable: false } };
+    return { content: [{ type: "text", text: JSON.stringify(structuredContent) }], structuredContent, isError: true };
+}
+/** Request-local auth recovery at the MCP boundary, never inside a guest provider. */
+export class AuthElicitation {
+    options;
+    codec;
+    downstream;
+    stateCodec() {
+        const key = this.options.vault?.requestStateKey;
+        if (!key)
+            return invalidState();
+        return (this.codec ??= key.call(this.options.vault).then((bytes) => createRequestStateCodec({
+            key: bytes,
+            ttlSeconds: TTL_MS / 1000,
+            bind: () => canonical({ principal: this.options.principal, endpoint: this.options.endpoint }),
+        })));
+    }
+    constructor(options) {
+        this.options = options;
+        this.downstream = new DownstreamElicitation({
+            ...options,
+            mint: async (state, context) => (await this.stateCodec()).mint(state, context),
+        });
+    }
+    /** The SDK runs this before any tool handler, including non-auth tools. */
+    async verify(wire, context) {
+        const { vault, endpoint, principal, registry, canManage } = this.options;
+        if (!vault?.requestStateKey || wire.length > MAX_RELAY_STATE_CHARS)
+            return invalidState();
+        const state = await (await this.stateCodec()).verify(wire, context);
+        if (object(state) && state.version === 2 && state.kind === "downstream")
+            return this.downstream.verify(state, context);
+        if (wire.length > 8192)
+            return invalidState();
+        if (!object(state) ||
+            state.version !== 1 ||
+            !principal ||
+            state.principal !== principal ||
+            state.endpoint !== endpoint ||
+            typeof state.connector !== "string" ||
+            !registry.getConnector(state.connector) ||
+            !canManage(state.connector) ||
+            !Number.isSafeInteger(state.expiresAt) ||
+            state.expiresAt <= Date.now() ||
+            state.expiresAt > Date.now() + TTL_MS ||
+            !Number.isInteger(state.round) ||
+            state.round < 1 ||
+            state.round > MAX_ROUNDS ||
+            !["call_tool", "call_destructive_tool", "execute_code", "authorize_connector"].includes(String(state.tool)) ||
+            typeof state.digest !== "string" ||
+            !/^[a-f0-9]{64}$/.test(state.digest) ||
+            !Array.isArray(state.browserNonces) ||
+            state.browserNonces.length !== state.round ||
+            !state.browserNonces.every((nonce) => typeof nonce === "string" && /^[a-f0-9-]{36}$/.test(nonce)) ||
+            !Array.isArray(state.reads) ||
+            !state.reads.every((read) => object(read) &&
+                typeof read.address === "string" &&
+                typeof read.digest === "string" &&
+                /^[a-f0-9]{64}$/.test(read.digest)) ||
+            (state.address !== undefined && typeof state.address !== "string"))
+            return invalidState();
+        if (context.mcpReq.method !== "tools/call" || context.http?.req?.headers.get("Mcp-Name") !== state.tool)
+            return invalidState();
+        return state;
+    }
+    async browserProgress(state) {
+        let started;
+        let claimed;
+        let completed = false;
+        let pending = false;
+        for (const nonce of state.browserNonces) {
+            const progress = await this.options.linkProgress(state.connector, nonce);
+            if (progress === "started")
+                started = nonce;
+            if (progress === "claimed")
+                claimed = nonce;
+            completed ||= progress === "started";
+            pending ||= progress === "claimed";
+        }
+        const predecessor = started ?? claimed;
+        return { ...(predecessor ? { predecessor } : {}), completed: completed && !pending };
+    }
+    async connected(id, context) {
+        const { registry, publicUrl, vault, principal, defer } = this.options;
+        const connector = registry.getConnector(id);
+        const scope = {};
+        const signal = AbortSignal.any([context.mcpReq.signal, this.options.requestSignal]);
+        try {
+            return await runEdge(withDeadlineEffect((deadline) => Effect.gen(function* () {
+                const ctx = registry.contextFor(id, publicUrl, scope, { signal: deadline });
+                yield* Effect.addFinalizer(() => closeScope(connector, ctx, defer));
+                if (connector.credential) {
+                    const metadata = yield* Effect.promise(() => vault.metadata(id, connector.authScope === "personal" ? principal : undefined));
+                    if (storedCredentialShape(connector.credential, metadata?.fields ?? null).state !== "valid")
+                        return false;
+                }
+                if (!connector.status)
+                    return Boolean(connector.credential);
+                return ((yield* Effect.promise(() => registry.statusFor(id, publicUrl, scope, { signal: deadline }))).state ===
+                    "ok");
+            }).pipe(Effect.scoped), { signal, timeoutMs: 5000, timeoutError: new Error("Auth status check timed out") }));
+        }
+        catch {
+            return false;
+        }
+    }
+    async run(tool, args, context, operation) {
+        this.downstream.bind(context);
+        const prior = context.mcpReq.requestState();
+        if (prior?.version === 2)
+            return this.downstream.resume(prior, tool, args, context, operation);
+        const previous = prior;
+        const requestDigest = previous ? await digest(tool, args) : undefined;
+        if (previous && (previous.tool !== tool || previous.digest !== requestDigest || previous.address !== args.address))
+            return failure("invalid_request_state", "Invalid or expired requestState");
+        const response = context.mcpReq.inputResponses?.[INPUT_KEY];
+        if (previous && object(response) && !["accept", "decline", "cancel"].includes(String(response.action))) {
+            throw new ProtocolError(INVALID_PARAMS, "Invalid auth elicitation response", {
+                reason: "invalid_input_response",
+            });
+        }
+        if (previous && !(await this.options.claimRetry(previous.connector, previous.browserNonces.at(-1)))) {
+            return failure("invalid_request_state", "Invalid or expired requestState");
+        }
+        if (previous && object(response)) {
+            if (response.action === "decline")
+                return failure("auth_declined", "Connection was declined. The request was not retried.");
+            if (response.action === "cancel")
+                return failure("auth_cancelled", "Connection was cancelled. The request was not retried.");
+        }
+        if (previous?.reads.length) {
+            const catalog = new CatalogService(this.options.registry, this.options.publicUrl, {
+                requestScope: this.options.requestScope,
+                requestSignal: AbortSignal.any([context.mcpReq.signal, this.options.requestSignal]),
+            });
+            // Recheck every entered read before restarting any part of a program.
+            // A trusted pool cannot authorize replay of a newly classified write.
+            for (const read of previous.reads) {
+                const current = await catalog.resolveTool(read.address, { signal: context.mcpReq.signal });
+                if (!current.ok ||
+                    current.resolved.classificationFresh !== true ||
+                    current.resolved.definition.classification !== "read" ||
+                    (await classificationDigest(current.resolved.definition)) !== read.digest) {
+                    const structuredContent = {
+                        ok: false,
+                        error: {
+                            code: "auth_replay_refused",
+                            retryable: false,
+                            reconciliationRequired: true,
+                            message: "An entered read no longer has the same fresh classification. Reconcile its target before starting a new request.",
+                            authorizationUrl: (await this.options.connectLink(previous.connector)).url,
+                        },
+                    };
+                    return {
+                        isError: true,
+                        structuredContent,
+                        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+                    };
+                }
+            }
+            bindReplayReads(this.options.requestScope, previous.reads);
+        }
+        const browser = previous && tool === "authorize_connector" ? await this.browserProgress(previous) : undefined;
+        if (browser?.completed && previous) {
+            // Retire unspent links before the status read. A browser claim racing
+            // these CASes either wins and is observed as pending, or is refused.
+            await this.options.closeLinks(previous.connector, previous.browserNonces);
+            if ((await this.browserProgress(previous)).completed && (await this.connected(previous.connector, context))) {
+                const structuredContent = { connector: previous.connector, status: "ok" };
+                return { structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
+            }
+        }
+        let result = await operation();
+        const relayed = await this.downstream.finish(tool, args, context, result, previous);
+        if (relayed !== result)
+            return relayed;
+        const error = result.structuredContent?.error;
+        const authFailure = result.isError && object(error) && (error.code === "auth_required" || error.code === "downstream_oauth_required");
+        const explicit = tool === "authorize_connector" &&
+            ["oauth", "operator_config"].includes(String(result.structuredContent?.recovery));
+        if (!authFailure && !explicit)
+            return result;
+        const id = authFailure ? error.connector : explicit ? args.connector : undefined;
+        // Every accepted retry owns new request-local facts. Handler-authored
+        // errors and program write summaries cannot establish replay eligibility.
+        const facts = await authRecoveryFacts(this.options.requestScope, String(id));
+        const blocked = !explicit && (!facts.eligible || facts.writeEntered);
+        if (authFailure && (facts.unsafeEntered || (tool !== "call_tool" && !facts.eligible))) {
+            const structuredContent = {
+                ...result.structuredContent,
+                error: {
+                    ...error,
+                    retryable: false,
+                    reconciliationRequired: true,
+                    retry: "This call may have partially run. Reconcile its target before retrying after the operator completes recovery.",
+                },
+            };
+            result = { ...result, structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
+        }
+        const { registry, vault, principal, publicUrl, canManage, unavailable } = this.options;
+        const connector = typeof id === "string" ? registry.getConnector(id) : undefined;
+        const recoverable = connector?.startAuth || (connector?.credential && this.options.credentialUi);
+        if (typeof id !== "string" ||
+            !/^[a-z0-9_-]+$/.test(id) ||
+            !recoverable ||
+            !principal ||
+            !publicUrl ||
+            unavailable ||
+            !canManage(id))
+            return result;
+        const envelope = context.mcpReq.envelope;
+        const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY];
+        const elicitation = object(capabilities) ? capabilities.elicitation : undefined;
+        const capable = envelope?.[PROTOCOL_VERSION_META_KEY] === "2026-07-28" &&
+            object(elicitation) &&
+            Object.hasOwn(elicitation, "url") &&
+            object(elicitation.url);
+        if (blocked || !capable || !vault?.requestStateKey || !vault.seal || !vault.open) {
+            if (!authFailure)
+                return result;
+            const structuredContent = {
+                ...result.structuredContent,
+                error: {
+                    ...result.structuredContent?.error,
+                    authorizationUrl: (await this.options.connectLink(id)).url,
+                },
+            };
+            return { ...result, structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
+        }
+        if (previous && previous.round >= MAX_ROUNDS)
+            return failure("auth_round_limit", "Connection is still required after three prompts. Connect explicitly, then start a new request.");
+        // Once a verified browser has started this attempt, retries continue it.
+        // A pending consent must never be reset by another force=true prompt.
+        const forced = explicit && args.force === true;
+        const link = await this.options.connectLink(id, forced && !browser?.predecessor, forced ? browser?.predecessor : undefined);
+        const state = {
+            version: 1,
+            principal,
+            endpoint: this.options.endpoint,
+            connector: id,
+            tool,
+            ...(typeof args.address === "string" ? { address: args.address } : {}),
+            digest: requestDigest ?? (await digest(tool, args)),
+            round: (previous?.round ?? 0) + 1,
+            expiresAt: previous?.expiresAt ?? Date.now() + TTL_MS,
+            browserNonces: [...(previous?.browserNonces ?? []), link.nonce],
+            reads: [...new Map([...(previous?.reads ?? []), ...facts.reads].map((read) => [read.address, read])).values()],
+        };
+        const wire = await (await this.stateCodec()).mint(state, context);
+        if (wire.length > 8192) {
+            const structuredContent = {
+                ...result.structuredContent,
+                error: {
+                    ...result.structuredContent?.error,
+                    authorizationUrl: link.url,
+                },
+            };
+            return { ...result, structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
+        }
+        return inputRequired({
+            inputRequests: {
+                [INPUT_KEY]: inputRequired.elicitUrl({
+                    message: MESSAGE,
+                    url: link.url,
+                }),
+            },
+            requestState: wire,
+        });
+    }
+}

package/dist/branding.d.ts

@@ -48,25 +48,18 @@ export declare function droppedThemeTokens(theme?: ConnectaTheme): string[];
  * anything that would need escaping is dropped rather than rewritten.
  */
 export declare function themeCss(theme: ResolvedTheme): string;
-/**
- * The resolved scheme as the root element's attribute. The dark palette keys
- * off `html[data-scheme]`, so "system" leaves it off and the media query
- * decides.
- */
-export declare function schemeAttribute(theme: ResolvedTheme): string;
 /** Text or attribute value, escaped for any position in an HTML document. */
 export declare function escapeHtml(value: string): string;
 export interface PageLayout {
     /** The complete `<title>`. */
     title: string;
+    /** The SPA puts the masthead in its sidebar. */
+    operatorShell?: boolean;
     /** Whether the operator UI is mounted, and so serves `/favicon.*` and `/`. */
     uiMounted: boolean;
     /**
      * The origin that serves `/favicon.*`, for a page that may be rendered on
-     * another host: root-relative icon hrefs resolve against it. A browser 404
-     * on the artifact host passes `publicUrl`, since that host answers every
-     * non-artifact path, the favicons included, with 404. Omitted, they stay
-     * root-relative.
+     * another host: root-relative icon hrefs resolve against it. Omitted, they stay root-relative.
      */
     iconOrigin?: string | undefined;
     /** Markup after the masthead: the page's `<main>`. */
@@ -119,15 +112,14 @@ export declare const STATUS_ICONS: {
 /**
  * The 404 a browser gets for a path nothing serves, and everyone else's plain
  * `Not Found`. The body is built from deployment configuration alone and names
- * no path, so every unserved path — on the main host or an artifact host —
- * answers with the same bytes for the same `Accept`: a 404 must not tell one
+ * no path, so every unserved path answers with the same bytes for the same `Accept`: a 404 must not tell one
  * route from another. The home link appears only when the operator UI is
- * mounted to land on, and points at the public origin so an artifact host's
- * 404 does not link to another 404.
+ * mounted to land on, and points at the configured public origin.
  */
 export declare function notFoundResponse(request: Request, opts: {
-    branding?: ConnectaBranding | undefined;
-    ui?: object | undefined;
+    ui?: {
+        readonly branding?: ConnectaBranding | undefined;
+    } | undefined;
     publicUrl?: string | undefined;
 }): Response;
 /**

package/dist/branding.js

@@ -1,4 +1,5 @@
 import { PAGE_CSS, TOKENS_CSS } from "./page-styles.js";
+import { htmlSecurityHeaders } from "./html-security.js";
 /** Connecta's default monochrome "C" mark. */
 export const CONNECTA_FAVICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
   <style>
@@ -33,11 +34,8 @@ export function resolveBranding(branding) {
         ...(ownerUrl && isSafeHttpUrl(ownerUrl) ? { ownerUrl } : {}),
         description: trimmedString(branding?.description) ??
             `Manage the services this ${productName} instance makes available to agents.`,
-        pageTitle: trimmedString(branding?.pageTitle) ??
-            (ownerName ? `${productName} — ${ownerName}` : productName),
-        faviconHref: faviconHref && isSafeIconHref(faviconHref)
-            ? faviconHref
-            : DEFAULT_FAVICON_HREF,
+        pageTitle: trimmedString(branding?.pageTitle) ?? (ownerName ? `${productName} — ${ownerName}` : productName),
+        faviconHref: faviconHref && isSafeIconHref(faviconHref) ? faviconHref : DEFAULT_FAVICON_HREF,
         themeColor: configuredThemeColor(branding) ?? "#ffffff",
         theme: resolveTheme(branding?.theme),
     };
@@ -63,8 +61,7 @@ function isFontStack(value) {
     if (value.length > 200)
         return false;
     const names = value.split(",");
-    return names.length <= 12 &&
-        names.every((name) => FONT_NAME.test(name.trim()));
+    return names.length <= 12 && names.every((name) => FONT_NAME.test(name.trim()));
 }
 const COLOR_SCHEMES = ["system", "light", "dark"];
 /**
@@ -96,9 +93,7 @@ export function resolveTheme(theme) {
  */
 function radiusLength(radius) {
     if (typeof radius === "number") {
-        return Number.isFinite(radius) && radius >= 0 && radius <= 999
-            ? `${radius}px`
-            : undefined;
+        return Number.isFinite(radius) && radius >= 0 && radius <= 999 ? `${radius}px` : undefined;
     }
     const value = trimmedString(radius);
     if (!value || !CSS_LENGTH.test(value))
@@ -128,8 +123,7 @@ export function droppedThemeTokens(theme) {
     }
     // Compared against the trimmed value the resolver reads, so `" dark "` is
     // not reported as dropped when it was applied.
-    if (isSetValue(theme.colorScheme) &&
-        trimmedString(theme.colorScheme) !== resolved.colorScheme) {
+    if (isSetValue(theme.colorScheme) && trimmedString(theme.colorScheme) !== resolved.colorScheme) {
         dropped.push("colorScheme");
     }
     return dropped.map((token) => `theme.${token}`);
@@ -154,18 +148,12 @@ export function themeCss(theme) {
  * off `html[data-scheme]`, so "system" leaves it off and the media query
  * decides.
  */
-export function schemeAttribute(theme) {
-    return theme.colorScheme === "system"
-        ? ""
-        : ` data-scheme="${theme.colorScheme}"`;
+function schemeAttribute(theme) {
+    return theme.colorScheme === "system" ? "" : ` data-scheme="${theme.colorScheme}"`;
 }
 /** Text or attribute value, escaped for any position in an HTML document. */
 export function escapeHtml(value) {
-    return value
-        .replaceAll("&", "&amp;")
-        .replaceAll('"', "&quot;")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;");
+    return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 /**
  * The masthead's `--surface` in each palette, for the browser chrome a
@@ -184,8 +172,8 @@ function themeColorMeta(branding, theme) {
     if (theme.colorScheme !== "system") {
         return `<meta name="theme-color" content="${SURFACE[theme.colorScheme]}">`;
     }
-    return `<meta name="theme-color" content="${SURFACE.light}" media="(prefers-color-scheme: light)">\n` +
-        `<meta name="theme-color" content="${SURFACE.dark}" media="(prefers-color-scheme: dark)">`;
+    return (`<meta name="theme-color" content="${SURFACE.light}" media="(prefers-color-scheme: light)">\n` +
+        `<meta name="theme-color" content="${SURFACE.dark}" media="(prefers-color-scheme: dark)">`);
 }
 /**
  * The one page layout every server-rendered page shares: the operator shell,
@@ -212,22 +200,16 @@ export function renderPage(branding, layout) {
     const owner = brand.ownerName
         ? label("brand", brand.ownerName, brand.ownerUrl)
         : label("brand", brand.productName, brand.productUrl);
-    const product = brand.ownerName
-        ? label("product", brand.productName, brand.productUrl)
-        : "";
+    const product = brand.ownerName ? label("product", brand.productName, brand.productUrl) : "";
     const customIcon = brand.faviconHref !== DEFAULT_FAVICON_HREF;
     // `isSafeIconHref` already limited a relative href to one leading slash, so
     // resolving it can only land on `iconOrigin` itself.
-    const iconHref = (href) => layout.iconOrigin && href.startsWith("/")
-        ? new URL(href, layout.iconOrigin).toString()
-        : href;
+    const iconHref = (href) => layout.iconOrigin && href.startsWith("/") ? new URL(href, layout.iconOrigin).toString() : href;
     const icons = [
         ...(customIcon || layout.uiMounted
             ? [`<link rel="icon" href="${escapeHtml(iconHref(brand.faviconHref))}" type="image/svg+xml">`]
             : []),
-        ...(layout.uiMounted
-            ? [`<link rel="shortcut icon" href="${escapeHtml(iconHref("/favicon.ico"))}">`]
-            : []),
+        ...(layout.uiMounted ? [`<link rel="shortcut icon" href="${escapeHtml(iconHref("/favicon.ico"))}">`] : []),
     ];
     const skip = layout.skipTo
         ? `<a class="skip-link" href="#${escapeHtml(layout.skipTo.id)}">${escapeHtml(layout.skipTo.label)}</a>\n`
@@ -245,7 +227,7 @@ ${icons.join("\n")}
 ${layout.head ?? ""}
 <style>${styles}${themeCss(brand.theme)}</style>
 </head>
-<body>
+<body${layout.operatorShell ? ' class="operator-shell"' : ""}>
 ${skip}<header class="masthead shell">
   <div class="masthead-inner">
     <div class="mast-nav">
@@ -278,17 +260,15 @@ function wantsHtml(request) {
 /**
  * The 404 a browser gets for a path nothing serves, and everyone else's plain
  * `Not Found`. The body is built from deployment configuration alone and names
- * no path, so every unserved path — on the main host or an artifact host —
- * answers with the same bytes for the same `Accept`: a 404 must not tell one
+ * no path, so every unserved path answers with the same bytes for the same `Accept`: a 404 must not tell one
  * route from another. The home link appears only when the operator UI is
- * mounted to land on, and points at the public origin so an artifact host's
- * 404 does not link to another 404.
+ * mounted to land on, and points at the configured public origin.
  */
 export function notFoundResponse(request, opts) {
     if (!wantsHtml(request)) {
         return new Response("Not Found", { status: 404, headers: { Vary: "Accept" } });
     }
-    const brand = resolveBranding(opts.branding);
+    const brand = resolveBranding(opts.ui?.branding);
     const uiMounted = Boolean(opts.ui);
     const homeHref = opts.publicUrl ? new URL("/", opts.publicUrl).toString() : "/";
     const home = uiMounted
@@ -305,7 +285,7 @@ export function notFoundResponse(request, opts) {
     ${home}
   </section>
 </main>`;
-    return new Response(renderPage(opts.branding, {
+    return new Response(renderPage(opts.ui?.branding, {
         title: `Page not found — ${brand.pageTitle}`,
         uiMounted,
         // Same bytes on either host: the icons, like the home link, come from
@@ -314,7 +294,7 @@ export function notFoundResponse(request, opts) {
         body,
     }), {
         status: 404,
-        headers: { "Content-Type": "text/html; charset=utf-8", Vary: "Accept" },
+        headers: htmlSecurityHeaders({ "Content-Type": "text/html; charset=utf-8", Vary: "Accept" }),
     });
 }
 /**
@@ -326,9 +306,7 @@ export function notFoundResponse(request, opts) {
  * from leaving the field alone, and both take the default silently.
  */
 function isSetValue(value) {
-    return typeof value === "string"
-        ? trimmedString(value) !== undefined
-        : value !== undefined && value !== null;
+    return typeof value === "string" ? trimmedString(value) !== undefined : value !== undefined && value !== null;
 }
 /**
  * Names of the branding URLs the operator set that failed their gate and were
@@ -342,16 +320,9 @@ export function droppedBrandingUrls(branding) {
     const resolved = resolveBranding(branding);
     const faviconHref = branding.favicon?.href;
     return [
-        ...(isSetValue(branding.productUrl) && !resolved.productUrl
-            ? ["productUrl"]
-            : []),
-        ...(isSetValue(branding.ownerUrl) && !resolved.ownerUrl
-            ? ["ownerUrl"]
-            : []),
-        ...(isSetValue(faviconHref) &&
-            trimmedString(faviconHref) !== resolved.faviconHref
-            ? ["favicon.href"]
-            : []),
+        ...(isSetValue(branding.productUrl) && !resolved.productUrl ? ["productUrl"] : []),
+        ...(isSetValue(branding.ownerUrl) && !resolved.ownerUrl ? ["ownerUrl"] : []),
+        ...(isSetValue(faviconHref) && trimmedString(faviconHref) !== resolved.faviconHref ? ["favicon.href"] : []),
     ];
 }
 /**
@@ -443,11 +414,7 @@ export function droppedUiAuthUrls(uiAuth) {
         return [];
     return [
         ...(isSafeHttpsUrl(uiAuth.frontendApiUrl) ? [] : ["uiAuth.frontendApiUrl"]),
-        ...(isSetValue(uiAuth.signInUrl) && !isSafeHttpsUrl(uiAuth.signInUrl)
-            ? ["uiAuth.signInUrl"]
-            : []),
-        ...(isSetValue(uiAuth.signUpUrl) && !isSafeHttpsUrl(uiAuth.signUpUrl)
-            ? ["uiAuth.signUpUrl"]
-            : []),
+        ...(isSetValue(uiAuth.signInUrl) && !isSafeHttpsUrl(uiAuth.signInUrl) ? ["uiAuth.signInUrl"] : []),
+        ...(isSetValue(uiAuth.signUpUrl) && !isSafeHttpsUrl(uiAuth.signUpUrl) ? ["uiAuth.signUpUrl"] : []),
     ];
 }

package/dist/byte-read-response.js

@@ -0,0 +1,39 @@
+// Web-API only, like the rest of the core: Node and workerd read a body alike.
+const decoder = new TextDecoder();
+/**
+ * A downstream's response whose `text()` and `json()` read bytes.
+ *
+ * workerd, when `.text()` (and `.json()`, which reads text) meets a body whose
+ * Content-Type it does not parse as text, prints a native warning quoting that
+ * Content-Type whole: below every console and logger, so a downstream could
+ * write into the deployment's log (INV-6, #695). No filter on the header can
+ * agree with workerd's own parser for every value a downstream can send, so
+ * connecta never asks for text: `arrayBuffer()` carries no such warning, and
+ * the bytes are decoded here exactly as `text()` would decode them (UTF-8,
+ * BOM stripped, malformed sequences replaced).
+ *
+ * The response itself is returned, its readers shadowed by own properties, so
+ * `status`, `headers`, `url`, `body`, and `instanceof Response` are unchanged,
+ * and so is everything an SDK or a handler reads. A clone is shadowed too:
+ * the pinned SDK reads a token response's `clone().json()`.
+ */
+export function byteReadResponse(response) {
+    if (!Object.isExtensible(response)) {
+        // A custom fetch that froze its response: shadow a copy instead, which
+        // keeps everything but `url` and `redirected`.
+        return byteReadResponse(new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        }));
+    }
+    const arrayBuffer = response.arrayBuffer.bind(response);
+    const clone = response.clone.bind(response);
+    const text = async () => decoder.decode(await arrayBuffer());
+    const own = (value) => ({ value, configurable: true, writable: true });
+    return Object.defineProperties(response, {
+        text: own(text),
+        json: own(async () => JSON.parse(await text())),
+        clone: own(() => byteReadResponse(clone())),
+    });
+}

package/dist/call-admission.js

@@ -1,6 +1,6 @@
 import { Deferred, Duration, Effect } from "effect";
 import { ConnectorCallError } from "./errors.js";
-import { provideCallAdmissionProgram, startCallAdmission, } from "./runtime/call-admission.js";
+import { provideCallAdmissionProgram, startCallAdmission } from "./runtime/call-admission.js";
 import { fromSignal, runEdge } from "./runtime/run.js";
 const DEFAULT_MAX_QUEUE_SIZE = 32;
 const DEFAULT_QUEUE_TIMEOUT_MS = 5_000;
@@ -28,7 +28,11 @@ export function isCallAdmissionError(error) {
 /** Sum gauges and counters without publishing connector or principal keys. */
 export function aggregateCallAdmissionSnapshots(snapshots) {
     const aggregate = {
-        rules: 0, partitions: 0, active: 0, queued: 0, closed: snapshots.length > 0,
+        rules: 0,
+        partitions: 0,
+        active: 0,
+        queued: 0,
+        closed: snapshots.length > 0,
         totals: { admitted: 0, queued: 0, rejected: 0, rateLimited: 0, cancelled: 0 },
         queueWaitMs: { count: 0, total: 0, max: 0 },
     };
@@ -88,8 +92,7 @@ export class ConnectorCallAdmissionController {
             throw new TypeError(`connector "${connectorId}" callAdmission.rules must contain exactly one rule in this release.`);
         }
         const rule = policy.rules[0];
-        if (rule.maxConcurrency === undefined &&
-            rule.budget === undefined) {
+        if (rule.maxConcurrency === undefined && rule.budget === undefined) {
             throw new TypeError(`connector "${connectorId}" callAdmission rule must declare maxConcurrency or budget.`);
         }
         this.maxConcurrency =
@@ -97,9 +100,7 @@ export class ConnectorCallAdmissionController {
                 ? undefined
                 : positiveWhole(rule.maxConcurrency, `connector "${connectorId}" callAdmission maxConcurrency`);
         if (this.maxConcurrency === undefined &&
-            (rule.maxQueueSize !== undefined ||
-                rule.queueTimeoutMs !== undefined ||
-                rule.retryAfterMs !== undefined)) {
+            (rule.maxQueueSize !== undefined || rule.queueTimeoutMs !== undefined || rule.retryAfterMs !== undefined)) {
             throw new TypeError(`connector "${connectorId}" callAdmission queue settings require maxConcurrency.`);
         }
         this.maxQueueSize = nonNegativeWhole(rule.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE, `connector "${connectorId}" callAdmission maxQueueSize`);
@@ -193,8 +194,7 @@ export class ConnectorCallAdmissionController {
     pump(state) {
         if (this.closed || this.maxConcurrency === undefined)
             return;
-        while (state.active < this.maxConcurrency &&
-            state.waiters.length > 0) {
+        while (state.active < this.maxConcurrency && state.waiters.length > 0) {
             const waiter = state.waiters.shift();
             // The waiter's signal is not read here. This runs in whichever request
             // released a slot, and on Workers reading an AbortSignal that another
@@ -248,9 +248,7 @@ export class ConnectorCallAdmissionController {
     }
     maybeDeletePartition(key, state, now) {
         this.pruneBudget(state, now);
-        if (state.active === 0 &&
-            state.waiters.length === 0 &&
-            state.admittedAt.length === 0) {
+        if (state.active === 0 && state.waiters.length === 0 && state.admittedAt.length === 0) {
             this.partitions.delete(key);
         }
     }
@@ -322,8 +320,7 @@ export class ConnectorCallAdmissionController {
                 controller.rejectedTotal++;
                 return Effect.fail(new CallAdmissionError("partition", "connector_call_failed", `Connector "${controller.connectorId}" call-admission partitionKey threw.`, { cause }));
             }
-            if (typeof key !== "string" ||
-                enc.encode(key).length > MAX_PARTITION_KEY_BYTES) {
+            if (typeof key !== "string" || enc.encode(key).length > MAX_PARTITION_KEY_BYTES) {
                 controller.rejectedTotal++;
                 return Effect.fail(new CallAdmissionError("partition", "connector_call_failed", `Connector "${controller.connectorId}" call-admission partitionKey must return a string of at most ${MAX_PARTITION_KEY_BYTES} UTF-8 bytes.`));
             }
@@ -352,8 +349,7 @@ export class ConnectorCallAdmissionController {
                 controller.rateLimitedTotal++;
                 return Effect.fail(controller.budgetLimited(budgetRetryAfterMs));
             }
-            if (controller.maxConcurrency === undefined ||
-                state.active < controller.maxConcurrency) {
+            if (controller.maxConcurrency === undefined || state.active < controller.maxConcurrency) {
                 return Effect.succeed(controller.admit(state, queuedAt, 0));
             }
             if (state.waiters.length >= controller.maxQueueSize) {