@fungi.computer/oyster 0.2.0 → 0.3.1

package/dist/machine-link/host.js

@@ -0,0 +1,189 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { correlationKey } from "@fungi.computer/cairn";
+import { createMachineLinkPostChannel, MachineLinkPostUnavailable, machineLinkAudience, } from "@fungi.computer/seam/machine-link-protocol";
+import { importSeamVerifiers, seamHeader, verifySeamRequest, } from "@fungi.computer/seam";
+import { createLocalBackendReplayStore } from "@fungi.computer/computer";
+import { createMachineLinkSockets } from "./presence.js";
+const attachmentSchema = z.strictObject({
+    deviceId: z.string().min(1).max(256),
+    fenceEpoch: z.int().nonnegative(),
+});
+const maximumInFlight = 32;
+/**
+ * Native device socket I/O. Pins/member authority and mail admission are supplied
+ * by their existing owners. Native attachments survive hibernation; pending
+ * Post I/O does not claim durable custody and is retried by Carrier.
+ */
+export class MachineLinkHost {
+    context;
+    options;
+    channels = new Map();
+    replay;
+    routes;
+    constructor(context, owner, options) {
+        this.context = context;
+        this.options = options;
+        this.replay = createLocalBackendReplayStore(owner);
+        context.setWebSocketAutoResponse(new WebSocketRequestResponsePair("ping", "pong"));
+        this.routes = new Hono().get("/api/teams/:teamId/local/mesh/:deviceId/connect", async (context) => {
+            if (context.req.param("teamId") !== options.teamId)
+                return context.body(null, 403);
+            const request = context.req.raw;
+            if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket")
+                return context.body(null, 426);
+            const deviceId = context.req.param("deviceId");
+            try {
+                const device = await options.authorize(deviceId);
+                const keyId = await verifySeamRequest(await importSeamVerifiers({ [deviceId]: device.publicKey }), machineLinkAudience(options.teamId, deviceId), request.method, request.url, request.headers.get(seamHeader), null, this.replay);
+                if (keyId !== deviceId)
+                    return context.body(null, 403);
+                const pair = new WebSocketPair();
+                pair[1].serializeAttachment({
+                    deviceId,
+                    fenceEpoch: device.fenceEpoch,
+                });
+                createMachineLinkSockets(this.context, deviceId).accept(pair[1]);
+                await this.publishDirectory(pair[1], deviceId);
+                return new Response(null, { status: 101, webSocket: pair[0] });
+            }
+            catch (cause) {
+                this.options.report("machine-link.dial", cause);
+                return context.body(null, 403);
+            }
+        });
+    }
+    fetch(request) {
+        return Promise.resolve(this.routes.fetch(request));
+    }
+    async publishDirectory(socket, deviceId) {
+        // Ordered before the addressed operation, but its metadata ACK is not a
+        // prerequisite for work admission (including the deliberately lost ACK).
+        const agents = await this.options.directory();
+        this.context.waitUntil(this.channel(socket, deviceId)
+            .deliver({
+            key: `directory:${correlationKey()}`,
+            kind: "machineDirectory",
+            address: { teamId: this.options.teamId, deviceId },
+            event: {
+                agents: agents.map(({ agentId, name }) => ({ agentId, name })),
+            },
+        })
+            .then(() => undefined, (cause) => {
+            this.options.report("machine-link.directory", cause);
+            socket.close(1011, "directory unavailable");
+        }));
+    }
+    channel(socket, deviceId) {
+        let channel = this.channels.get(socket);
+        if (channel === undefined) {
+            // Native stream ordering survives asynchronous authority pulls. Bound
+            // writes to the combined send/receive budgets independently of receipt
+            // timeouts; this is not a custody or retry queue.
+            const writer = new WritableStream({
+                write: async (frame) => {
+                    await this.authorizeSocket(socket, deviceId);
+                    socket.send(frame);
+                },
+            }, new CountQueuingStrategy({ highWaterMark: 2 * maximumInFlight })).getWriter();
+            channel = createMachineLinkPostChannel({
+                limits: {
+                    maxInFlight: maximumInFlight,
+                    maxFrameBytes: 512 * 1024,
+                    acknowledgmentMs: 10_000,
+                },
+                send: (frame) => {
+                    // A receipt timeout releases Post custody, not a still-blocked
+                    // native write. Enforce the stream's bound before enqueueing again.
+                    if (writer.desiredSize === null || writer.desiredSize <= 0)
+                        throw new MachineLinkPostUnavailable({ reason: "busy" });
+                    return writer.write(frame);
+                },
+                receive: async (envelope) => {
+                    const device = await this.authorizeSocket(socket, deviceId);
+                    return await this.options.receive(device, envelope);
+                },
+            });
+            this.channels.set(socket, channel);
+        }
+        return channel;
+    }
+    async deliver(deviceId, envelope) {
+        await this.options.authorize(deviceId);
+        const links = createMachineLinkSockets(this.context, deviceId);
+        const socket = this.context
+            .getWebSockets(`machine-link:${deviceId}`)
+            .find((candidate) => links.isCurrent(candidate));
+        if (socket === undefined)
+            throw new MachineLinkPostUnavailable({ reason: "closed" });
+        await this.publishDirectory(socket, deviceId);
+        return await this.channel(socket, deviceId).deliver(envelope);
+    }
+    async message(socket, message) {
+        try {
+            const { deviceId } = attachmentSchema.parse(socket.deserializeAttachment());
+            if (!createMachineLinkSockets(this.context, deviceId).isCurrent(socket)) {
+                socket.close(4001, "replaced");
+                return;
+            }
+            await this.authorizeSocket(socket, deviceId);
+            const text = z.string().safeParse(message);
+            if (!text.success) {
+                socket.close(1003, "text required");
+                return;
+            }
+            await this.channel(socket, deviceId).receive(text.data);
+        }
+        catch (cause) {
+            this.#fail(socket, cause);
+        }
+    }
+    close(socket) {
+        this.channels.get(socket)?.close();
+        this.channels.delete(socket);
+    }
+    // A message that cannot be admitted or received ends this link: the host
+    // records the cause and the device sees 1011, then reconnects with a fresh dial.
+    #fail(socket, cause) {
+        this.options.report("machine-link.message", cause);
+        this.close(socket);
+        socket.close(1011, "machine link unavailable");
+    }
+    async authorizeSocket(socket, deviceId) {
+        const attachment = attachmentSchema.parse(socket.deserializeAttachment());
+        const device = await this.options
+            .authorize(deviceId)
+            .catch((cause) => {
+            this.close(socket);
+            socket.close(4003, "authority unavailable");
+            throw cause;
+        });
+        if (attachment.deviceId !== deviceId ||
+            attachment.fenceEpoch !== device.fenceEpoch ||
+            !createMachineLinkSockets(this.context, deviceId).isCurrent(socket)) {
+            this.close(socket);
+            socket.close(4003, "authority changed");
+            throw new MachineLinkPostUnavailable({ reason: "closed" });
+        }
+        return device;
+    }
+    /** A delayed old fence cannot retire a fresh connection at the current epoch. */
+    fence(fenceEpoch, live) {
+        for (const socket of this.context.getWebSockets()) {
+            const pin = attachmentSchema.safeParse(socket.deserializeAttachment());
+            if (!pin.success ||
+                pin.data.fenceEpoch < fenceEpoch ||
+                (!live && pin.data.fenceEpoch === fenceEpoch)) {
+                this.close(socket);
+                socket.close(4003, "authority changed");
+            }
+        }
+    }
+    /** Authorized physical erasure retires even hibernated sockets, at any epoch. */
+    retireForErasure() {
+        for (const socket of this.context.getWebSockets()) {
+            this.close(socket);
+            socket.close(4003, "erased");
+        }
+    }
+}

