@zackbart/connecta 0.24.3 → 0.25.0

package/dist/storage/memory.js

@@ -12,27 +12,28 @@ export function memoryStorage() {
         }
         return e;
     };
+    const write = (key, value, ttlSeconds) => {
+        // Rotate through at most 16 existing keys. Live entries cannot keep an
+        // expired tail resident forever, and no request starts a background job.
+        for (let i = 0; i < 16; i++) {
+            const next = sweep.next();
+            if (next.done) {
+                sweep = map.keys();
+                break;
+            }
+            fresh(next.value);
+        }
+        map.set(key, {
+            value,
+            ...(ttlSeconds ? { exp: Date.now() + ttlSeconds * 1000 } : {}),
+        });
+    };
     return {
         async get(key) {
             return fresh(key)?.value ?? null;
         },
         async set(key, value, opts) {
-            // Rotate through at most 16 existing keys. Live entries cannot keep an
-            // expired tail resident forever, and no request starts a background job.
-            for (let i = 0; i < 16; i++) {
-                const next = sweep.next();
-                if (next.done) {
-                    sweep = map.keys();
-                    break;
-                }
-                fresh(next.value);
-            }
-            map.set(key, {
-                value,
-                ...(opts?.ttlSeconds
-                    ? { exp: Date.now() + opts.ttlSeconds * 1000 }
-                    : {}),
-            });
+            write(key, value, opts?.ttlSeconds);
         },
         async delete(key) {
             map.delete(key);
@@ -45,5 +46,16 @@ export function memoryStorage() {
             })
                 .sort();
         },
+        // Atomic because nothing between the read and the write yields: the body
+        // runs to completion before any other call on this map can start.
+        async compareAndSet(key, expected, next, opts) {
+            if ((fresh(key)?.value ?? null) !== expected)
+                return false;
+            if (next === null)
+                map.delete(key);
+            else
+                write(key, next, opts?.ttlSeconds);
+            return true;
+        },
     };
 }

package/dist/timeout.js

@@ -1,5 +1,7 @@
 // The deadline vocabulary shared by downstream discovery probes and tool calls.
 // One definition keeps those waits bounded consistently.
+import { Effect } from "effect";
+import { runEdge, withDeadlineEffect } from "./runtime/run.js";
 /**
  * Generous default bound for a single downstream probe/catalog call. High enough
  * to trip only on a pathological hang, not a realistically slow probe.
@@ -12,54 +14,22 @@ export function normalizeTimeoutMs(value) {
     }
     return Math.max(1, Math.trunc(value));
 }
-/** Resolve after `ms`, or false when the caller aborts first. */
-export function sleep(ms, signal) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const finish = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", cancel);
-            resolve(value);
-        };
-        const timer = setTimeout(() => finish(true), ms);
-        const cancel = () => finish(false);
-        signal?.addEventListener("abort", cancel, { once: true });
-        if (signal?.aborted)
-            cancel();
-    });
-}
+/**
+ * Run one operation under a deadline and the caller's signal, whichever ends
+ * it first.
+ *
+ * The operation gets a signal of its own: the caller's abort is forwarded to
+ * it, and the deadline aborts it with `timeoutError`. Either way the promise
+ * rejects with that signal's reason, without waiting for work that ignores
+ * the signal. A synchronous throw rejects like an asynchronous one. This is
+ * the Promise face of `withDeadlineEffect` (src/runtime/run.ts), which owns
+ * the contract; an Effect caller uses that directly.
+ */
 export function withDeadline(operation, options) {
-    const controller = new AbortController();
-    const forwardAbort = () => controller.abort(options.signal?.reason);
-    options.signal?.addEventListener("abort", forwardAbort, { once: true });
-    if (options.signal?.aborted)
-        forwardAbort();
-    let rejectAbort;
-    const aborted = new Promise((_, reject) => { rejectAbort = reject; });
-    const onAbort = () => rejectAbort(controller.signal.reason ?? options.timeoutError);
-    controller.signal.addEventListener("abort", onAbort, { once: true });
-    if (controller.signal.aborted)
-        onAbort();
-    const timer = options.timeoutMs === undefined
-        ? undefined
-        : setTimeout(() => controller.abort(options.timeoutError), options.timeoutMs);
-    let work;
-    try {
-        work = operation(controller.signal);
-    }
-    catch (error) {
-        work = Promise.reject(error);
-    }
-    return Promise.race([work, aborted]).finally(() => {
-        controller.abort();
-        if (timer)
-            clearTimeout(timer);
-        controller.signal.removeEventListener("abort", onAbort);
-        options.signal?.removeEventListener("abort", forwardAbort);
-    });
+    return runEdge(withDeadlineEffect((signal) => Effect.tryPromise({
+        try: () => operation(signal),
+        catch: (error) => error,
+    }), options));
 }
 /**
  * Give one operation a caller-facing deadline and the matching cancellation

package/dist/types.d.ts

@@ -12,6 +12,26 @@ export interface KVStorage {
      * subsystems that need independent, enumerable records require it explicitly.
      */
     list?(prefix: string): Promise<string[]>;
