@zackbart/connecta 0.24.4 → 0.25.0

package/dist/runtime/run.js

@@ -0,0 +1,174 @@
+// The one place an Effect becomes a Promise.
+//
+// Connecta's published surface is Promise-shaped and stays that way; Effect is
+// an implementation detail behind it. Every edge where a fiber starts runs
+// through this module, so the rules for that crossing live in one file instead
+// of being re-derived at each call site — and test/purity.test.ts fails if any
+// other file under src/ calls Effect.run*, runFork, forkDaemon, or
+// ManagedRuntime.make.
+//
+// Two things the stock runners get wrong for this codebase:
+//
+// - The default MixedScheduler yields through setImmediate, which vitest's
+//   fake timers replace. A fiber that yields under vi.useFakeTimers() then
+//   waits for a timer tick nobody advances. Yielding through a microtask keeps
+//   fibers moving under fakes, and Workers never had setImmediate to begin
+//   with. The cost is that a fiber never yields to I/O, which is why CPU-heavy
+//   work stays out of Effect loops.
+// - Effect.runPromise rejects an interrupted fiber with a generic "All fibers
+//   interrupted without error". Callers of withDeadline today see the abort
+//   reason the caller chose, and runEdge keeps it that way.
+import { Cause, Context, Duration, Effect, Exit, ManagedRuntime, Scheduler, } from "effect";
+/** Yield to the scheduler through the microtask queue, never a timer. */
+function setMicrotask(task) {
+    let cancelled = false;
+    queueMicrotask(() => {
+        if (!cancelled)
+            task();
+    });
+    return () => {
+        cancelled = true;
+    };
+}
+/** The scheduler every edge-run fiber uses; see the header for why. */
+export const microtaskScheduler = new Scheduler.MixedScheduler("async", setMicrotask);
+const runExit = Effect.runPromiseExitWith(Context.make(Scheduler.Scheduler, microtaskScheduler));
+function abortReason(signal) {
+    return signal?.reason ?? new DOMException("aborted", "AbortError");
+}
+/**
+ * Turn a failed Exit back into the value a Promise caller would have seen.
+ *
+ * An interrupt caused by the caller's signal wins, as the abort does in
+ * withDeadline's race. Otherwise the first typed failure is rethrown as is,
+ * then the first defect — never a wrapper, because callers check `instanceof`,
+ * `name`, and `message` on connecta's own error classes.
+ */
+function rethrow(cause, signal) {
+    const reasons = cause.reasons;
+    if (signal?.aborted && reasons.some(Cause.isInterruptReason)) {
+        throw abortReason(signal);
+    }
+    const failure = reasons.find(Cause.isFailReason);
+    if (failure)
+        throw failure.error;
+    const defect = reasons.find(Cause.isDieReason);
+    if (defect)
+        throw defect.defect;
+    throw abortReason(signal);
+}
+const disposedRuntimes = new WeakSet();
+/** Wrap a layer as an EdgeRuntime without building it. */
+export function makeEdgeRuntime(layer) {
+    return ManagedRuntime.make(layer);
+}
+/**
+ * Release a runtime's layer resources. Idempotent, and never rejects: a
+ * finalizer that fails has nobody left to report to.
+ */
+export async function disposeEdgeRuntime(runtime) {
+    if (disposedRuntimes.has(runtime))
+        return;
+    disposedRuntimes.add(runtime);
+    // Through runExit rather than runtime.dispose(), whose runner yields on
+    // Effect's default scheduler — the one vitest's fake timers freeze.
+    await runExit(runtime.disposeEffect);
+}
+/**
+ * The effect with the runtime's services provided, building them first when
+ * no run has yet. The build runs on the calling fiber's scheduler, so it is
+ * the microtask scheduler here, as everything else is.
+ */
+function provideRuntime(effect, runtime) {
+    if (disposedRuntimes.has(runtime)) {
+        return Effect.die(new Error("This Connecta has been closed."));
+    }
+    const built = runtime.cachedContext;
+    if (built)
+        return Effect.provideContext(effect, built);
+    return Effect.flatMap(runtime.contextEffect, (context) => Effect.provideContext(effect, context));
+}
+export async function runEdge(effect, options = {}) {
+    const exit = await runExit(options.runtime
+        ? provideRuntime(effect, options.runtime)
+        // Without a runtime the overloads admit only an effect that requires
+        // nothing, so there is nothing to provide.
+        : effect, options.signal ? { signal: options.signal } : undefined);
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    return rethrow(exit.cause, options.signal);
+}
+/**
+ * Fail with the signal's abort reason once it aborts; never succeed.
+ *
+ * Race it against work that should stop when the signal does. A signal
+ * aborted without a reason fails with an AbortError, as `fetch` would.
+ */
+export function fromSignal(signal) {
+    return Effect.callback((resume) => {
+        // Remove the listener on every path, firing included. `once` already
+        // drops it from a real AbortSignal, but the cleanup below runs only on
+        // interruption, and a signal-shaped wrapper sees no removal otherwise.
+        const onAbort = () => {
+            signal.removeEventListener("abort", onAbort);
+            resume(Effect.fail(abortReason(signal)));
+        };
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+        return Effect.sync(() => signal.removeEventListener("abort", onAbort));
+    });
+}
+/**
+ * The Effect form of withDeadline (src/timeout.ts), with the same contract.
+ *
+ * The operation gets a signal of its own. The caller's signal is forwarded to
+ * it, and the deadline aborts it with the labelled `timeoutError` *before* the
+ * operation's fiber is interrupted, so work that honors the signal sees the
+ * same reason the caller does. Either abort fails the effect with that reason:
+ * the caller's, or `timeoutError`. The signal is always aborted on exit, as
+ * withDeadline's `finally` does.
+ *
+ * The error channel is `unknown` because an abort reason is whatever the
+ * caller chose.
+ */
+export function withDeadlineEffect(operation, options) {
+    return Effect.suspend(() => {
+        const controller = new AbortController();
+        const forwardAbort = () => controller.abort(options.signal?.reason);
+        options.signal?.addEventListener("abort", forwardAbort, { once: true });
+        if (options.signal?.aborted)
+            forwardAbort();
+        // One race, not a race nested in a race: every contender is a forked
+        // fiber, and forks are most of what a deadline costs (P1-S02 measured
+        // about 2µs per raceFirst). Fork order is unchanged — operation, abort,
+        // timer — and the timer still aborts the signal before anything is
+        // interrupted, so the abort contender wins with the labelled reason.
+        const contenders = [
+            Effect.suspend(() => operation(controller.signal)),
+            fromSignal(controller.signal),
+        ];
+        if (options.timeoutMs !== undefined) {
+            contenders.push(Effect.sleep(Duration.millis(options.timeoutMs)).pipe(Effect.andThen(Effect.sync(() => controller.abort(options.timeoutError))), Effect.andThen(Effect.never)));
+        }
+        return Effect.raceAllFirst(contenders).pipe(Effect.ensuring(Effect.sync(() => {
+            controller.abort();
+            options.signal?.removeEventListener("abort", forwardAbort);
+        })));
+    });
+}
+/**
+ * The only sanctioned fire-and-forget.
+ *
+ * On Workers the work is handed to `ctx.waitUntil`, so the platform keeps the
+ * invocation alive until it settles rather than freezing it mid-flight. The
+ * returned promise never rejects: the outcome is the effect's own business,
+ * and an unhandled rejection from background work helps nobody.
+ */
+export function detach(effect, ctx) {
+    const settled = runExit(effect).then(() => { }, () => { });
+    ctx?.waitUntil?.(settled);
+    return settled;
+}