package/dist/machine-link/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * One device's outbound machine link, shared by every Oyster host. The host
+ * supplies live authority; this entry owns enrollment, the fence outbox and
+ * the shared link types, and runs on any host. Device sockets, signed-dial
+ * replay and Post custody need the Workers runtime and live in
+ * `@fungi.computer/oyster/machine-link/workers`. The wire protocol stays in
+ * `@fungi.computer/seam/machine-link-protocol`.
+ */
+export * from "./authority.js";
+export * from "./enrollment.js";
+export * from "./fences.js";
+export * from "./home.js";
+export * from "./presence.js";
+export * from "./client.js";
+export * from "./delivery.js";

package/dist/machine-link/index.js

@@ -0,0 +1,15 @@
+/**
+ * One device's outbound machine link, shared by every Oyster host. The host
+ * supplies live authority; this entry owns enrollment, the fence outbox and
+ * the shared link types, and runs on any host. Device sockets, signed-dial
+ * replay and Post custody need the Workers runtime and live in
+ * `@fungi.computer/oyster/machine-link/workers`. The wire protocol stays in
+ * `@fungi.computer/seam/machine-link-protocol`.
+ */
+export * from "./authority.js";
+export * from "./enrollment.js";
+export * from "./fences.js";
+export * from "./home.js";
+export * from "./presence.js";
+export * from "./client.js";
+export * from "./delivery.js";