+    /**
+     * Atomic compare-and-set: write `next` only if the key's current value is
+     * exactly `expected`, and report whether the write happened. `expected:
+     * null` means "absent", and an expired entry is absent. `next: null`
+     * deletes; otherwise `next` is stored with `options.ttlSeconds`, or with no
+     * expiry when that is omitted, exactly as `set` would. On `false` nothing
+     * changed.
+     *
+     * Atomic means linearizable against every other operation on the same
+     * store, `set` and `delete` included: of N concurrent `compareAndSet(key,
+     * null, value)` claims on an absent key, exactly one returns true.
+     *
+     * Optional, because not every backend can promise it: an eventually
+     * consistent store such as Cloudflare Workers KV must omit the method
+     * rather than emulate it with a read followed by a write. Subsystems that
+     * need an atomic claim require it explicitly.
+     */
+    compareAndSet?(key: string, expected: string | null, next: string | null, options?: {
+        ttlSeconds?: number;
+    }): Promise<boolean>;
 }
 export interface Logger {
     debug(...args: unknown[]): void;
@@ -106,7 +126,7 @@ export interface ConnectorCredentialFieldConfig {
     name: string;
     /** Short field label, e.g. "Account email". */
     label: string;
-    /** Plain-language guidance shown in /credentials. Never include the credential itself. */
+    /** Plain-language guidance shown in the connection's credential form in the operator UI. Never include the credential itself. */
     description?: string;
     /** Input placeholder, e.g. "you@example.com". */
     placeholder?: string;
@@ -117,7 +137,7 @@ export interface ConnectorCredentialFieldConfig {
 export interface ConnectorCredentialConfig {
     /** Short group or field label, e.g. "API token" or "Service credentials". */
     label: string;
-    /** Plain-language guidance shown in /credentials. Never include the credential itself. */
+    /** Plain-language guidance shown in the connection's credential form in the operator UI. Never include the credential itself. */
     description?: string;
     /** Password-field placeholder, e.g. "Paste API token". */
     placeholder?: string;
@@ -142,7 +162,7 @@ export interface ConnectorContext {
     /**
      * Read-only access to this connector's human-managed credential. Present
      * only when the connector declares `credential` and the deployment configures
-     * `credentials.encryptionKey`.
+     * `vault`.
      */
     credential?: ConnectorCredentialAccess;
     /**
@@ -225,7 +245,7 @@ export interface Connector {
      * Max inline result size (bytes) for this connector's tools before
      * call_tool truncates and stashes the full text for get_result
      * paging. Overrides `ConnectaConfig.calls.maxResultBytes`;
-     * omit to inherit it (which itself defaults to 50_000). Must be a whole
+     * omit to inherit it (which itself defaults to 24_000). Must be a whole
      * number of bytes >= 1; anything else warns at startup and is ignored, so
      * the connector inherits the deployment-wide cap.
      */
@@ -248,11 +268,11 @@ export interface Connector {
      * configuration; no runtime registration or shared mutable copy exists.
      */
     usageGuide?: string | ConnectorUsageGuide;
-    /** Optional human-managed credential slot rendered on /credentials. */
+    /** Optional human-managed credential slot rendered in the connection in the operator UI. */
     credential?: ConnectorCredentialConfig;
-    /** Optional server-side check used by /credentials' Test action. */
+    /** Optional server-side check used by the connection's Test action in the operator UI. */
     testCredential?(value: string, ctx: ConnectorContext): Promise<CredentialTestResult>;
-    /** Optional multi-field credential check used by /credentials' Test action. */
+    /** Optional multi-field credential check used by the connection's Test action in the operator UI. */
     testCredentials?(values: ConnectorCredentialValues, ctx: ConnectorContext): Promise<CredentialTestResult>;
     /**
      * Statically-known tool defs, exposed by in-code connectors (`api()`) for
@@ -519,6 +539,43 @@ export interface ConnectaBranding {
     };
     /** `theme-color` meta value. Defaults to "#ffffff". */
     themeColor?: string;
+    /**
+     * Operator-page appearance. Every field is optional, and a rejected value
+     * takes its default rather than failing the page, so `createConnecta` warns
+     * at startup about anything it dropped.
+     *
+     * Five knobs, not a palette. Surfaces, borders, muted text, and the status
+     * colors all derive from these, so a deployment sets an accent and gets a
+     * readable page instead of thirty chances to break one.
+     */
+    theme?: ConnectaTheme;
+}
+/**
+ * The operator UI's themeable tokens. These land in a `:root` block on the
+ * page, so each is gated by a narrow syntactic check: an unvalidated value
+ * here would let deployment config write arbitrary CSS.
+ */
+export interface ConnectaTheme {
+    /**
+     * The brand color: links, focus rings, primary actions, the active nav item.
+     * Hex only (`#rgb`, `#rrggbb`, or `#rrggbbaa`). Defaults to `#2f5fe0`.
+     */
+    accent?: string;
+    /**
+     * Corner rounding for cards, inputs, and buttons. A CSS length (`10px`,
+     * `0.5rem`) or a bare number read as pixels. `0` restores square corners.
+     * Defaults to `10px`.
+     */
+    radius?: string | number;
+    /** Body font stack. A plain CSS font-family list. Defaults to a system stack. */
+    fontFamily?: string;
+    /** Monospace font stack for addresses, ids, and the endpoint URL. */
+    monoFamily?: string;
+    /**
+     * `"system"` (the default) follows the operator's OS setting; `"light"` and
+     * `"dark"` pin the page to one palette.
+     */
+    colorScheme?: "system" | "light" | "dark";
 }
 /** An inbound authentication provider (bearer token, interactive identity, ...). */
 export interface InboundAuth {

package/dist/ui.d.ts

@@ -1,14 +1,28 @@
 import type { OperatorSurface } from "./module-contracts.js";
 import type { CredentialVault } from "./credential-contract.js";
 import { type DeferredWork } from "./connector-scope.js";
-import { type CredentialManagementCapability, type UiData } from "./operator-ui/model.js";
+import { type CredentialManagementCapability, type UiData, type UiProblem, type UiToolSafety } from "./operator-ui/model.js";
 import type { RegistryView } from "./registry.js";
-import type { ConnectaBranding, UiAuthConfig } from "./types.js";
+import type { ConnectaBranding, Connector, ConnectorStatus, ToolDef, UiAuthConfig } from "./types.js";
 export { filterUiConnectors, type CredentialManagementCapability, type UiConnector, type UiData, } from "./operator-ui/model.js";
 export { CONNECTA_FAVICON_SVG, resolveBranding, isSafeHttpUrl, isSafeHttpsUrl, isSafeIconHref } from "./branding.js";
 export type OperatorPage = "connections" | "activity";
 export declare function operatorPageForPath(path: string): OperatorPage | undefined;
 export declare function operatorPageTitle(page: OperatorPage, configuredTitle: string): string;
+/**
+ * The badge a tool earns, from the one predicate core enforces with. Computed
+ * here so the page reports the rule rather than restating it.
+ */
+export declare function uiToolSafety(definition: ToolDef): UiToolSafety;
+/**
+ * The fix-prompt key for a connector that is not usable. Chosen from the
+ * status state and the connector's declared auth shape — configuration, never
+ * the status message, which can carry a downstream error body.
+ */
+export declare function uiProblemFor(connector: Pick<Connector, "credential" | "startAuth">, status: ConnectorStatus["state"], observed: {
+    credentialDrift: boolean;
+    catalogFailed: boolean;
+}): UiProblem | undefined;
 export declare function credentialManagementCapability(input: {
     eligibleOperator: boolean;
     hasCredentialSlots: boolean;

package/dist/ui.js

@@ -1,14 +1,12 @@
 import { routeUi } from "./routes/ui.js";
 import { routeCredentials } from "./routes/credentials.js";
 import { routeOAuthManagement } from "./routes/oauth-management.js";
-import { withDeadline } from "./timeout.js";
-import { credentialTestRule, describeUndeclaredCredentialFields, storedCredentialShape, } from "./credential-rules.js";
-import { closeConnectorScope, } from "./connector-scope.js";
-import { mapSettledWithConcurrency, resolveDiscoveryConcurrency, } from "./concurrency.js";
+import { uiData } from "./routes/ui-data.js";
+import { runEdge } from "./runtime/run.js";
+import { isExplicitlyReadOnly } from "./tool-safety.js";
 import { OPERATOR_UI_CSS, OPERATOR_UI_SCRIPT, } from "./operator-ui/generated.js";
-import { CONNECTA_VERSION } from "./version.js";
 export { filterUiConnectors, } from "./operator-ui/model.js";
-import { resolveBranding, isSafeHttpsUrl } from "./branding.js";
+import { resolveBranding, isSafeHttpsUrl, themeCss } from "./branding.js";
 export { CONNECTA_FAVICON_SVG, resolveBranding, isSafeHttpUrl, isSafeHttpsUrl, isSafeIconHref } from "./branding.js";
 /**
  * A JS string literal safe to inline in a script element. Escaping `/` keeps
@@ -31,6 +29,30 @@ export function operatorPageForPath(path) {
 export function operatorPageTitle(page, configuredTitle) {
     return `${OPERATOR_PAGE_LABELS[page]} — ${configuredTitle}`;
 }
+/**
+ * The badge a tool earns, from the one predicate core enforces with. Computed
+ * here so the page reports the rule rather than restating it.
+ */
+export function uiToolSafety(definition) {
+    return isExplicitlyReadOnly(definition) ? "runs_in_programs" : "needs_approval";
+}
+/**
+ * The fix-prompt key for a connector that is not usable. Chosen from the
+ * status state and the connector's declared auth shape — configuration, never
+ * the status message, which can carry a downstream error body.
+ */
+export function uiProblemFor(connector, status, observed) {
+    if (observed.credentialDrift)
+        return "credential_mismatch";
+    if (status === "error")
+        return "connector_unavailable";
+    if (status === "auth_required") {
+        if (connector.startAuth)
+            return "oauth_required";
+        return connector.credential ? "credential_required" : "auth_required";
+    }
+    return observed.catalogFailed ? "catalog_failed" : undefined;
+}
 export function credentialManagementCapability(input) {
     if (!input.eligibleOperator)
         return "requires_operator";
@@ -48,169 +70,17 @@ export function credentialManagementCapability(input) {
 export async function buildUiData(registry, baseUrl, serverInfo, credentialVault, activityEnabled = false, credentialManagement = credentialVault
     ? "available"
     : "requires_operator", defer, oauthManagement = false, discoveryConcurrency, personalCredentialOwner, detailOptions = {}) {
-    const requestScope = {};
-    const connectorSet = registry.listConnectors();
-    const concurrency = resolveDiscoveryConcurrency(discoveryConcurrency);
-    const settled = await mapSettledWithConcurrency(connectorSet, concurrency, async (c) => {
-        try {
-            return await withDeadline(async (outerSignal) => {
-                const drift = await registry.credentialDriftFor(c.id);
-                outerSignal.throwIfAborted();
-                let tools = [];
-                let status;
-                try {
-                    status = await withDeadline(async (signal) => {
-                        if (drift)
-                            return { state: "auth_required", message: drift };
-                        const current = await registry.statusFor(c.id, baseUrl, requestScope, { signal });
-                        if (current.state === "ok" && !signal.aborted) {
-                            try {
-                                tools = (await registry.getTools(c.id, baseUrl, requestScope, { signal })).map(t => ({ name: t.name, address: `${c.id}.${t.name}`, ...(t.description ? { description: t.description } : {}) }));
-                            }
-                            catch { /* The registry owns the failed catalog observation. */ }
-                        }
-                        return current;
-                    }, { timeoutMs: detailOptions.timeoutMs ?? 30_000, signal: outerSignal, timeoutError: new Error("Connection details timed out. Retry this connection.") });
-                }
-                catch (error) {
-                    status = { state: "error", message: error instanceof Error ? error.message : "Connection details unavailable" };
-                }
-                let credential;
-                const mayManageAuth = detailOptions.mayManage?.(c.id) ?? (c.authScope === "personal" ? Boolean(personalCredentialOwner) : oauthManagement);
-                if (c.credential && credentialVault && mayManageAuth) {
-                    // One rule, shared with the test route: only the hook matching the
-                    // declared credential shape can run, so the button is offered only
-                    // where a click can succeed (src/credentials.ts).
-                    const testRule = credentialTestRule(c);
-                    const credentialFields = (metadata) => c.credential?.fields?.map((field) => {
-                        const fieldMetadata = metadata?.fields?.[field.name];
-                        return {
-                            name: field.name,
-                            label: field.label,
-                            ...(field.description
-                                ? { description: field.description }
-                                : {}),
-                            ...(field.placeholder
-                                ? { placeholder: field.placeholder }
-                                : {}),
-                            inputType: field.inputType ?? "password",
-                            configured: Boolean(fieldMetadata),
-                            ...(fieldMetadata
-                                ? {
-                                    lastFour: fieldMetadata.lastFour,
-                                    updatedAt: fieldMetadata.updatedAt,
-                                }
-                                : {}),
-                        };
-                    });
-                    const credentialCard = {
-                        label: c.credential.label,
-                        ...(c.credential.description
-                            ? { description: c.credential.description }
-                            : {}),
-                        ...(c.credential.placeholder
-                            ? { placeholder: c.credential.placeholder }
-                            : {}),
-                    };
-                    try {
-                        const metadata = await credentialVault.metadata(c.id, c.authScope === "personal" ? personalCredentialOwner : undefined);
-                        const fields = credentialFields(metadata);
-                        const shape = storedCredentialShape(c.credential, metadata?.fields ?? null);
-                        credential = {
-                            ...credentialCard,
-                            ...(fields?.length ? { fields } : {}),
-                            configured: shape.state === "valid",
-                            removable: Boolean(metadata),
-                            ...(metadata
-                                ? {
-                                    lastFour: metadata.lastFour,
-                                    updatedAt: metadata.updatedAt,
-                                }
-                                : {}),
-                            testable: testRule.mode !== null && shape.state !== "mismatch",
-                            ...(shape.state === "mismatch"
-                                ? { error: shape.message }
-                                : {}),
-                            // A dropped field leaves its secret in the vault, and the field
-                            // list below only renders fields the connector still declares —
-                            // so without this line there is nowhere an operator could see it.
-                            ...(shape.state === "valid" && shape.undeclared.length
-                                ? {
-                                    notice: describeUndeclaredCredentialFields(shape.undeclared),
-                                }
-                                : {}),
-                        };
-                    }
-                    catch {
-                        const fields = credentialFields();
-                        credential = {
-                            ...credentialCard,
-                            ...(fields?.length ? { fields } : {}),
-                            configured: false,
-                            removable: true,
-                            testable: testRule.mode !== null,
-                            error: "Stored credential could not be read.",
-                        };
-                    }
-                }
-                outerSignal.throwIfAborted();
-                return {
-                    id: c.id,
-                    authScope: c.authScope ?? "shared",
-                    ...(c.title ? { title: c.title } : {}),
-                    ...(c.description !== undefined
-                        ? { description: c.description }
-                        : {}),
-                    status: status.state,
-                    ...(status.message ? { message: status.message } : {}),
-                    toolCount: tools.length,
-                    tools,
-                    // Counts only, and only when a refresh in this runtime produced them.
-                    // `Registry.statusFor` already rebuilt the report through
-                    // `boundedCatalogDrift`, so what lands here cannot carry a name or a
-                    // schema even if the plugin seam returned one.
-                    ...(status.catalogDrift ? { catalogDrift: status.catalogDrift } : {}),
-                    ...(status.catalogAccess
-                        ? { catalogAccess: status.catalogAccess }
-                        : {}),
-                    oauth: Boolean(c.startAuth && c.disconnectAuth),
-                    ...(credential ? { credential } : {}),
-                };
-            }, {
-                timeoutMs: detailOptions.timeoutMs ?? 30_000,
-                ...(detailOptions.signal ? { signal: detailOptions.signal } : {}),
-                timeoutError: new Error("Connection details timed out. Retry this connection."),
-            });
-        }
-        catch (error) {
-            return {
-                id: c.id,
-                ...(c.title ? { title: c.title } : {}),
-                authScope: c.authScope ?? "shared",
-                status: "error",
-                oauth: Boolean(c.startAuth && c.disconnectAuth),
-                message: error instanceof Error ? error.message : "Connection details unavailable",
-                toolCount: 0,
-                tools: [],
-            };
-        }
-        finally {
-            await closeConnectorScope(c, registry.contextFor(c.id, baseUrl, requestScope), defer);
-        }
-    });
-    const connectors = settled.map((result) => {
-        if (result.status === "rejected")
-            throw result.reason;
-        return result.value;
-    });
-    return {
+    return runEdge(uiData(registry, baseUrl, {
         serverInfo,
-        connectaVersion: CONNECTA_VERSION,
-        connectors,
+        credentialVault,
         activityEnabled,
         credentialManagement,
-        oauthManagement: oauthManagement || Boolean(personalCredentialOwner),
-    };
+        defer,
+        oauthManagement,
+        discoveryConcurrency,
+        personalCredentialOwner,
+        ...detailOptions,
+    }));
 }
 function escapeHtmlAttr(value) {
     return value
@@ -281,8 +151,14 @@ export function renderUiHtml(uiAuth, mcpUrl = "/mcp", branding, nonce, page = "c
     const clerkScript = clerk && clerkScriptOrigin
         ? `<script${nonceAttr} crossorigin="anonymous" data-clerk-publishable-key="${escapeHtmlAttr(clerk.publishableKey)}" src="${escapeHtmlAttr(clerkScriptOrigin)}/npm/@clerk/clerk-js@6/dist/clerk.browser.js"></script>`
         : "";
+    // A pinned scheme is an attribute, not a stylesheet edit: the dark palette
+    // keys off `html[data-scheme]`, so "system" leaves the attribute off and the
+    // media query decides.
+    const schemeAttr = brand.theme.colorScheme === "system"
+        ? ""
+        : ` data-scheme="${brand.theme.colorScheme}"`;
     return `<!doctype html>
-<html lang="en">
+<html lang="en"${schemeAttr}>
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
@@ -292,22 +168,24 @@ export function renderUiHtml(uiAuth, mcpUrl = "/mcp", branding, nonce, page = "c
 <link rel="shortcut icon" href="/favicon.ico">
 <title>${escapeHtmlAttr(title)}</title>
 ${clerkScript}
-<style>${OPERATOR_UI_CSS}</style>
+<style>${OPERATOR_UI_CSS}${themeCss(brand.theme)}</style>
 </head>
 <body>
 <a class="skip-link" href="#operatorContent">Skip to operator page</a>
-<header class="masthead shell pgrid">
-  ${owner}
-  <div class="mast-nav">
-    ${product}
+<header class="masthead shell">
+  <div class="masthead-inner">
+    <div class="mast-nav">
+      ${owner}
+      ${product}
+    </div>
     <div id="operatorNav"></div>
   </div>
 </header>
 
 <main id="operatorContent" class="page shell" tabindex="-1">
-  <div class="lead pgrid">
-    <h1 class="pcap">${OPERATOR_PAGE_LABELS[page]}</h1>
-    <div class="pbody lead-copy">
+  <div class="lead">
+    <h1>${OPERATOR_PAGE_LABELS[page]}</h1>
+    <div class="lead-copy">
       <p>${escapeHtmlAttr(brand.description)}</p>
       <noscript><p class="msg">The operator pages need JavaScript. Nothing else here
       does — agents reach this deployment through <span class="mono">/mcp</span>.</p></noscript>
@@ -327,15 +205,29 @@ ${OPERATOR_UI_SCRIPT}</script>
 </body>
 </html>`;
 }
+function ownsOperatorPath(reserved, path) {
+    if (path === "/activity")
+        return true;
+    return reserved.some((pattern) => pattern.endsWith("/*")
+        ? path.startsWith(pattern.slice(0, -1))
+        : path === pattern);
+}
 /** Mount the connection UI without enabling any storage or activity module. */
 export function operatorUi(options = {}) {
+    const reservedPaths = ["/", "/ui", "/ui/*", "/favicon.svg", "/favicon.ico"];
     return {
         ...options,
-        reservedPaths: ["/", "/ui", "/ui/*", "/favicon.svg", "/favicon.ico"],
+        reservedPaths,
         credentialHandoffUrl(baseUrl) {
             return new URL("/", baseUrl).toString();
         },
         async handle(context) {
+            // Everything else belongs to the server, and reaches it untouched: no
+            // route here, and no activity module, runs for a path this surface does
+            // not own. The Activity page is the one addition; the server reserves
+            // it only when history is readable, and routeUi checks the same thing.
+            if (!ownsOperatorPath(reservedPaths, context.path))
+                return null;
             const routes = [
                 ...(context.opts.credentialVault ? [routeCredentials] : []),
                 routeOAuthManagement,