package/dist/runtime/services.js

@@ -0,0 +1,130 @@
+// The core's services, as Effect code sees them.
+//
+// createConnecta resolves storage, the vault, activity history, logging, and
+// the rest of its configuration once, at construction. This module gives each
+// of those a service key and assembles them into the layer behind that
+// Connecta's runtime (an EdgeRuntime, src/runtime/run.ts), so an Effect
+// program reads them from its context rather than from arguments threaded
+// through every call. The shells — Registry, CatalogService, and the rest —
+// stay constructible from plain arguments, as the tests construct them. The
+// registry's storage programs read Storage and Logger too, but from their own
+// partition rather than this runtime (see src/runtime/storage.ts for why).
+//
+// Every import from an optional module is type-only. An omitted activity
+// module is a no-op recorder that builds no event and calls nothing, and the
+// UI, vault, and activity implementations stay out of the root import graph
+// (test/purity.test.ts).
+import { Context, Effect, Layer } from "effect";
+import { makeEdgeRuntime } from "./run.js";
+/**
+ * The deployment's KVStorage: `config.storage`, or the memoryStorage() that
+ * stands in for it. `compareAndSet` is present exactly when the adapter
+ * implements it, so a caller that needs atomicity checks for it here.
+ */
+export class Storage extends Context.Service()("connecta/Storage") {
+}
+/**
+ * The credential vault, or undefined when the deployment configures none —
+ * a required service whose value may be absent, not a default, so a program
+ * run without it provided fails to typecheck instead of finding no vault.
+ */
+export class Vault extends Context.Service()("connecta/Vault") {
+}
+/**
+ * Connecta's diagnostic logger, already resolved: the configured Logger, a
+ * no-op for `"silent"`, or console output prefixed `[connecta]`. Effect's
+ * own logger is never used (test/purity.test.ts), because it honors neither
+ * `"silent"` nor the line format a deployment greps for.
+ */
+export class Logger extends Context.Service()("connecta/Logger") {
+}
+/** Payload-free activity history, or a recorder that records nothing. */
+export class ActivityRecorder extends Context.Service()("connecta/ActivityRecorder") {
+}
+/** What createConnecta resolved at construction. */
+export class ResolvedConfig extends Context.Service()("connecta/ResolvedConfig") {
+}
+/**
+ * The request's hook for work that may outlive its response (a Worker's
+ * `ctx.waitUntil`). Per request, not per Connecta, so it is never part of the
+ * runtime: a request provides it with `Effect.provideService`, and a program
+ * outside any request sees undefined and keeps its work in the foreground.
+ */
+export const DeferredWork = Context.Reference("connecta/DeferredWork", { defaultValue: () => undefined });
+/**
+ * Resolve `ConnectaConfig.logger`. `"silent"` discards every line; an omitted
+ * logger writes to the console with the `[connecta]` prefix.
+ */
+export function resolveLogger(logger) {
+    if (logger === "silent") {
+        return { debug() { }, info() { }, warn() { }, error() { } };
+    }
+    return logger ?? {
+        debug: (...a) => console.debug("[connecta]", ...a),
+        info: (...a) => console.info("[connecta]", ...a),
+        warn: (...a) => console.warn("[connecta]", ...a),
+        error: (...a) => console.error("[connecta]", ...a),
+    };
+}
+const NO_ACTIVITY = {
+    enabled: false,
+    recordTool: () => Effect.void,
+    recordDrift: () => Effect.void,
+};
+function activityRecorder(module, serverInfo, logger) {
+    const deployment = module.deploymentId !== undefined
+        ? { deploymentId: module.deploymentId }
+        : {};
+    // A custom module's recorder that throws is logged like a store that
+    // throws: activity never changes the outcome of the work it describes.
+    const bestEffort = (record) => Effect.sync(() => {
+        try {
+            record();
+        }
+        catch (error) {
+            logger.warn("[connecta] activity record failed", error);
+        }
+    });
+    return {
+        enabled: true,
+        recordTool: (request, input) => DeferredWork.use((defer) => bestEffort(() => module.recordTool({
+            sink: module.store,
+            recordTool: module.recordTool,
+            actor: request.actor,
+            requestId: request.requestId,
+            serverInfo,
+            ...deployment,
+            ...(defer ? { defer } : {}),
+            logger,
+        }, input))),
+        recordDrift: (input) => bestEffort(() => module.recordDrift({ sink: module.store, serverInfo, ...deployment, logger }, input)),
+    };
+}
+/**
+ * The layer behind a Connecta's runtime. Every service is a value resolved
+ * before this is called, so building the layer only assembles a context: it
+ * starts no fiber and touches no storage.
+ */
+function coreServices(options) {
+    const activity = options.activity
+        ? activityRecorder(options.activity, options.config.serverInfo, options.logger)
+        : NO_ACTIVITY;
+    return Layer.succeedContext(Context.make(Storage, options.storage).pipe(Context.add(Vault, options.vault), Context.add(Logger, options.logger), Context.add(ActivityRecorder, activity), Context.add(ResolvedConfig, options.config)));
+}
+// Keyed by the root Registry: it is the per-Connecta object every internal
+// caller already holds, and a Registry built directly (as the tests build
+// them) simply has no runtime.
+const runtimes = new WeakMap();
+/**
+ * Create the runtime for the Connecta that owns `registry`. Runs nothing:
+ * the layer is built by the first run that needs it (see EdgeRuntime).
+ */
+export function createCoreRuntime(registry, options) {
+    const runtime = makeEdgeRuntime(coreServices(options));
+    runtimes.set(registry, runtime);
+    return runtime;
+}
+/** The runtime createConnecta made for this root registry, if it made one. */
+export function coreRuntime(registry) {
+    return runtimes.get(registry);
+}