package/dist/machine-link/link.d.ts

@@ -0,0 +1,48 @@
+import * as Schema from "effect/Schema";
+import { type MachineAgentOperation } from "@fungi.computer/seam/machine-link-protocol";
+import type { PostDeliveryResult, PostEnvelope } from "@fungi.computer/carrier/post";
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import { type MachineLinkAuthority, type MachineLinkCaller, type MachineLinkFenceFact, type MachineLinkFenceResult, type MachineLinkIdentity } from "./authority.js";
+/** The Durable Object state a machine link needs from its host class. */
+export type MachineLinkState = Pick<DurableObjectState, "getWebSockets" | "acceptWebSocket" | "setWebSocketAutoResponse" | "waitUntil"> & Readonly<{
+    storage: WatchdogSqliteOwner & Pick<DurableObjectStorage, "get" | "put">;
+}>;
+/** The host's own storage erasure, so readback matches its other owners. */
+export type MachineLinkStorageErasure<Readback> = Readonly<{
+    erased(): Promise<boolean>;
+    erase(): Promise<Readback>;
+    read(): Promise<Readback>;
+}>;
+/**
+ * One device's link inside its own Durable Object. The host's DO class
+ * delegates every entry point here. Identity is pinned on the first live
+ * answer and every act rereads the host's authority; nothing is written
+ * before the host says the device is live.
+ */
+export declare function createMachineLink<Readback>(state: MachineLinkState, options: Readonly<{
+    authority: Omit<MachineLinkAuthority, "deliverControlFact">;
+    /** Whether this DO is the canonical owner for the identity. */
+    addressed: (identity: MachineLinkIdentity) => boolean;
+    erasure: MachineLinkStorageErasure<Readback>;
+    report: (operation: string, cause: unknown) => void;
+}>): {
+    fetch: (request: Request) => Promise<Response>;
+    /** Mail addressed to this device's Agent, rechecked against its home. */
+    deliver(input: MachineLinkIdentity, caller: MachineLinkCaller, agentId: string, envelope: PostEnvelope): Promise<PostDeliveryResult>;
+    /** One finite Agent operation on this device, returning its receipt. */
+    operation(input: MachineLinkIdentity, caller: MachineLinkCaller, agentId: string, raw: MachineAgentOperation): Promise<Schema.Json>;
+    /**
+     * Apply one committed fence fact pushed by the host's producer. The fact
+     * is the push; the link does not read authority back here. Sockets at an
+     * older epoch close, and a not-live fact closes the current one too. The
+     * per-frame live read remains the guarantee.
+     */
+    applyFence(raw: MachineLinkFenceFact): MachineLinkFenceResult;
+    preflightErasure: (teamId: string, deviceId: string) => Promise<void>;
+    eraseForTeam(teamId: string, deviceId: string): Promise<Readback>;
+    readErasure: () => Promise<Readback>;
+    webSocketMessage(socket: WebSocket, message: string | ArrayBuffer): Promise<void>;
+    webSocketClose(socket: WebSocket, code: number, reason: string): void;
+    webSocketError(socket: WebSocket): void;
+};
+export type MachineLink = ReturnType<typeof createMachineLink>;

package/dist/machine-link/link.js

