@fungi.computer/oyster 0.5.0 → 0.6.0

package/dist/release.d.ts

@@ -60,6 +60,19 @@ export type VerifiedRelease = Readonly<{
 export declare function sha256(bytes: Uint8Array): Promise<string>;
 /** Read one artifact and refuse it unless its bytes match `digest`. */
 export declare function readVerified(store: ArtifactStore, artifactRef: ArtifactRef, digest: Sha256Digest): Promise<Uint8Array>;
+/**
+ * Copies of verified artifacts near the reader, keyed by content digest. An
+ * entry holds only bytes that already matched its digest, so a hit is served
+ * without another store read or hash.
+ */
+export type VerifiedObjectCache = Readonly<{
+    /** The cached bytes for `digest`, or null on a miss. */
+    match: (digest: Sha256Digest) => Promise<ReadableStream<Uint8Array> | null>;
+    /** Keep verified bytes; an unstored write only costs the next reader a store read. */
+    put: (digest: Sha256Digest, bytes: Uint8Array) => Promise<"stored" | "unstored">;
+}>;
+/** {@link readVerified} through an optional digest-keyed cache it fills on a miss. */
+export declare function readCachedVerified(store: ArtifactStore, cache: VerifiedObjectCache | undefined, artifactRef: ArtifactRef, digest: Sha256Digest): Promise<ReadableStream<Uint8Array> | Uint8Array<ArrayBuffer>>;
 /** Decode an untrusted Release record, as an install request carries it. */
 export declare function parseRelease(value: unknown): Release;
 /**

package/dist/release.js

@@ -36,6 +36,16 @@ export async function readVerified(store, artifactRef, digest) {
         throw new ReleaseError("digest_mismatch", `Digest mismatch ${artifactRef}`);
     return bytes;
 }
+/** {@link readVerified} through an optional digest-keyed cache it fills on a miss. */
+export async function readCachedVerified(store, cache, artifactRef, digest) {
+    const hit = await cache?.match(digest);
+    if (hit !== undefined && hit !== null)
+        return hit;
+    const bytes = await readVerified(store, artifactRef, digest);
+    await cache?.put(digest, bytes);
+    // A response body owns a plain ArrayBuffer, whatever view the store returned.
+    return new Uint8Array(bytes);
+}
 const decodeText = (bytes) => new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes);
 /** Decode an untrusted Release record, as an install request carries it. */
 export function parseRelease(value) {

package/dist/request-origin.d.ts

@@ -0,0 +1,4 @@
+/** Require the request's own Origin and refuse cross-site provenance. */
+export declare function sameOriginRequest(request: Request): boolean;
+/** Channel reads allow absent Origin but never conflicting or cross-site provenance. */
+export declare function sameOriginReadRequest(request: Request): boolean;

package/dist/request-origin.js

@@ -0,0 +1,10 @@
+/** Require the request's own Origin and refuse cross-site provenance. */
+export function sameOriginRequest(request) {
+    return request.headers.has("origin") && sameOriginReadRequest(request);
+}
+/** Channel reads allow absent Origin but never conflicting or cross-site provenance. */
+export function sameOriginReadRequest(request) {
+    const origin = request.headers.get("origin");
+    return (request.headers.get("sec-fetch-site") !== "cross-site" &&
+        (origin === null || origin === new URL(request.url).origin));
+}

package/dist/standalone/agents.js

@@ -1,5 +1,4 @@
-import { normalizeModel, streamModel } from "@fungi.computer/mule/effect";
-import { observeProviderStatus } from "@fungi.computer/mule/effect";
+import { isRetryableProviderRejection, normalizeModel, observeProviderStatus, streamModel, } from "@fungi.computer/mule/effect";
 import { standaloneTenancy, } from "./tenancy.js";
 import { AcceptedSchema } from "@fungi.computer/shiitake/client";
 import { createShiitakeClient } from "@fungi.computer/shiitake/client";
@@ -53,10 +52,10 @@ function observedModels(model, defaults) {
         acquire: ({ signal }) => {
             const retryableMessages = new WeakSet();
             const safeFailures = new WeakMap();
-            const failure = (message, code) => {
+            const failure = (message, rejection) => {
                 // Pi can include raw response bodies in errorMessage. No provider
                 // prose enters a Session, retry journal, model context or diagnostics.
-                const safe = `Model request failed (${code}). Retry the request.`;
+                const safe = `Model request failed (${rejection?.code ?? "provider_rejected"}). Retry the request.`;
                 const terminal = {
                     role: "assistant",
                     content: [],
@@ -69,7 +68,7 @@ function observedModels(model, defaults) {
                     timestamp: message.timestamp,
                 };
                 safeFailures.set(terminal, safe);
-                if (code === "provider_unavailable")
+                if (isRetryableProviderRejection(rejection))
                     retryableMessages.add(terminal);
                 return terminal;
             };
@@ -92,7 +91,7 @@ function observedModels(model, defaults) {
                             });
                             for await (const event of response) {
                                 if (event.type === "error") {
-                                    const terminal = failure(event.error, observed.rejection()?.code ?? "provider_rejected");
+                                    const terminal = failure(event.error, observed.rejection(event.error));
                                     events.push({ ...event, error: terminal });
                                     events.end(terminal);
                                     return;
@@ -100,7 +99,7 @@ function observedModels(model, defaults) {
                                 if (event.type === "done" &&
                                     (event.message.stopReason === "error" ||
                                         event.message.stopReason === "aborted")) {
-                                    const terminal = failure(event.message, observed.rejection()?.code ?? "provider_rejected");
+                                    const terminal = failure(event.message, observed.rejection(event.message));
                                     events.push({ ...event, message: terminal });
                                     events.end(terminal);
                                     return;
@@ -109,7 +108,7 @@ function observedModels(model, defaults) {
                             }
                             const result = await response.result();
                             events.end(result.stopReason === "error" || result.stopReason === "aborted"
-                                ? failure(result, observed.rejection()?.code ?? "provider_rejected")
+                                ? failure(result, observed.rejection(result))
                                 : result);
                         }
                         catch {
@@ -136,7 +135,7 @@ function observedModels(model, defaults) {
                                 },
                                 stopReason: signal.aborted ? "aborted" : "error",
                                 timestamp: Date.now(),
-                            }, "provider_unavailable");
+                            }, { code: "provider_unavailable" });
                             events.push({
                                 type: "error",
                                 reason: signal.aborted ? "aborted" : "error",
@@ -236,15 +235,16 @@ export class StandaloneAgentBase extends ShiitakeDO {
      * this does not install an inbound route or mint provider credentials.
      */
     channelConversations(binding) {
-        return createChannelConversations({
+        const owner = createChannelConversations({
             sql: this.ctx.storage.sql,
             transactionSync: (body) => this.ctx.storage.transactionSync(body),
             binding,
             door: channelSessionDoor(() => this.shiitake(), () => {
                 // Standalone Agents have no Hub Team grants to deliver.
-            }),
+            }, () => owner),
             now: () => Date.now(),
         });
+        return owner;
     }
     /** Each installed Release's verified catalog surface, built once per Release for this Agent's lifetime. */
     #appSurfaces;

package/dist/standalone/channel-session-door.d.ts

@@ -1,4 +1,4 @@
 import type { ShiitakeOwnerAgent } from "@fungi.computer/shiitake/cloudflare";
-import type { SessionDoor } from "../channels/conversations.js";
+import type { ChannelConversations, SessionDoor } from "../channels/conversations.js";
 /** Translate a standalone Agent's Shiitake owner into Oyster's channel Session port. */
-export declare function channelSessionDoor(open: () => Promise<ShiitakeOwnerAgent>, deliverGrants: (sessionId: string) => void): SessionDoor;
+export declare function channelSessionDoor(open: () => Promise<ShiitakeOwnerAgent>, deliverGrants: (sessionId: string) => void, conversations: () => ChannelConversations): SessionDoor;

package/dist/standalone/channel-session-door.js

@@ -1,15 +1,45 @@
 import { authorMeta } from "@fungi.computer/agar/agents";
 import { ShiitakeError } from "@fungi.computer/shiitake";
+import { participantSnapshot, visitorPendingPrompt, visitorSnapshot, } from "@fungi.computer/shiitake/client";
+import { visitorStream } from "@fungi.computer/shiitake/server-visitor-stream";
 /** Translate a standalone Agent's Shiitake owner into Oyster's channel Session port. */
-export function channelSessionDoor(open, deliverGrants) {
+export function channelSessionDoor(open, deliverGrants, conversations) {
+    const policy = () => conversations();
     return {
         createSession: async (requestId) => (await open()).createSession(requestId),
         deliverGrants,
         withdraw: async (sessionId, requestId) => (await open()).session(sessionId).withdraw(requestId),
-        latestPending: async (sessionId, visitor) => (await open())
-            .withMeta(authorMeta(visitor))
-            .session(sessionId)
-            .latestPending(),
+        latestPending: async (sessionId, visitor) => {
+            const prompt = await (await open())
+                .withMeta(authorMeta(visitor))
+                .session(sessionId)
+                .latestPending();
+            return prompt === null ? null : visitorPendingPrompt(prompt, visitor.id);
+        },
+        participantDocument: async (sessionId, visitorId, options) => {
+            const snapshot = await (await open()).session(sessionId).read(options);
+            return JSON.stringify(visitorSnapshot(participantSnapshot(snapshot, policy()), visitorId));
+        },
+        participantStream: async (sessionId, visitorId, options) => {
+            let watch;
+            try {
+                watch = await (await open()).session(sessionId).watch();
+            }
+            catch (cause) {
+                options.release();
+                throw cause;
+            }
+            return visitorStream({
+                ...options,
+                watch,
+                visitorId,
+                filter: (snapshot) => participantSnapshot(snapshot, policy()),
+                read: async () => (await open()).session(sessionId).read(),
+                onError: (event, cause) => {
+                    console.warn(event, cause);
+                },
+            });
+        },
         prompt: async (sessionId, { requestId, text, meta }) => {
             // The conversation row exists now, so its channel admission is known;
             // deliver Agent tools before the first run can call one.

package/dist/standalone/computer-fleet.js

@@ -1,8 +1,10 @@
 import { Hono } from "hono";
+import { endTime, startTime } from "hono/timing";
 import { HTTPException } from "hono/http-exception";
 import { z } from "zod";
 import { computerCreateRequestSchema, computerPageSchema, } from "@fungi.computer/computer/fleet";
 import { oysterPrincipalIsOwner, } from "../host.js";
+import { computerTargetParam } from "../computer-target.js";
 /** Fleet controls never accept an actor from the request body. */
 const fleetComputerId = z.string().min(1).max(256);
 export const standaloneFleetRequestSchema = z.discriminatedUnion("operation", [
@@ -48,7 +50,7 @@ function fleetResponse(result) {
 export async function standaloneComputerSelection(registry, incoming) {
     if (incoming === undefined)
         return registry.selectedComputer();
-    const requested = new URL(incoming.request.url).searchParams.getAll("computerId");
+    const requested = new URL(incoming.request.url).searchParams.getAll(computerTargetParam);
     if (requested.length === 0)
         return registry.selectedComputer();
     const admission = await incoming.auth.authenticate(incoming.request);
@@ -91,16 +93,20 @@ export function standaloneComputerFleetRoutes(registryFor) {
         if (!oysterPrincipalIsOwner(principal))
             return context.json({ error: "Owner only" }, 403);
         const registry = registryFor();
+        startTime(context, "fleet");
         const admitted = await registry.computerFleet(principal.actor.memberId, {
             operation: "list",
             page: { limit: 1, offset: 0 },
         });
+        endTime(context, "fleet");
         if (admitted === null || "error" in admitted)
             return fleetResponse(admitted);
+        startTime(context, "registry");
         const [directory, computerId] = await Promise.all([
             registry.directory(),
             registry.selectedComputer(),
         ]);
+        endTime(context, "registry");
         return context.json({
             ...directory,
             computer: { computerId, name: computerId },

package/dist/standalone/tenancy.d.ts

@@ -1,5 +1,6 @@
 import { TenancyRegistryDO } from "../tenancy/cloudflare.js";
 import { type Identity, type Tenant, type ReadonlyTenancy } from "../tenancy/index.js";
+import { type OysterKeySessionResolver } from "../auth.js";
 import type { OysterGitWorkerEnv } from "../workers-git.js";
 import { type OysterTenancy, type TenantId } from "../tenant.js";
 /** Trusted standalone provisioning inputs; credentials never enter the seed. */
@@ -28,6 +29,8 @@ export declare class StandaloneTenants extends TenancyRegistryDO {
 /** The same trusted bindings are used by HTTP, MCP and cold root readers. */
 export type StandaloneTenancyEnv = Pick<OysterGitWorkerEnv, "OYSTER_ORIGIN" | "OYSTER_OWNER_NAME" | "OYSTER_OWNER_KEY" | "KEYS"> & Readonly<{
     TENANTS: DurableObjectNamespace<StandaloneTenants>;
+    /** Optional host-owned named-key browser sessions; Oyster mints none. */
+    OYSTER_KEY_SESSIONS?: OysterKeySessionResolver;
 }>;
 /** A live registry-owned owner; the configured label is never its member ID. */
 export type StandaloneOwner = Readonly<{

package/dist/standalone/tenancy.js

@@ -2,7 +2,7 @@ import { TenancyRegistryDO, admittedRegistry, durableObjectRegistry, } from "../
 import { createTenancy, } from "../tenancy/index.js";
 import { ownerKey } from "../tenancy/owner-key.js";
 import { hosts } from "../tenancy/resolve.js";
-import { ownerOrKeyAuth } from "../auth.js";
+import { keySessionAuth, ownerOrKeyAuth, } from "../auth.js";
 import { HTTPException } from "hono/http-exception";
 import { defaultTenant, tenantScope, } from "../tenant.js";
 import * as Schema from "effect/Schema";
@@ -173,7 +173,12 @@ async function composeTenancy(env) {
                     async authenticate(request) {
                         if (owner === null)
                             return { kind: "refused", status: 403 };
-                        const admission = await ownerOrKeyAuth(env.OYSTER_OWNER_KEY, owner.actor.memberId, () => env.KEYS.getByName(scope.durableName("keys"))).authenticate(request);
+                        const keys = () => env.KEYS.getByName(scope.durableName("keys"));
+                        const namedKeyAuth = ownerOrKeyAuth(env.OYSTER_OWNER_KEY, owner.actor.memberId, keys);
+                        const auth = env.OYSTER_KEY_SESSIONS === undefined
+                            ? namedKeyAuth
+                            : keySessionAuth(namedKeyAuth, owner.actor.memberId, keys, env.OYSTER_KEY_SESSIONS);
+                        const admission = await auth.authenticate(request);
                         // This entry admits only named keys; the owner key has its own entry.
                         return admission.kind === "admitted" &&
                             admission.principal.actor.kind === "team-key"

package/dist/turnstile.d.ts

@@ -0,0 +1,27 @@
+/** Host-owned configuration inputs, decoded before any challenge is opened. */
+export type TurnstileEnvironment = Readonly<{
+    TURNSTILE?: string;
+    TURNSTILE_SITE_KEY?: string;
+    TURNSTILE_SECRET_KEY?: string;
+}>;
+/** Explicit opt-out, complete verification credentials, or a closed door. */
+export type TurnstileConfiguration = Readonly<{
+    kind: "disabled";
+}> | Readonly<{
+    kind: "enabled";
+    siteKey: string;
+    secretKey: string;
+}> | Readonly<{
+    kind: "misconfigured";
+}>;
+/** Retain the development default; HTTPS hosts without keys fail closed. */
+export declare function readTurnstileConfiguration(environment: TurnstileEnvironment, origin: string | undefined): TurnstileConfiguration;
+/** Verify with Cloudflare; timeout policy and safe failure reporting belong to the host. */
+export declare function verifyTurnstileToken(input: {
+    secretKey: string;
+    token: string;
+    remoteIp?: string;
+}, options: {
+    timeoutMs: number;
+    onError(cause: unknown): void;
+}): Promise<"passed" | "failed" | "unavailable">;

package/dist/turnstile.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+const siteverifyUrl = "https://challenges.cloudflare.com/turnstile/v0/siteverify";
+const environmentSchema = z.object({
+    TURNSTILE: z.literal("off").optional(),
+    TURNSTILE_SITE_KEY: z.string().trim().min(1).optional(),
+    TURNSTILE_SECRET_KEY: z.string().trim().min(1).optional(),
+});
+const responseSchema = z.object({ success: z.boolean() });
+/** Retain the development default; HTTPS hosts without keys fail closed. */
+export function readTurnstileConfiguration(environment, origin) {
+    const parsed = environmentSchema.safeParse(environment);
+    if (!parsed.success)
+        return { kind: "misconfigured" };
+    if (parsed.data.TURNSTILE === "off")
+        return { kind: "disabled" };
+    const { TURNSTILE_SITE_KEY: siteKey, TURNSTILE_SECRET_KEY: secretKey } = parsed.data;
+    if (siteKey === undefined && secretKey === undefined)
+        return URL.parse(origin ?? "")?.protocol === "https:"
+            ? { kind: "misconfigured" }
+            : { kind: "disabled" };
+    if (siteKey === undefined || secretKey === undefined)
+        return { kind: "misconfigured" };
+    return { kind: "enabled", siteKey, secretKey };
+}
+/** Verify with Cloudflare; timeout policy and safe failure reporting belong to the host. */
+export async function verifyTurnstileToken(input, options) {
+    try {
+        const body = {
+            secret: input.secretKey,
+            response: input.token,
+        };
+        if (input.remoteIp !== undefined)
+            body.remoteip = input.remoteIp;
+        const response = await fetch(siteverifyUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(options.timeoutMs),
+        });
+        if (!response.ok)
+            return "unavailable";
+        const verdict = responseSchema.safeParse(await response.json());
+        if (!verdict.success)
+            return "unavailable";
+        return verdict.data.success ? "passed" : "failed";
+    }
+    catch (cause) {
+        options.onError(cause);
+        return "unavailable";
+    }
+}

package/dist/workers-git.js

@@ -889,6 +889,7 @@ export function createOysterGitWorker(root) {
                 hosts = new Map();
                 environments.set(env, hosts);
             }
+            const started = Date.now();
             let resolved;
             try {
                 resolved = await root.admit(env, request);
@@ -907,6 +908,7 @@ export function createOysterGitWorker(root) {
             const boot = await serveOysterBootCapability(request, env, scope);
             if (boot !== null)
                 return boot;
+            const admitted = Date.now();
             let host;
             try {
                 host = await root.hostFor(env, scope, request);
@@ -916,6 +918,7 @@ export function createOysterGitWorker(root) {
                     return error.getResponse();
                 throw error;
             }
+            const hosted = Date.now();
             const key = `${scope.tenantId}:${scope.origin}:${host.computerId ?? ""}`;
             let entry = hosts.get(key);
             let cache = true;
@@ -938,7 +941,10 @@ export function createOysterGitWorker(root) {
             }
             entry.active += 1;
             try {
-                return await entry.app.fetch(request, env, ctx);
+                return withStageTimings(await entry.app.fetch(request, env, ctx), {
+                    admit: admitted - started,
+                    host: hosted - admitted,
+                });
             }
             finally {
                 entry.active -= 1;
@@ -946,6 +952,19 @@ export function createOysterGitWorker(root) {
         },
     };
 }
+/**
+ * Add the root's own stages (tenant admission, host selection) to the App
+ * server's Server-Timing, so a slow request names the hop it waited on. An
+ * upgraded socket keeps its response untouched.
+ */
+function withStageTimings(response, stages) {
+    if (response.status === 101)
+        return response;
+    const timed = new Response(response.body, response);
+    for (const [name, duration] of Object.entries(stages))
+        timed.headers.append("Server-Timing", `${name};dur=${String(duration)}`);
+    return timed;
+}
 /**
  * `host.git` for an Oyster Worker: the git door's writer projection and the
  * admitted, installation-scoped Artifacts path with the App's push policy and

package/dist/workers.js

@@ -35,10 +35,11 @@ import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import { releaseSchema } from "@fungi.computer/puffball/effect";
 import { AppInstanceError, } from "./index.js";
-import { createCloudflareAppInstance, r2ArtifactStore, createCloudflareInvocationGate, decodeFrameBindingProps, captureFrameBindingReply, frameBindingEntrypoint, backgroundFrameMethods, } from "./cloudflare.js";
+import { createCloudflareAppInstance, r2ArtifactStore, createCloudflareInvocationGate, edgeVerifiedObjectCache, decodeFrameBindingProps, captureFrameBindingReply, frameBindingEntrypoint, backgroundFrameMethods, } from "./cloudflare.js";
 import { invocationFactsSchema, assertBackgroundBinding, admitBackgroundFrame, } from "./invocation.js";
 import { deliverBackground, deliverGitPush } from "./internal/delivery.js";
-import { createOyster, verifyRelease, defaultAssetPolicy, } from "./host.js";
+import { releaseCache } from "./internal/host-gate.js";
+import { createOyster, } from "./host.js";
 import { createGitPushJournal } from "./git-journal.js";
 import { AppStorageError, } from "@fungi.computer/agar/storage";
 import { storageFrameMethods } from "./storage-frame.js";
@@ -148,6 +149,7 @@ export class OysterRegistry extends DurableObject {
         return this.approvalHome(pin).capability(actor).setAutoApprove(input);
     }
     #rootData;
+    #releases = releaseCache(r2ArtifactStore(this.env.RELEASES));
     /** Append-only App source seed receipts; a Git-capable subclass forks over these. */
     appSourceReceipts;
     /** Team-owned fork registrations, one App publisher record per App. */
@@ -196,7 +198,7 @@ export class OysterRegistry extends DurableObject {
             installations: {
                 list: () => Promise.resolve(this.list()),
             },
-            resolveRelease: (release) => verifyRelease(r2ArtifactStore(env.RELEASES), release, defaultAssetPolicy, false),
+            resolveRelease: this.#releases,
         });
     }
     /** The installation owner's RPC: admit, read, load, plan or commit one
@@ -319,7 +321,7 @@ export class OysterRegistry extends DurableObject {
                                 expected.selection.releaseId ||
                             installation.release.appId !== expected.selection.appId)))
                     throw new AppStorageError("unavailable");
-                const resolved = await verifyRelease(r2ArtifactStore(this.env.RELEASES), installation.release, defaultAssetPolicy, false);
+                const resolved = await this.#releases(installation.release);
                 if (expected !== undefined &&
                     resolved.backend?.digest !== expected.artifactDigest)
                     throw new AppStorageError("unavailable");
@@ -756,9 +758,9 @@ export class OysterInstance extends DurableObject {
     }
     async executeBindingCall(raw, method, input) {
         const props = decodeFrameBindingProps(raw);
-        const frame = this.frames.active();
-        if (props.instanceId !== frame.facts.instanceId ||
-            props.frameId !== frame.frameId)
+        // The packet's own frame: a closed or foreign frame id refuses.
+        const frame = this.frames.active(props.frameId);
+        if (props.instanceId !== frame.facts.instanceId)
             throw new AppInstanceError("revoked");
         assertBackgroundBinding(frame, props.binding);
         // A guest packet is its own entry: exactly one registry read re-admits it.
@@ -787,7 +789,7 @@ export class OysterInstance extends DurableObject {
             .every((operation) => granted.includes(operation)))
             throw new AppInstanceError("binding_not_granted");
         const result = await row.dispatch(this.#bindingContext, frame, props, method, args);
-        if (this.frames.active() !== frame)
+        if (this.frames.active(props.frameId) !== frame)
             throw new AppInstanceError("revoked");
         assertBackgroundBinding(frame, props.binding);
         return descriptor.decodeResult(result);
@@ -1102,10 +1104,7 @@ export function oysterWorkerHost(env, auth, options = {}) {
         },
         auth,
         workbench: {
-            directory: async () => {
-                await installations.list();
-                return registry().directory();
-            },
+            directory: () => registry().directory(),
             storage: (installationId, ownerId) => ({
                 read: (key) => registry().storageRead(installationId, ownerId, key),
                 write: (input) => registry().storageWrite(installationId, ownerId, input),
@@ -1115,6 +1114,10 @@ export function oysterWorkerHost(env, auth, options = {}) {
         },
         guestLimits: guestLimits(options.guestLimits),
         artifacts,
+        // Workers and workerd keep a zone cache; a runtime without one reads R2.
+        ...("caches" in globalThis && {
+            uiCache: edgeVerifiedObjectCache(caches.default, scope.origin),
+        }),
         bootUi: oysterBootUi(env, scope),
         // File-only hosts may keep workspace files beside their Release artifacts.
         capabilities: [

package/docs/api/auth.md

@@ -8,6 +8,26 @@
 
 # auth
 
+## Type Aliases
+
+### OysterKeySessionResolver
+
+```ts
+type OysterKeySessionResolver = Readonly<{
+  resolve: (value) => Promise<Readonly<{
+    keyId: string;
+  }> | null>;
+}>;
+```
+
+The host owns session minting, hashing/storage and expiry. A session resolves
+only to a key id, never to owner or grant authority. Hosts should use Path=/,
+HttpOnly, Secure and SameSite=Lax (or stricter) as defense in depth; Oyster
+independently checks request provenance. Cookie-only admission allows GET/HEAD
+navigation. Every other method requires Origin to be present and equal the
+request URL's origin, and Sec-Fetch-Site not to be cross-site. Missing Origin is
+refused.
+
 ## Variables
 
 ### ownerKeyCookieName
@@ -18,6 +38,16 @@ const ownerKeyCookieName: "oyster_session" = "oyster_session";
 
 Cookie emitted by ownerKeyAuth, for composing credential-specific adapters.
 
+---
+
+### keySessionCookieName
+
+```ts
+const keySessionCookieName: "oyster_key_session" = "oyster_key_session";
+```
+
+Host-minted opaque sessions for named keys, separate from the owner cookie.
+
 ## Functions
 
 ### ownerKeyAuth()
@@ -61,3 +91,28 @@ The owner key, or a named key admitted as its canonical Team-key actor.
 #### Returns
 
 [`OysterAuth`](host.md#oysterauth)
+
+---
+
+### keySessionAuth()
+
+```ts
+function keySessionAuth(auth, ownerId, keys, sessions): OysterAuth;
+```
+
+Add host-owned browser sessions to ownerOrKeyAuth. Explicit credentials and
+non-401 refusals keep their ordinary result; ambient cookies cannot undo them.
+Every cookie admission rechecks the key's liveness and canonical owner.
+
+#### Parameters
+
+| Parameter  | Type                                                                  |
+| ---------- | --------------------------------------------------------------------- |
+| `auth`     | [`OysterAuth`](host.md#oysterauth)                                    |
+| `ownerId`  | `string`                                                              |
+| `keys`     | () => `NonNullable`\<[`OysterHost`](host.md#oysterhost)\[`"keys"`\]\> |
+| `sessions` | [`OysterKeySessionResolver`](#oysterkeysessionresolver)               |
+
+#### Returns
+
+[`OysterAuth`](host.md#oysterauth)

package/docs/api/build-contract.md

@@ -966,7 +966,7 @@ function putContentObject(
   object,
   body,
   mediaType,
-): Promise<"refused" | "stored">;
+): Promise<"stored" | "refused">;
 ```
 
 Stream one object into the store under its digest. The store refuses a body
@@ -987,7 +987,7 @@ the body is discarded, never stored.
 
 #### Returns
 
-`Promise`\<`"refused"` \| `"stored"`\>
+`Promise`\<`"stored"` \| `"refused"`\>
 
 ---
 

package/docs/api/cloudflare.md

@@ -305,6 +305,30 @@ frame or guestEnv factory is accepted.
 
 ---
 
+### edgeVerifiedObjectCache()
+
+```ts
+function edgeVerifiedObjectCache(cache, origin): VerifiedObjectCache;
+```
+
+The zone's edge cache as a [VerifiedObjectCache](host.md#verifiedobjectcache):
+each verified object under a digest-named key on `origin` that no route serves.
+A failed write is logged and answers `unstored`; the next reader verifies from
+the store again.
+
+#### Parameters
+
+| Parameter | Type                                    |
+| --------- | --------------------------------------- |
+| `cache`   | `Pick`\<`Cache`, `"match"` \| `"put"`\> |
+| `origin`  | `string`                                |
+
+#### Returns
+
+[`VerifiedObjectCache`](host.md#verifiedobjectcache)
+
+---
+
 ### r2ArtifactStore()
 
 ```ts
@@ -435,7 +459,8 @@ function createCloudflareInvocationGate<Host, FacetClass>(
 ): InvocationGate<Host>;
 ```
 
-End the native App facet before shared frame admission releases its permit.
+End the native App facet when live authority closes early, before the gate
+admits again.
 
 #### Type Parameters