package/dist/runtime/storage.js

@@ -0,0 +1,66 @@
+// The Storage service, as the registry's programs use it.
+//
+// KVStorage stays Promise-shaped: it is what a deployment author implements,
+// and nobody should need Effect to write a storage adapter. The operations
+// below lift one call each into an effect that reads the adapter from the
+// Storage service and fails with whatever the adapter threw, unwrapped, so a
+// warning built from it reads exactly as it did.
+//
+// Which Storage a program sees is the registry's decision, not the runtime's.
+// The Connecta runtime (src/runtime/services.ts) is keyed by the root
+// Registry, and that is the wrong key here: a personal registry's storage is
+// the root's namespaced to `principal:<key>:`, so handing its programs the
+// runtime's Storage would read and write another partition. Each Registry —
+// root, personal, or one a test built from plain arguments — therefore
+// provides its own storage and logger to the programs it runs
+// (`runOnPartition`). For the root registry those are the very values the
+// runtime holds, because createConnecta passes the same two objects to both.
+// A scoped view holds no storage of its own: it reaches Storage through the
+// registry it delegates to, and the result stash is always the root's,
+// because its capacity is runtime-wide.
+import { Context, Effect } from "effect";
+import { runEdge } from "./run.js";
+import { Logger, Storage } from "./services.js";
+/** Read one key; null when absent. */
+export function storageGet(key) {
+    return Storage.use((storage) => Effect.tryPromise({
+        // Promise.resolve keeps an adapter that answers synchronously working,
+        // as `await` did; a synchronous throw is caught either way.
+        try: () => Promise.resolve(storage.get(key)),
+        catch: (error) => error,
+    }));
+}
+/** Write one key, with the adapter's optional TTL. */
+export function storageSet(key, value, options) {
+    return Storage.use((storage) => Effect.tryPromise({
+        try: () => Promise.resolve(storage.set(key, value, options)),
+        catch: (error) => error,
+    }));
+}
+/** Delete one key. */
+export function storageDelete(key) {
+    return Storage.use((storage) => Effect.tryPromise({
+        try: () => Promise.resolve(storage.delete(key)),
+        catch: (error) => error,
+    }));
+}
+// One context per partition object, built on first use. A registry's options
+// object lives exactly as long as the registry, so the WeakMap never holds a
+// partition past its owner.
+const partitions = new WeakMap();
+function partitionContext(partition) {
+    let context = partitions.get(partition);
+    if (!context) {
+        context = Context.make(Storage, partition.storage).pipe(Context.add(Logger, partition.logger));
+        partitions.set(partition, context);
+    }
+    return context;
+}
+/**
+ * Run a registry program against the registry's own storage and logger, at a
+ * Promise boundary. Resolves and rejects as runEdge does: the original error,
+ * never a wrapper.
+ */
+export function runOnPartition(effect, partition) {
+    return runEdge(Effect.provideContext(effect, partitionContext(partition)));
+}