@@ -0,0 +1,223 @@
+import { createHash } from "node:crypto";
+import { Hono } from "hono";
+import * as Schema from "effect/Schema";
+import { BirdDogMailSchema } from "@fungi.computer/bird-dog/effect";
+import { agentMailAddressSchema, machineAgentOperationSchema, MachineLinkPostUnavailable, } from "@fungi.computer/seam/machine-link-protocol";
+import { machineLinkFenceFactSchema, machineLinkIdentitySchema, machineLinkName, MachineLinkRefused, } from "./authority.js";
+import { MachineLinkHost } from "./host.js";
+const pinKey = "machine-link:identity";
+const maximumMailBytes = 256 * 1024;
+/**
+ * One device's link inside its own Durable Object. The host's DO class
+ * delegates every entry point here. Identity is pinned on the first live
+ * answer and every act rereads the host's authority; nothing is written
+ * before the host says the device is live.
+ */
+export function createMachineLink(state, options) {
+    const { authority } = options;
+    let host;
+    const match = (identity) => {
+        if (!options.addressed(identity))
+            throw new MachineLinkRefused("actor_not_allowed");
+    };
+    const savedIdentity = async () => {
+        const raw = await state.storage.get(pinKey);
+        return raw === undefined ? null : machineLinkIdentitySchema.parse(raw);
+    };
+    const current = async (input) => {
+        const proposed = machineLinkIdentitySchema.parse(input);
+        const saved = await savedIdentity();
+        if (saved !== null && machineLinkName(saved) !== machineLinkName(proposed))
+            throw new MachineLinkRefused("actor_not_allowed");
+        const identity = saved ?? proposed;
+        match(identity);
+        if (await options.erasure.erased())
+            throw new MachineLinkPostUnavailable({ reason: "closed" });
+        // Pinned address only. Neither a forwarding header nor caller-provided key
+        // can lend authority to this link.
+        const facts = await authority.admitDevice(identity);
+        if (!facts.live)
+            throw new MachineLinkPostUnavailable({ reason: "closed" });
+        match(facts);
+        if (facts.teamId !== identity.teamId ||
+            facts.deviceId !== identity.deviceId)
+            throw new MachineLinkRefused("actor_not_allowed");
+        // First product write is after the host's independent live decision.
+        if (saved === null)
+            await state.storage.put(pinKey, identity);
+        return facts;
+    };
+    const mail = (envelope) => {
+        const address = Schema.decodeUnknownSync(agentMailAddressSchema, {
+            onExcessProperty: "error",
+        })(envelope.address);
+        const body = Schema.decodeUnknownSync(BirdDogMailSchema, {
+            onExcessProperty: "error",
+        })(envelope.event);
+        return { address, mail: body };
+    };
+    /**
+     * The link's own sender check, whatever the host answered: the facts must
+     * name the caller and actor it saw, a hosted caller must be hosted, and a
+     * device caller must be an Agent homed on that live device, same member.
+     */
+    const checkedTarget = async (identity, caller, agentId, requesterAgentId) => {
+        const facts = await authority.resolveTarget(identity, caller, agentId, requesterAgentId);
+        if (facts.teamId !== identity.teamId ||
+            facts.callerAgentId !== caller.agentId ||
+            facts.targetAgentId !== agentId ||
+            facts.actorAgentId !== (requesterAgentId ?? caller.agentId))
+            throw new MachineLinkRefused("actor_not_allowed");
+        if (caller.kind === "hosted") {
+            if (facts.callerHome.kind !== "hosted")
+                throw new MachineLinkRefused("actor_not_allowed");
+            return facts;
+        }
+        const source = await authority.admitDevice({
+            teamId: identity.teamId,
+            deviceId: caller.deviceId,
+        });
+        if (!source.live ||
+            source.teamId !== identity.teamId ||
+            source.deviceId !== caller.deviceId ||
+            facts.callerHome.kind !== "machine" ||
+            facts.callerHome.deviceId !== source.deviceId)
+            throw new MachineLinkRefused("actor_not_allowed");
+        return facts;
+    };
+    const receive = async (identity, envelope) => {
+        await current(identity);
+        if (envelope.kind !== "agentMail")
+            return "refused";
+        const { address, mail: body } = mail(envelope);
+        const caller = {
+            kind: "device",
+            deviceId: identity.deviceId,
+            agentId: body.from.agentId,
+        };
+        const target = await checkedTarget(identity, caller, address.agentId, null);
+        if (envelope.key !== body.key ||
+            address.scopeId !== target.teamId ||
+            address.agentId !== body.to.agentId ||
+            new TextEncoder().encode(JSON.stringify(body)).byteLength >
+                maximumMailBytes)
+            return "refused";
+        return await authority.deliverHome(identity, caller, target, envelope);
+    };
+    const hostFor = (input) => {
+        const identity = { teamId: input.teamId, deviceId: input.deviceId };
+        return (host ??= new MachineLinkHost(state, state.storage, {
+            teamId: identity.teamId,
+            authorize: async (deviceId) => {
+                if (deviceId !== identity.deviceId)
+                    throw new MachineLinkRefused("actor_not_allowed");
+                return await current(identity);
+            },
+            directory: () => authority.directory(identity),
+            receive: (_device, envelope) => receive(identity, envelope),
+            report: options.report,
+        }));
+    };
+    const routes = new Hono().get("/api/teams/:teamId/local/mesh/:deviceId/connect", async (context) => {
+        const identity = machineLinkIdentitySchema.parse(context.req.param());
+        try {
+            await current(identity);
+            return await hostFor(identity).fetch(context.req.raw);
+        }
+        catch {
+            return context.body(null, 403);
+        }
+    });
+    const preflightErasure = async (teamId, deviceId) => {
+        const identity = machineLinkIdentitySchema.parse({ teamId, deviceId });
+        match(identity);
+        if (await options.erasure.erased())
+            return;
+        if (!(await authority.canErase(identity)))
+            throw new MachineLinkRefused("actor_not_allowed");
+    };
+    return {
+        fetch: (request) => Promise.resolve(routes.fetch(request)),
+        /** Mail addressed to this device's Agent, rechecked against its home. */
+        async deliver(input, caller, agentId, envelope) {
+            const device = await current(input);
+            if (envelope.kind !== "agentMail")
+                return "refused";
+            const { address, mail: body } = mail(envelope);
+            const facts = await checkedTarget(device, caller, agentId, null);
+            if (facts.targetHome.kind !== "machine" ||
+                facts.targetHome.deviceId !== device.deviceId ||
+                envelope.key !== body.key ||
+                address.scopeId !== facts.teamId ||
+                address.agentId !== facts.targetAgentId ||
+                body.to.agentId !== facts.targetAgentId ||
+                body.from.agentId !== facts.callerAgentId ||
+                new TextEncoder().encode(JSON.stringify(body)).byteLength >
+                    maximumMailBytes)
+                return "refused";
+            return await hostFor(device).deliver(device.deviceId, envelope);
+        },
+        /** One finite Agent operation on this device, returning its receipt. */
+        async operation(input, caller, agentId, raw) {
+            const device = await current(input);
+            const operation = Schema.decodeUnknownSync(machineAgentOperationSchema, {
+                onExcessProperty: "error",
+            })(raw);
+            const facts = await checkedTarget(device, caller, agentId, operation.type === "settlement" ? operation.requesterAgentId : null);
+            if (facts.targetHome.kind !== "machine" ||
+                facts.targetHome.deviceId !== device.deviceId)
+                throw new MachineLinkRefused("actor_not_allowed");
+            const key = createHash("sha256")
+                .update(JSON.stringify([facts.callerAgentId, facts.targetAgentId, operation]))
+                .digest("hex");
+            const result = await hostFor(device).deliver(device.deviceId, {
+                key,
+                kind: "machineAgent",
+                address: { scopeId: facts.teamId, agentId: facts.targetAgentId },
+                event: { actorAgentId: facts.actorAgentId, operation },
+            });
+            if (result === "accepted" ||
+                result === "duplicate" ||
+                result === "refused" ||
+                !("receipt" in result) ||
+                result.status === "refused")
+                throw new MachineLinkRefused("unavailable");
+            return result.receipt;
+        },
+        /**
+         * Apply one committed fence fact pushed by the host's producer. The fact
+         * is the push; the link does not read authority back here. Sockets at an
+         * older epoch close, and a not-live fact closes the current one too. The
+         * per-frame live read remains the guarantee.
+         */
+        applyFence(raw) {
+            const fact = machineLinkFenceFactSchema.parse(raw);
+            match(fact);
+            hostFor(fact).fence(fact.fenceEpoch, fact.live);
+            return { kind: "confirmed", fenceEpoch: fact.fenceEpoch };
+        },
+        preflightErasure,
+        async eraseForTeam(teamId, deviceId) {
+            await preflightErasure(teamId, deviceId);
+            hostFor({ teamId, deviceId }).retireForErasure();
+            return await options.erasure.erase();
+        },
+        readErasure: () => options.erasure.read(),
+        async webSocketMessage(socket, message) {
+            const identity = await savedIdentity();
+            if (identity === null) {
+                socket.close(4003, "identity unavailable");
+                return;
+            }
+            await hostFor(identity).message(socket, message);
+        },
+        webSocketClose(socket, code, reason) {
+            host?.close(socket);
+            socket.close(code === 1005 || code === 1006 ? 1000 : code, reason);
+        },
+        webSocketError(socket) {
+            host?.close(socket);
+            socket.close(1011, "machine link error");
+        },
+    };
+}

