@zackbart/connecta 0.37.1 → 0.39.0

package/dist/routes/shared.js

@@ -163,7 +163,7 @@ const authorizeNative = /* @__PURE__ */ registerAuth(authorize, function (reques
             return { ok: false, response: privateJson({ error: "authenticated user required" }, { status: 403 }) };
         }
         // Every caller of this function is a human route. Agents reach pools only at
-        // `/agent/<pool>` (#837), so a workload or `cta_` credential refuses here
+        // `/agent/<pool>`, so a workload or `cta_` credential refuses here
         // without verification, and never falls back to a cookie, session or Access context.
         if (machineCredential) {
             return {
@@ -299,7 +299,7 @@ function agentChallenge() {
     };
 }
 /**
- * Admission at an agent endpoint, `/agent/<pool>` (#837). Only the built-in
+ * Admission at an agent endpoint, `/agent/<pool>`. Only the built-in
  * agent credential adapters are consulted: Clerk and Access never run, cookies and Clerk
  * handshake parameters are stripped, and the runtime context, which carries
  * Access's `ctx.access` even on a bypassed path, is never passed. Anything but
@@ -376,7 +376,7 @@ export function isSameOrigin(request, baseUrl) {
         return false;
     }
 }
-export function withSecurityHeaders(response, requestUrl, _path) {
+export function withSecurityHeaders(response, requestUrl) {
     const headers = response.headers.get("Content-Type")?.toLowerCase().startsWith("text/html")
         ? htmlSecurityHeaders(response.headers)
         : new Headers(response.headers);
@@ -392,7 +392,7 @@ export function withSecurityHeaders(response, requestUrl, _path) {
     });
 }
 /**
- * Plain `/mcp` and every operator route admit a maintainer (#837). An open
+ * Every operator route admits a maintainer. An open
  * deployment has no inbound auth and so no maintainers: its one anonymous
  * caller keeps the whole default endpoint, as the startup warning says.
  */
@@ -401,7 +401,7 @@ export function admitsMaintainer(opts, authz) {
 }
 /**
  * The declared pool `/mcp/<name>` serves to this person, or undefined for the
- * same 404. An agent is never admitted here, even when listed (#837).
+ * same 404. An agent is never admitted here, even when listed.
  */
 export function memberPool(opts, name, identity) {
     if (identity.agent !== undefined)
@@ -409,6 +409,12 @@ export function memberPool(opts, name, identity) {
     const pool = opts.pools.get(name);
     return pool?.members.some((member) => isMember(member, identity)) ? pool : undefined;
 }
+/** Human memberships, matched only against the resolved namespaced principal. */
+export function personPools(opts, identity) {
+    if (identity.agent !== undefined)
+        return [];
+    return [...opts.pools].filter(([, pool]) => pool.members.some((member) => isMember(member, identity)));
+}
 /** The declared pool `/agent/<name>` serves to this agent, or undefined for the same 404. */
 export function agentPool(opts, name, identity) {
     if (identity.agent === undefined)
@@ -417,7 +423,7 @@ export function agentPool(opts, name, identity) {
     return pool?.members.some((member) => member.kind === "agent" && isMember(member, identity)) ? pool : undefined;
 }
 /**
- * The connectors of every pool this identity is a member of (#837): what a
+ * The connectors of every pool this identity is a member of: what a
  * pool member may ever manage, and only their personal ones among these.
  */
 export function memberConnectors(opts, identity) {
@@ -435,7 +441,7 @@ export function memberConnectors(opts, identity) {
 }
 /**
  * Whether this identity may start, finish, or remove a connector's auth
- * (#837). Only an interactive person ever may; an agent or any other machine
+ * Only an interactive person ever may; an agent or any other machine
  * credential manages nothing. Shared auth is deployment-wide, so it takes a
  * maintainer. A personal connector takes a stable principal that is a
  * maintainer, whose plain `/mcp` includes it, or a member of a pool that
@@ -454,12 +460,12 @@ export function mayManageConnector(opts, authz, connector) {
     const pools = memberConnectors(opts, identity);
     return pools === "all" || pools.has(connector.id);
 }
-/** Agent token list, issue, rotate, and revoke: an interactive maintainer only (#837). */
+/** Agent token list, issue, rotate, and revoke: an interactive maintainer only. */
 export function managesAgentTokens(opts, authz) {
     return (authz.identity.interactive && authz.identity.agent === undefined && isMaintainer(opts.maintainers, authz.identity));
 }
 /**
- * Activity reads: a maintainer principal, interactive or not (#837). Members
+ * Activity reads: a maintainer principal, interactive or not. Members
  * and agents read none, and an open deployment has no maintainer.
  */
 export function readsActivity(opts, authz) {

package/dist/routes/ui-config.js

@@ -359,7 +359,7 @@ function maintainerRead(context, authz) {
             .map(([id, tools]) => [id, Object.fromEntries(Object.entries(tools).filter(([name]) => validName(name)))]));
         // A pool owner is a Workspace mailbox address. Only an authenticated
         // maintainer reads it; an open deployment's anonymous caller, which this
-        // route admits, gets null, the same as an unset owner (#837).
+        // route admits, gets null, the same as an unset owner.
         const ownersVisible = opts.config.auth.length > 0 && isMaintainer(opts.maintainers, authz.identity);
         config.pools = config.pools.map((pool) => ({
             ...pool,
@@ -553,7 +553,7 @@ function memberRead(context, authz, pools) {
     return Effect.gen(function* () {
         const allIds = opts.registry.listConnectors().map((c) => c.id);
         const ids = new Set(allIds.filter((id) => pools.some(([, pool]) => servesConnector(pool, id))));
-        const registry = opts.registry.scoped(scopeFor(authz, opts.config.auth.length > 0, [...ids]));
+        const registry = opts.registry.scoped(scopeFor(authz, opts.config.auth.length > 0, [...ids], pools.length === 1 ? pools[0][0] : undefined));
         const selected = context.url.searchParams.get("connector");
         const visible = registry
             .listConnectors()
@@ -571,7 +571,7 @@ function memberRead(context, authz, pools) {
             root: null,
             pools: pools.map(([name, pool]) => ({
                 name,
-                humanPath: `/mcp/${name}`,
+                humanPath: pools.length === 1 ? "/mcp" : `/mcp/${name}`,
                 agentPath: `/agent/${name}`,
                 readOnly: pool.readOnly,
                 surface: pool.native ? "native" : "meta",

package/dist/routes/ui-data.js

@@ -9,14 +9,19 @@ import { describedTools } from "../described.js";
 import { Effect } from "effect";
 import { bindActivityRequest } from "../activity-request.js";
 import { resolveDiscoveryConcurrency } from "../concurrency.js";
+import { credentialReads } from "../credential-reads.js";
 import { credentialTestRule, describeUndeclaredCredentialFields, storedCredentialShape } from "../credential-rules.js";
+import { readVerification } from "../credential-verification.js";
 import { failureRecord, failureStatus, logFailure, recordedToolName, statusFailure } from "../operator-record.js";
 import { closeScope } from "../runtime/connector-scope.js";
+import { requestReads } from "../runtime/request-scope.js";
 import { withDeadlineEffect } from "../runtime/run.js";
 import { uiProblemFor } from "../ui.js";
 import { CONNECTA_VERSION } from "../version.js";
+import { prepareStatusSlot, readStatusObservation, storeStatusObservation, } from "../connector-status.js";
 const DETAIL_TIMEOUT_MS = 30_000;
 const DETAIL_TIMED_OUT = "Connection details timed out. Retry this connection.";
+const OBSERVE_TIMED_OUT = "Connector did not answer before the operator page's deadline.";
 function attempt(operation) {
     return Effect.tryPromise({ try: operation, catch: (error) => error });
 }
@@ -38,6 +43,35 @@ export function uiData(registry, baseUrl, options) {
             const logger = registry.contextFor(id, baseUrl, requestScope).logger;
             logFailure(logger, "operator status", failureRecord({ connector: id, state }, failure), state === "auth_required" ? "info" : "warn");
         };
+        // A stored row: the observation's state and problem, and no tools. They
+        // stay in the catalog cache (INV-8), and the browser's live read, which
+        // follows in its own request, shows them. Reading them here could connect,
+        // and the row's scope would wait for that listing to end.
+        // The credential's stored verification is local, so it is read fresh here too.
+        const observeStored = (c, stored, drift, requestScope) => drift
+            ? Effect.succeed({ status: { state: "auth_required", message: drift }, tools: [], catalogFailed: false })
+            : Effect.map(verificationFor(c, requestScope), (verification) => ({
+                status: { state: stored.state },
+                tools: [],
+                catalogFailed: stored.problem === "catalog_failed",
+                ...(stored.problem === "connector_timeout" ? { timedOut: true } : {}),
+                verification,
+            }));
+        /**
+         * The stored last verification of an operator-managed credential
+         * (src/credential-verification.ts). Read only, never probed (INV-10). A
+         * record counts only for the save it observed, whose revision the card's
+         * memoized vault read already holds; a vault without revisions has none
+         * to match.
+         */
+        const verificationFor = (c, requestScope) => c.credential && vault
+            ? attempt(async () => {
+                const metadata = await credentialReads(vault, requestReads(requestScope)).metadata(c.id, c.authScope === "personal" ? owner : undefined);
+                return metadata?.revision
+                    ? readVerification(registry.contextFor(c.id, baseUrl, requestScope).storage, metadata.revision)
+                    : undefined;
+            }).pipe(Effect.orElseSucceed(() => undefined))
+            : Effect.succeed(undefined);
         // Status first, then the catalog only when status is ok. A failed status
         // read is an error status, not a failed row: the row still reports the
         // connector's credential.
@@ -54,8 +88,9 @@ export function uiData(registry, baseUrl, options) {
                     signal,
                     ...(options.defer ? { defer: options.defer } : {}),
                 }));
+                const verification = yield* verificationFor(c, requestScope);
                 if (status.state !== "ok" || signal.aborted) {
-                    return { status, tools: [], catalogFailed: false };
+                    return { status, tools: [], catalogFailed: false, verification };
                 }
                 // A catalog is configuration the operator chose to load, and its
                 // descriptions are the agent's too, so the page shows them as text.
@@ -71,10 +106,10 @@ export function uiData(registry, baseUrl, options) {
                     name: recordedToolName(t),
                     address: `${c.id}.${recordedToolName(t)}`,
                     classification: t.classification === "read" ? "read" : "write",
-                }))).pipe(Effect.map((tools) => ({ status, tools, catalogFailed: false })), 
+                }))).pipe(Effect.map((tools) => ({ status, tools, catalogFailed: false, verification })), 
                 // The registry owns the failed catalog observation; the page only
                 // needs to know there was one.
-                Effect.catch(() => Effect.succeed({ status, tools: [], catalogFailed: !signal.aborted })), 
+                Effect.catch(() => Effect.succeed({ status, tools: [], catalogFailed: !signal.aborted, verification })), 
                 // Loading the catalog may replace an earlier clean observation.
                 // Read this view's current bounded facts without another status probe.
                 Effect.map((observed) => ({
@@ -87,9 +122,23 @@ export function uiData(registry, baseUrl, options) {
                 catalogFailed: false,
             })));
         };
+        // The observation under its own deadline. Its abort reaches the status
+        // and catalog reads through `inner`, which then settle as an error or a
+        // failed catalog; either way the reason on `inner` says the deadline
+        // ended them, so the row is a timeout rather than a failure.
+        const observeWithin = (c, drift, signal, requestScope, timeoutMs) => {
+            const timeoutError = new Error(OBSERVE_TIMED_OUT);
+            const timedOut = () => ({
+                status: failureStatus(c.id, timeoutError),
+                tools: [],
+                catalogFailed: false,
+                timedOut: true,
+            });
+            return withDeadlineEffect((inner) => observe(c, drift, inner, requestScope).pipe(Effect.map((observed) => (inner.reason === timeoutError ? timedOut() : observed))), { timeoutMs, signal, timeoutError }).pipe(Effect.catch((error) => (error === timeoutError ? Effect.succeed(timedOut()) : Effect.fail(error))));
+        };
         // The credential card, for someone who may manage this connector's auth.
         // Never fails: a vault that cannot be read is the card's own error.
-        const credentialFor = (c) => {
+        const credentialFor = (c, requestScope) => {
             const mayManageAuth = options.mayManage?.(c.id) ?? (c.authScope === "personal" ? Boolean(owner) : options.oauthManagement);
             const declared = c.credential;
             if (!declared || !vault || !mayManageAuth)
@@ -121,7 +170,9 @@ export function uiData(registry, baseUrl, options) {
                 ...(declared.placeholder ? { placeholder: declared.placeholder } : {}),
             };
             return attempt(async () => {
-                const metadata = await vault.metadata(c.id, c.authScope === "personal" ? owner : undefined);
+                // Memoized per request: the card only displays what the drift and
+                // status reads of this same detail already read.
+                const metadata = await credentialReads(vault, requestReads(requestScope)).metadata(c.id, c.authScope === "personal" ? owner : undefined);
                 const fields = credentialFields(metadata);
                 const shape = storedCredentialShape(declared, metadata?.fields ?? null);
                 return {
@@ -152,18 +203,52 @@ export function uiData(registry, baseUrl, options) {
                 });
             }));
         };
-        const detail = (c, signal, requestScope) => Effect.gen(function* () {
-            const drift = yield* attempt(() => registry.credentialDriftFor(c.id));
+        // Where this row records what it observed. A live read prepares only the
+        // generation; a stored read looks the observation up and, finding none,
+        // records the live read it falls back to.
+        const statusLookup = (c, requestScope) => options.statusObservation === "stored"
+            ? readStatusObservation(registry, c.id, baseUrl, requestScope)
+            : options.statusObservation === "record"
+                ? Effect.map(prepareStatusSlot(registry, c.id, baseUrl, requestScope), (slot) => (slot ? { slot } : {}))
+                : Effect.succeed({});
+        const detail = (c, signal, requestScope, recording) => Effect.gen(function* () {
+            // The status slot is read before the probe starts, so an invalidation
+            // during it leaves the observation under the generation it replaced.
+            const [drift, stored] = yield* Effect.all([attempt(() => registry.credentialDriftFor(c.id, requestScope)), statusLookup(c, requestScope)], { concurrency: 2 });
+            const observation = stored.observation;
+            const statusSlot = observation ? undefined : stored.slot;
+            // The row's own deadline may end it below; it records from here.
+            if (statusSlot)
+                recording.slot = statusSlot;
             // One deadline covers the whole row. The status and catalog reads once
             // had a second one of the same length inside it, which could only fire
             // after this one had already ended the row.
-            const { status, tools, catalogFailed } = yield* observe(c, drift, signal, requestScope);
-            const credential = yield* credentialFor(c);
+            // The operator page's shorter observation deadline, when it has one,
+            // bounds only the downstream: the credential card below is local
+            // storage and still renders, so a slow vendor's slot stays fixable.
+            const { status, tools, catalogFailed, timedOut, verification } = observation
+                ? yield* observeStored(c, observation, drift, requestScope)
+                : options.observeTimeoutMs === undefined
+                    ? yield* observe(c, drift, signal, requestScope)
+                    : yield* observeWithin(c, drift, signal, requestScope, options.observeTimeoutMs);
+            const credential = yield* credentialFor(c, requestScope);
             logStatus(c.id, status.state, statusFailure(status), requestScope);
-            const problem = uiProblemFor(c, status.state, {
-                credentialDrift: Boolean(drift),
-                catalogFailed,
-            });
+            const problem = timedOut
+                ? "connector_timeout"
+                : uiProblemFor(c, status.state, {
+                    credentialDrift: Boolean(drift),
+                    catalogFailed,
+                });
+            const toolCount = observation ? observation.toolCount : tools.length;
+            // Started only while the caller is still here, then awaited to its
+            // end even if the row's deadline or the caller ends it meanwhile.
+            if (statusSlot && !signal.aborted && !options.signal?.aborted)
+                yield* Effect.uninterruptible(storeStatusObservation(statusSlot, {
+                    state: status.state,
+                    ...(problem ? { problem } : {}),
+                    toolCount,
+                    observedAt: Date.now(),
+                }));
             return {
                 id: c.id,
                 authScope: c.authScope ?? "shared",
@@ -171,7 +256,7 @@ export function uiData(registry, baseUrl, options) {
                 ...(c.description !== undefined ? { description: c.description } : {}),
                 status: status.state,
                 ...(problem ? { problem } : {}),
-                toolCount: tools.length,
+                toolCount,
                 tools: tools.map((tool) => ({
                     name: tool.name,
                     address: tool.address,
@@ -186,7 +271,9 @@ export function uiData(registry, baseUrl, options) {
                     ...(status.registrationPath ? { auth: { registrationPath: status.registrationPath } } : {}),
                     catalogAgeMs: registry.catalogAgeMs(c.id),
                     lastCall: null,
+                    ...(observation ? { observedAgeMs: Math.max(0, Date.now() - observation.observedAt) } : {}),
                 },
+                ...(observation ? { observedAgeMs: Math.max(0, Date.now() - observation.observedAt) } : {}),
                 // Counts only, and only when a refresh in this runtime produced them.
                 // `Registry.withCatalogObservations` rebuilt the report through
                 ...(status.catalogAccess ? { catalogAccess: status.catalogAccess } : {}),
@@ -196,43 +283,62 @@ export function uiData(registry, baseUrl, options) {
                     : {}),
                 oauth: Boolean(c.startAuth && c.disconnectAuth),
                 ...(status.registrationPath ? { registrationPath: status.registrationPath } : {}),
+                ...(verification ? { verification } : {}),
                 ...(credential ? { credential } : {}),
             };
         });
-        const unavailable = (c, error, requestScope) => Effect.sync(() => {
+        const unavailable = (c, error, requestScope, timeoutError) => Effect.sync(() => {
             logStatus(c.id, "failed", error, requestScope);
+            // The row's own deadline is a timeout too, whichever ran out first.
+            const problem = error === timeoutError ? "connector_timeout" : "connector_unavailable";
             return {
                 id: c.id,
                 ...(c.title ? { title: c.title } : {}),
                 authScope: c.authScope ?? "shared",
                 status: "error",
-                problem: "connector_unavailable",
+                problem,
                 oauth: Boolean(c.startAuth && c.disconnectAuth),
                 toolCount: 0,
                 tools: [],
                 overlay: {
                     id: c.id,
                     status: "error",
-                    problem: "connector_unavailable",
+                    problem,
                     tools: [],
                     catalogAgeMs: registry.catalogAgeMs(c.id),
                     lastCall: null,
                 },
             };
         });
+        // The row's own deadline ended the read: record that timeout before the
+        // response, so the next stored read parks this row too. A caller who has
+        // already left records nothing. Once started, the write is awaited to its
+        // end, never raced or detached: storage writes cannot be withdrawn once
+        // sent, so the request settles only after it does, bounded by the storage
+        // layer like every other awaited write (INV-7).
+        const recordRowTimeout = (slot) => !slot || options.signal?.aborted
+            ? Effect.void
+            : Effect.uninterruptible(storeStatusObservation(slot, {
+                state: "error",
+                problem: "connector_timeout",
+                toolCount: 0,
+                observedAt: Date.now(),
+            }));
         const row = (c) => Effect.suspend(() => {
             // A row ends independently. Revoking its probe must not revoke a live
             // sibling that happens to belong to the same operator payload.
             const requestScope = {};
             if (options.activityContext)
                 bindActivityRequest(requestScope, options.activityContext);
-            return withDeadlineEffect((signal) => detail(c, signal, requestScope), {
+            const timeoutError = new Error(DETAIL_TIMED_OUT);
+            const recording = {};
+            return withDeadlineEffect((signal) => detail(c, signal, requestScope, recording), {
                 timeoutMs: options.timeoutMs ?? DETAIL_TIMEOUT_MS,
                 ...(options.signal ? { signal: options.signal } : {}),
-                timeoutError: new Error(DETAIL_TIMED_OUT),
+                timeoutError,
             }).pipe(
             // A hook that throws where it should reject fails its own row too.
-            Effect.catchDefect((defect) => Effect.fail(defect)), Effect.catch((error) => unavailable(c, error, requestScope)), Effect.ensuring(Effect.suspend(() => closeScope(c, registry.contextFor(c.id, baseUrl, requestScope), options.defer))));
+            Effect.catchDefect((defect) => Effect.fail(defect)), Effect.catch((error) => Effect.andThen(recordRowTimeout(error === timeoutError ? recording.slot : undefined), unavailable(c, error, requestScope, timeoutError))), Effect.ensuring(Effect.suspend(() => closeScope(c, registry.contextFor(c.id, baseUrl, requestScope), options.defer))));
         });
         return Effect.forEach(registry.listConnectors(), row, {
             concurrency: resolveDiscoveryConcurrency(options.discoveryConcurrency),

package/dist/routes/ui.js

@@ -134,6 +134,16 @@ function operatorView({ opts }, authz, registry) {
             : "requires_operator";
     return { visible, mayManage, permissions, activityEnabled, credentialManagement };
 }
+/**
+ * How long a detail read waits on the downstream before its row reports
+ * `connector_timeout`. A cold remote MCP handshake with an OAuth refresh is
+ * about five sequential round trips, so 8 s allows ~1.5 s each; anything
+ * slower is shown as slow or unreachable rather than holding one of the
+ * page's few detail slots for the full discovery deadline. A deployment that
+ * set a shorter `discovery.probeTimeoutMs` keeps that one deadline, which also
+ * ends in `connector_timeout`.
+ */
+const DETAIL_OBSERVE_TIMEOUT_MS = 8000;
 /** One connector's probed row, the page's second request per card. */
 function connectorDetail(context, id) {
     const { request, baseUrl, opts, defer } = context;
@@ -158,7 +168,13 @@ function connectorDetail(context, id) {
             discoveryConcurrency: 1,
             personalCredentialOwner: authz.principalKey,
             mayManage,
+            // A live read records its observation; `?observation=stored` answers
+            // from the current one instead and leaves the live read to the browser.
+            statusObservation: context.url.searchParams.get("observation") === "stored" ? "stored" : "record",
             timeoutMs: opts.config.discovery.probeTimeoutMs,
+            ...(opts.config.discovery.probeTimeoutMs > DETAIL_OBSERVE_TIMEOUT_MS
+                ? { observeTimeoutMs: DETAIL_OBSERVE_TIMEOUT_MS }
+                : {}),
             signal: request.signal,
         });
         const detail = data.connectors[0];
@@ -182,7 +198,7 @@ function summary(context) {
         const authz = yield* authorized(context);
         const registry = yield* visibleRegistry(context, authz);
         const { visible, mayManage, permissions, activityEnabled, credentialManagement } = operatorView(context, authz, registry);
-        // Only maintainers reach here (#837); setup commands are offered for every
+        // Only maintainers reach here; setup commands are offered for every
         // declared pool, since they administer them all.
         const pools = [...opts.pools.keys()];
         return privateJson({

package/dist/runtime/call-admission.js

@@ -7,7 +7,7 @@
 // block: the one place outside its instance methods that may read its private
 // bookkeeping, and one that emits nothing into the `.d.ts`.
 //
-// The two controllers stay separate on purpose (#453): request admission
+// The two controllers stay separate on purpose: request admission
 // bounds executor work, this bounds calls to one downstream connector, and a
 // shared queue between them was refused.
 import { Effect } from "effect";

package/dist/runtime/call.js

@@ -1,12 +1,13 @@
 // Operation and call services. Only the Promise view bridge is keyed on a
 // context object; authority lives in Context values, shared by derived views.
+import { Routes, routesOf } from "../agent-routes.js";
 import { Context, Effect } from "effect";
 import { ConnectorCallError } from "../errors.js";
 import { dispatchProviderRequest, } from "../provider-call.js";
 import { SentSecrets, sentSecretsForRequest, registerCredentialValues } from "../sent-secrets.js";
 import { recordRecovery } from "../call-recovery.js";
 import { fromSignal, runEdge } from "./run.js";
-import { RequestScope, requestOwner as requestOf } from "./request-scope.js";
+import { RequestScope, requestOwner as requestOf, requestReads } from "./request-scope.js";
 /** Who admitted the operation; absent for a probe or a callback no request admitted. */
 export class Caller extends Context.Service()("connecta/call/Caller") {
 }
@@ -106,7 +107,7 @@ function ended() {
     return new ConnectorCallError("connector_call_failed", "This call has ended; a capability kept from it can no longer be used.", { retryable: false });
 }
 /** Build one call's services. Invocation calls this in the scoped attempt that owns the permit (B.1). */
-export function openCall(inputs) {
+function openCall(inputs) {
     let open = true;
     const parentSignal = inputs.parent ? Context.get(inputs.parent.services, Signal) : undefined;
     const parents = [inputs.signal, parentSignal, inputs.requestSignal].filter((signal) => signal !== undefined);
@@ -197,7 +198,7 @@ export function openCall(inputs) {
                 throw ended();
             (inputs.ledger ?? detachedLedger).dispatch(request, headers, method);
         },
-    }), Context.add(CallMemo, new Map()), Context.add(ProviderLedger, inputs.providerLedger), Context.add(LogicalLedger, inputs.operation ? serviceFor(inputs.operation, LogicalLedger) : undefined));
+    }), Context.add(CallMemo, new Map()), Context.add(ProviderLedger, inputs.providerLedger), Context.add(LogicalLedger, inputs.operation ? serviceFor(inputs.operation, LogicalLedger) : undefined), Context.add(Routes, routesOf(inputs.operation)));
     const lease = {
         get services() {
             return Context.add(Context.add(services, ActiveCall, lease), Operation, inputs.operation);
@@ -338,6 +339,10 @@ export function chargeView(view) {
     const budget = recordedService(view, Budget);
     return budget ? runEdge(budget.charge) : Promise.reject(ended());
 }
+/** The read memo of the request this context belongs to (request-reads.ts). */
+export function viewReads(view) {
+    return requestReads(views.get(view)?.request ?? view.requestScope ?? view);
+}
 /** Admission is sticky until request close; ending a call never makes its copies standalone. */
 export function callScopeKnown(view) {
     const scope = requestOf(views.get(view)?.request ?? view.requestScope ?? view);

package/dist/runtime/native-storage.js

@@ -23,8 +23,17 @@ function current(receiver, key, own, args, native) {
 export function registerNativeStorage(edge, native) {
     const own = { get: edge.get, set: edge.set, delete: edge.delete, list: edge.list, compareAndSet: edge.compareAndSet };
     storageMethods.set(edge, own);
+    const getMany = native.getMany;
     storage.set(edge, {
         get: (key) => current(edge, "get", own.get, [key], () => native.get(key)),
+        // A replaced `get` answers each key itself, in order, as before.
+        ...(getMany
+            ? {
+                getMany: (keys) => typed(() => Reflect.get(edge, "get") === own.get
+                    ? getMany(keys)
+                    : Effect.forEach(keys, (key) => current(edge, "get", own.get, [key], () => native.get(key)))),
+            }
+            : {}),
         set: (key, value, options) => current(edge, "set", own.set, [key, value, options], () => native.set(key, value, options)),
         delete: (key) => current(edge, "delete", own.delete, [key], () => native.delete(key)),
         list: (prefix) => current(edge, "list", own.list, [prefix], () => native.list(prefix)),