package/dist/server.js

@@ -1,18 +1,119 @@
+import { Effect } from "effect";
 import { aggregateCallAdmissionSnapshots } from "./call-admission.js";
 import { isAdmittingExecutor } from "./executor-admission.js";
 import { createMcpRoute, MCP_CORS_HEADERS } from "./routes/mcp.js";
 import { routeOAuthCallback, } from "./routes/oauth.js";
+import { runEdge } from "./runtime/run.js";
 import { withSecurityHeaders, } from "./routes/shared.js";
 /**
  * Build the Web-standard fetch handler.
  *
  * Route ordering is the contract: private mutation routes precede wildcard
  * OPTIONS, and the security wrapper is applied to every response, including 404s.
+ *
+ * Each request is one fiber tied to `request.signal`: when its caller leaves,
+ * the request stops waiting on whatever it was waiting on, and what it holds
+ * is released (routes/mcp.ts). It runs on no Connecta runtime, because
+ * `/health` and a closed deployment's 503 must keep answering after
+ * `close()` has disposed that runtime.
  */
 export function createFetchHandler(opts) {
     const { auth, publicUrl, registry } = opts;
     const routeMcp = createMcpRoute(opts);
-    return async function fetch(request, runtimeContext) {
+    // The first provider's metadata answer for this request, if any has one.
+    const metadata = (request, baseUrl) => Effect.gen(function* () {
+        for (const provider of auth) {
+            const handleMetadata = provider.handleMetadata?.bind(provider);
+            if (handleMetadata) {
+                const response = yield* Effect.promise(async () => handleMetadata(request, baseUrl));
+                if (response)
+                    return response;
+            }
+        }
+        return null;
+    });
+    const health = async () => {
+        // The executor is required, so code admission always has a shape to
+        // report: either the executor's own pool or the fallback controller
+        // wrapped around it at construction.
+        const codeAdmission = isAdmittingExecutor(opts.executor)
+            ? opts.executor.admissionSnapshot?.()
+            : undefined;
+        return Response.json({
+            status: "ok",
+            connectors: registry.listConnectors().length,
+            server: opts.serverInfo,
+            // Which sandbox, not how it is tuned: `connecta doctor` reports the
+            // executor it just exercised rather than assuming one, and a
+            // deployment whose executor identifies as nothing omits the key
+            // instead of inviting a guess (#368).
+            ...(opts.executorName !== undefined
+                ? { executor: { name: opts.executorName } }
+                : {}),
+            // Counts only, from refreshes that already happened — the endpoint
+            // asks no downstream anything, and `connecta doctor` reads it to
+            // report a stale allowlist without a probe of its own (#343).
+            // Stable 64-bit hashes preserve that shape without publishing ids.
+            catalogDrift: Object.fromEntries(await Promise.all(Object.entries(registry.catalogDriftSnapshot()).map(async ([id, report]) => {
+                const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(id)));
+                const key = Array.from(hash.subarray(0, 8), byte => byte.toString(16).padStart(2, "0")).join("");
+                return [key, report];
+            }))),
+            admission: {
+                policy: "global-fifo",
+                requests: opts.requestAdmission.snapshot(),
+                code: codeAdmission ?? { managedByExecutor: true },
+                downstreamCalls: {
+                    policy: "connector-partitioned-per-runtime",
+                    aggregate: aggregateCallAdmissionSnapshots(Object.values(registry.callAdmissionSnapshot())),
+                },
+                reservedRoutes: [
+                    "/health",
+                    ...(opts.ui?.reservedPaths ?? []),
+                    ...(opts.ui && opts.activity?.list ? ["/activity"] : []),
+                ],
+            },
+            ...(opts.deploymentInfo ? { deployment: opts.deploymentInfo } : {}),
+        });
+    };
+    const route = (context) => Effect.gen(function* () {
+        const { request, path, baseUrl } = context;
+        // Private mutations own OPTIONS so they never inherit wildcard CORS.
+        const ui = opts.ui;
+        if (ui) {
+            const uiResponse = yield* Effect.promise(() => ui.handle(context));
+            if (uiResponse)
+                return uiResponse;
+        }
+        if (request.method === "OPTIONS") {
+            const preflight = yield* routeMcp.handle(context);
+            if (preflight)
+                return preflight;
+            const response = yield* metadata(request, baseUrl);
+            if (response)
+                return response;
+            return new Response(null, {
+                status: 204,
+                headers: MCP_CORS_HEADERS,
+            });
+        }
+        if (path.startsWith("/.well-known/")) {
+            const response = yield* metadata(request, baseUrl);
+            if (response)
+                return response;
+            return new Response("Not Found", { status: 404 });
+        }
+        if (path === "/health")
+            return yield* Effect.promise(health);
+        const oauthCallback = yield* routeOAuthCallback(context);
+        if (oauthCallback)
+            return oauthCallback;
+        const mcp = yield* routeMcp.handle(context);
+        if (mcp)
+            return mcp;
+        return new Response("Not Found", { status: 404 });
+    });
+    const serve = (request, runtimeContext) => Effect.suspend(() => {
         const url = new URL(request.url);
         const baseUrl = publicUrl ?? url.origin;
         const path = url.pathname;
@@ -20,8 +121,9 @@ export function createFetchHandler(opts) {
             ? runtimeContext.waitUntil.bind(runtimeContext)
             : undefined;
         const originRefusal = routeMcp.rejectOrigin(request);
-        if (originRefusal)
-            return withSecurityHeaders(originRefusal, url, path);
+        if (originRefusal) {
+            return Effect.succeed(withSecurityHeaders(originRefusal, url, path));
+        }
         // Container and orchestrator probes reach /health over plain HTTP on
         // loopback, where no proxy has set X-Forwarded-Proto. Redirecting them to
         // the public origin would make an internal liveness check depend on
@@ -43,10 +145,10 @@ export function createFetchHandler(opts) {
             target.pathname = path === "/ui" ? "/" : url.pathname;
             target.search = url.search;
             target.hash = "";
-            return withSecurityHeaders(new Response(null, {
+            return Effect.succeed(withSecurityHeaders(new Response(null, {
                 status: 308,
                 headers: { Location: target.toString() },
-            }), url, path);
+            }), url, path));
         }
         const context = {
             request,
@@ -57,89 +159,9 @@ export function createFetchHandler(opts) {
             defer,
             runtimeContext,
         };
-        const route = async () => {
-            // Private mutations own OPTIONS so they never inherit wildcard CORS.
-            const uiResponse = await opts.ui?.handle(context);
-            if (uiResponse)
-                return uiResponse;
-            if (request.method === "OPTIONS") {
-                const preflight = await routeMcp.handle(context);
-                if (preflight)
-                    return preflight;
-                for (const provider of auth) {
-                    if (provider.handleMetadata) {
-                        const response = await provider.handleMetadata(request, baseUrl);
-                        if (response)
-                            return response;
-                    }
-                }
-                return new Response(null, {
-                    status: 204,
-                    headers: MCP_CORS_HEADERS,
-                });
-            }
-            if (path.startsWith("/.well-known/")) {
-                for (const provider of auth) {
-                    if (provider.handleMetadata) {
-                        const response = await provider.handleMetadata(request, baseUrl);
-                        if (response)
-                            return response;
-                    }
-                }
-                return new Response("Not Found", { status: 404 });
-            }
-            if (path === "/health") {
-                // The executor is required, so code admission always has a shape to
-                // report: either the executor's own pool or the fallback controller
-                // wrapped around it at construction.
-                const codeAdmission = isAdmittingExecutor(opts.executor)
-                    ? opts.executor.admissionSnapshot?.()
-                    : undefined;
-                return Response.json({
-                    status: "ok",
-                    connectors: registry.listConnectors().length,
-                    server: opts.serverInfo,
-                    // Which sandbox, not how it is tuned: `connecta doctor` reports the
-                    // executor it just exercised rather than assuming one, and a
-                    // deployment whose executor identifies as nothing omits the key
-                    // instead of inviting a guess (#368).
-                    ...(opts.executorName !== undefined
-                        ? { executor: { name: opts.executorName } }
-                        : {}),
-                    // Counts only, from refreshes that already happened — the endpoint
-                    // asks no downstream anything, and `connecta doctor` reads it to
-                    // report a stale allowlist without a probe of its own (#343).
-                    // Stable 64-bit hashes preserve that shape without publishing ids.
-                    catalogDrift: Object.fromEntries(await Promise.all(Object.entries(registry.catalogDriftSnapshot()).map(async ([id, report]) => {
-                        const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(id)));
-                        const key = Array.from(hash.subarray(0, 8), byte => byte.toString(16).padStart(2, "0")).join("");
-                        return [key, report];
-                    }))),
-                    admission: {
-                        policy: "global-fifo",
-                        requests: opts.requestAdmission.snapshot(),
-                        code: codeAdmission ?? { managedByExecutor: true },
-                        downstreamCalls: {
-                            policy: "connector-partitioned-per-runtime",
-                            aggregate: aggregateCallAdmissionSnapshots(Object.values(registry.callAdmissionSnapshot())),
-                        },
-                        reservedRoutes: [
-                            "/health",
-                            ...(opts.ui?.reservedPaths ?? []),
-                            ...(opts.ui && opts.activity?.list ? ["/activity"] : []),
-                        ],
-                    },
-                    ...(opts.deploymentInfo ? { deployment: opts.deploymentInfo } : {}),
-                });
-            }
-            const oauthCallback = await routeOAuthCallback(context);
-            if (oauthCallback)
-                return oauthCallback;
-            const mcp = await routeMcp.handle(context);
-            if (mcp)
-                return mcp;
-            return new Response("Not Found", { status: 404 });
-        };
-        return withSecurityHeaders(await route(), url, path);
+        return Effect.map(route(context), (response) => withSecurityHeaders(response, url, path));
+    });
+    return function fetch(request, runtimeContext) {
+        return runEdge(serve(request, runtimeContext), { signal: request.signal });
     };
 }