package/dist/machine-link/presence.d.ts

@@ -0,0 +1,10 @@
+/** Native socket ownership for one machine; the caller authenticates each dial. */
+export declare function createMachineLinkSockets(context: Pick<DurableObjectState, "acceptWebSocket" | "getWebSockets">, deviceId: string): {
+    accept: (socket: WebSocket) => void;
+    isCurrent: (socket: WebSocket) => boolean;
+};
+/**
+ * Classify the accepted socket using its platform auto-response timestamp.
+ * Presence is a liveness hint, never Team membership or execution authority.
+ */
+export declare function isMachineLinkOnline(hasCurrentSocket: boolean, lastAutoPongAt: Date | null, now: number): boolean;

package/dist/machine-link/presence.js

@@ -0,0 +1,25 @@
+/** Native socket ownership for one machine; the caller authenticates each dial. */
+export function createMachineLinkSockets(context, deviceId) {
+    const machineLinkTag = `machine-link:${deviceId}`;
+    return {
+        accept: (socket) => {
+            context.acceptWebSocket(socket, [machineLinkTag]);
+            for (const previous of context.getWebSockets(machineLinkTag)) {
+                if (previous !== socket && previous.readyState === WebSocket.OPEN)
+                    previous.close(4001, "replaced");
+            }
+        },
+        isCurrent: (socket) => socket.readyState === WebSocket.OPEN &&
+            context.getWebSockets(machineLinkTag).includes(socket),
+    };
+}
+/**
+ * Classify the accepted socket using its platform auto-response timestamp.
+ * Presence is a liveness hint, never Team membership or execution authority.
+ */
+export function isMachineLinkOnline(hasCurrentSocket, lastAutoPongAt, now) {
+    if (!hasCurrentSocket || lastAutoPongAt === null)
+        return false;
+    const age = now - lastAutoPongAt.getTime();
+    return age >= 0 && age < 90_000;
+}

package/dist/machine-link/workers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The Workers half of the machine link: one device's native sockets,
+ * signed-dial replay ledger and Post custody inside its own Durable Object.
+ */
+export * from "./host.js";
+export * from "./link.js";

package/dist/machine-link/workers.js

@@ -0,0 +1,6 @@
+/**
+ * The Workers half of the machine link: one device's native sockets,
+ * signed-dial replay ledger and Post custody inside its own Durable Object.
+ */
+export * from "./host.js";
+export * from "./link.js";

package/dist/mcp-owner.d.ts

@@ -17,11 +17,11 @@ export type OysterMcpTenantPin = Readonly<{
  */
 export declare class OysterMcpOwner<Env extends OysterMcpOwnerEnv = OysterMcpOwnerEnv> extends DurableObject<Env> {
     #private;
-    constructor(ctx: DurableObjectState, env: Env, createHost: (env: Env, scope: TenantScope) => OysterHost);
+    constructor(ctx: DurableObjectState, env: Env, createHost: (env: Env, scope: TenantScope) => OysterHost | Promise<OysterHost>);
     /** Trusted host RPC: the namespace and pin are never selected by guest headers. */
     serve(request: Request, tenant: OysterMcpTenantPin): Promise<Response>;
 }
 /** Bind the owner to the deployment's existing host factory and options. */
-export declare function createOysterMcpOwner<Env extends OysterMcpOwnerEnv>(host: (env: Env, scope: TenantScope) => OysterHost): new (ctx: DurableObjectState, env: Env) => OysterMcpOwner<Env>;
+export declare function createOysterMcpOwner<Env extends OysterMcpOwnerEnv>(host: (env: Env, scope: TenantScope) => OysterHost | Promise<OysterHost>): new (ctx: DurableObjectState, env: Env) => OysterMcpOwner<Env>;
 /** Frontends own no SDK state and cannot close another isolate's sessions. */
 export declare function remoteOysterMcp(binding: DurableObjectNamespace<OysterMcpOwner> | undefined, scope: TenantScope): OysterMcp;