package/dist/skills.js

@@ -47,7 +47,7 @@ Caught Connecta errors expose \`message\`, \`code\`, \`retryable\`, and \`detail
 
 For a direct call, \`resultMode: "value"\` unwraps the result. \`timeoutMs\` sets its deadline. Every call makes one attempt; use the returned error classification and retry hint to decide whether to reissue. \`diagnostics: true\` adds timing.
 
-\`get_result({ id, offset?, maxBytes? })\` returns \`{ text, offset, nextOffset?, totalBytes }\` for a direct-call result. Both sizes are byte counts: \`maxBytes\` must be a whole number at least 1 and defaults to the deployment cap; \`offset\` must be a whole number at least 0 and defaults to 0. An offset inside a multi-byte character moves back to its first byte, and the response reports the served offset. Follow \`nextOffset\` to reassemble pages. An unknown or expired id is an error.
+\`get_result({ id, offset?, maxBytes? })\` returns a one-line JSON header \`{ resultId, offset, bytes, totalBytes, hasMore, nextAction? }\`, a newline, and then the page as raw text, for a direct-call result. Both sizes are byte counts: \`maxBytes\` must be a whole number at least 1, defaults to the result's cap, and is clamped to it; \`offset\` must be a whole number at least 0 and defaults to 0. An offset inside a multi-byte character moves back to its first byte, and the header reports the served offset. Follow \`nextAction\` until \`hasMore\` is false to reassemble pages. An unknown or expired id is an error.
 
 Limits: 20 host calls per run and a 15-second deadline per host call.
 

package/dist/storage/file.js

@@ -259,8 +259,9 @@ export function fileStorage(path, opts = {}) {
             throw new Error(`[connecta] state file ${path} is closed.`);
     };
     const logger = opts.logger ?? console;
-    // The state file holds downstream OAuth access/refresh tokens in cleartext,
-    // so keep it owner-only. Repair is best-effort: chmod is a no-op or throws on
+    // With a sealing vault, downstream OAuth tokens here are ciphertext; without
+    // one they are cleartext, and OAuth flow state is plaintext either way. Keep
+    // the file owner-only regardless. Repair is best-effort: chmod is a no-op or throws on
     // non-POSIX filesystems, and a loose mode must never keep the store from
     // starting.
     const tighten = () => {
@@ -377,5 +378,41 @@ export function fileStorage(path, opts = {}) {
                 .filter((key) => Boolean(fresh(key)) && key.startsWith(prefix))
                 .sort();
         },
+        // Atomic twice over: the lock makes this process the only writer of the
+        // file, and nothing between the comparison and the persisted rename
+        // yields, so no other call on this store can interleave. A write that
+        // cannot be persisted is rolled back so memory never claims a value the
+        // file does not hold.
+        async compareAndSet(key, expected, next, opts) {
+            assertOpen();
+            lock.assertHeld();
+            const previous = fresh(key);
+            if ((previous?.value ?? null) !== expected)
+                return false;
+            if (next === null) {
+                if (!previous)
+                    return true;
+                delete data[key];
+            }
+            else {
+                data[key] = {
+                    value: next,
+                    ...(opts?.ttlSeconds
+                        ? { exp: Date.now() + opts.ttlSeconds * 1000 }
+                        : {}),
+                };
+            }
+            try {
+                persist();
+            }
+            catch (error) {
+                if (previous)
+                    data[key] = previous;
+                else
+                    delete data[key];
+                throw error;
+            }
+            return true;
+        },
     };
 }