@fungi.computer/oyster 0.1.0 → 0.3.0

package/dist/standalone/registry.d.ts

@@ -1,15 +1,19 @@
+import type { Release } from "@fungi.computer/puffball";
 import { OysterRegistry, type OysterWorkerEnv } from "../workers.js";
-import type { TenantId } from "../tenant.js";
+import { type OysterHost } from "../host.js";
+import { type TenantScope, type TenantId } from "../tenant.js";
 import { type OysterGitEnv } from "../workers-git.js";
 import { type AppSourceForkResult, type TemplateSeedClaim } from "../source/index.js";
 import { type CloudflareArtifactsOptions } from "@fungi.computer/burrow/cloudflare";
-import { type OysterBuildSource, type OysterBuildView } from "../app-builds.js";
+import { type OysterBuildStartResult, type OysterBuildView } from "../app-builds.js";
 import type { TeamAppCandidateManifest } from "../build-contract.js";
 import type { BuildGitEvent } from "../build-egress.js";
 import { type StandaloneTenancyEnv } from "./tenancy.js";
 import type { ComputerDO } from "./computer.js";
+import type { ComputerEnv } from "@fungi.computer/computer";
+import { type StandaloneFleetRequest } from "./computer-fleet.js";
 /** What the registry needs to build Apps on the standalone's one Computer. */
-export type StandaloneRegistryEnv = OysterWorkerEnv & StandaloneTenancyEnv & OysterGitEnv & Readonly<{
+export type StandaloneRegistryEnv = OysterWorkerEnv & Pick<ComputerEnv, "COMPUTER_VM_DEFAULT_HOST"> & StandaloneTenancyEnv & OysterGitEnv & Readonly<{
     OYSTER_COMPUTER_ID: string;
     COMPUTER: DurableObjectNamespace<ComputerDO>;
 }>;
@@ -23,9 +27,75 @@ export type BuildTarget = Readonly<{
  * composition may supply; absent, Git goes to the provider's own remotes. */
 export type StandaloneRegistryGit = Pick<CloudflareArtifactsOptions, "gitFetch" | "gitHttp">;
 /** The existing REGISTRY class identity with standalone host-owned admission. */
-export declare class StandaloneRegistry extends OysterRegistry {
+/**
+ * Operations other Worker contexts call through the REGISTRY Durable Object
+ * namespace: the APPS binding (app-builds-binding.ts) and the fleet routes
+ * (computer-fleet.ts). Each is an RPC entrypoint, not an in-process helper.
+ */
+export type StandaloneRegistryRpc = {
+    computerFleet(memberId: string, request: StandaloneFleetRequest): ReturnType<StandaloneRegistry["computerFleet"]>;
+    registerRepositoryApp(input: Parameters<StandaloneRegistry["registerRepositoryApp"]>[0]): ReturnType<StandaloneRegistry["registerRepositoryApp"]>;
+    repositoryBuildSource(installationId: string, repository: string): ReturnType<StandaloneRegistry["repositoryBuildSource"]>;
+    readRepositoryBuild(installationId: string, repository: string): ReturnType<StandaloneRegistry["readRepositoryBuild"]>;
+    installWorkflowBuild(jobId: string, target: string, release: Release, memberId: string, callerInstallationId: string): ReturnType<StandaloneRegistry["installWorkflowBuild"]>;
+};
+export declare abstract class StandaloneRegistry extends OysterRegistry implements StandaloneRegistryRpc {
     #private;
+    protected abstract hostFor(scope: TenantScope): Promise<OysterHost>;
     constructor(state: DurableObjectState, env: StandaloneRegistryEnv, git?: StandaloneRegistryGit);
+    /** Re-admit the live owner before inventory access or a hosted start. */
+    computerFleet(memberId: string, request: StandaloneFleetRequest): Promise<Readonly<{
+        computerId: string;
+        name: string;
+        createdAt: number;
+        updatedAt: number;
+    }> | {
+        readonly computers: Readonly<{
+            computerId: string;
+            name: string;
+            createdAt: number;
+            updatedAt: number;
+        }>[];
+        readonly nextOffset: number | null;
+    } | ({
+        state: "running";
+    } & Disposable) | {
+        error: string;
+        computers?: undefined;
+        nextOffset?: undefined;
+        computerId?: undefined;
+        enabled?: undefined;
+    } | {
+        computers: ({
+            computerId: string;
+            name: string;
+        } | Readonly<{
+            computerId: string;
+            name: string;
+            createdAt: number;
+            updatedAt: number;
+        }>)[];
+        nextOffset: number | null;
+        error?: undefined;
+        computerId?: undefined;
+        enabled?: undefined;
+    } | {
+        computerId: string;
+        error?: undefined;
+        computers?: undefined;
+        nextOffset?: undefined;
+        enabled?: undefined;
+    } | {
+        enabled: boolean;
+        error?: undefined;
+        computers?: undefined;
+        nextOffset?: undefined;
+        computerId?: undefined;
+    } | null>;
+    /** A durable selection snapshot; the configured default remains the App build Computer. */
+    selectedComputer(): Promise<string>;
+    /** Frame dispatch checks inventory ownership, not a mutable UI selection. */
+    ownsComputer(computerId: string): boolean;
     /** One atomic registry admission proves the stored creator is still the owner. */
     protected currentOwner(memberId: string, tenantId: TenantId): Promise<string | null>;
     /** Operator-only: one smart-HTTP exchange with an App's template
@@ -39,7 +109,7 @@ export declare class StandaloneRegistry extends OysterRegistry {
      * published seed revision builds on the Computer. */
     publishSource(rawAppId: string, claim: TemplateSeedClaim, teamId: string): Promise<{
         readonly kind: "conflict";
-        readonly receipt?: undefined;
+        receipt?: undefined;
     } | {
         readonly kind: "recorded" | "existing";
         readonly receipt: {
@@ -52,7 +122,7 @@ export declare class StandaloneRegistry extends OysterRegistry {
         };
     } | {
         readonly kind: "unavailable";
-        readonly receipt?: undefined;
+        receipt?: undefined;
     }>;
     /** Fork a published platform App's source into its own Team-owned App,
      * as repository `name` of the calling installation's Git (so its owner
@@ -68,15 +138,85 @@ export declare class StandaloneRegistry extends OysterRegistry {
         repositoryPrefix: string;
         name: string;
     }>): Promise<AppSourceForkResult>;
-    /** Owner: record an App's build source (one repository, pinned recipe). */
-    registerBuildSource(source: OysterBuildSource): Promise<void>;
+    /** Register the committed root App, never the installation's mutable Files projection. */
+    registerRepositoryApp(input: Readonly<{
+        memberId: string;
+        installationId: string;
+        repository: string;
+    }>): Promise<Readonly<{
+        kind: "registered";
+        appId: string;
+        sourceRevision: string;
+    }> | Readonly<{
+        kind: "unauthorized" | "invalid_app" | "conflict";
+    }>>;
     /** Owner: start one build of an App's source at one commit; it runs on. */
     startBuild(input: {
         appId: string;
         sourceRevision: string;
         requestedBy: string;
-    }): Promise<OysterBuildView>;
+        workflow?: {
+            requestId: string;
+            /** The installation whose admitted Workflow node asks; it must own the source. */
+            callerInstallationId: string;
+            installationId?: string;
+        };
+    }): Promise<OysterBuildStartResult>;
+    /** The calling installation's existing source record, never a registration. */
+    repositoryBuildSource(installationId: string, repository: string): Promise<{
+        appId: import("@fungi.computer/puffball").AppId;
+    } | null>;
     readBuild(jobId: string): Promise<OysterBuildView | null>;
+    /** Repository status belongs to the same captured Git owner as registration. */
+    readRepositoryBuild(installationId: string, repository: string): Promise<Readonly<{
+        jobId: string;
+        appId: string;
+        releaseId: string;
+        sourceRevision: string;
+        status: "running" | "succeeded" | "failed" | "revoked";
+        detail: string | null;
+        release: Release | null;
+        installation: import("../app-builds.js").OysterBuildInstallation | null;
+    }> | null>;
+    /** Only the APPS dispatcher of an admitted Workflow node calls this operation.
+     * Reads and alarms never choose a Release. The build row owns the decision. */
+    installWorkflowBuild(jobId: string, target: string, release: Release, memberId: string, callerInstallationId: string): Promise<{
+        status: number;
+        body: {
+            error: string;
+            installationId?: undefined;
+            status?: undefined;
+            code?: undefined;
+            pending?: undefined;
+        };
+    } | {
+        status: number;
+        body: {
+            installationId: string;
+            status: string;
+            error?: undefined;
+            code?: undefined;
+            pending?: undefined;
+        };
+    } | {
+        status: number;
+        body: {
+            code: string;
+            error: string;
+            installationId?: undefined;
+            status?: undefined;
+            pending?: undefined;
+        };
+    } | {
+        status: number;
+        body: {
+            pending: boolean;
+            error?: undefined;
+            installationId?: undefined;
+            status?: undefined;
+            code?: undefined;
+        };
+    }>;
     /** The Computer re-admits each build execution here. */
     admitBuildExecution(jobId: string, computerObjectId: string): Promise<boolean>;
     /** The egress: which live job a build report from this Computer speaks for. */

package/dist/standalone/registry.js

@@ -1,4 +1,8 @@
+import { canonicalJson } from "@fungi.computer/braid";
 import { OysterRegistry, r2ArtifactStore, } from "../workers.js";
+import { installOrSelect } from "../host.js";
+import { installationOperationsPort } from "../installation-operations.js";
+import { tenantScope } from "../tenant.js";
 import { artifactsOf } from "../workers-git.js";
 import { forkAppSource, recordTemplateSeed, templateRepositoryForApp, } from "../source/index.js";
 import { exchangeOysterTemplateGit, exchangeOysterTemplateSource, } from "../app-sources.js";
@@ -7,22 +11,143 @@ import { defineIdFamily } from "@fungi.computer/cairn/id";
 import * as Schema from "effect/Schema";
 import { parseAppId } from "@fungi.computer/puffball";
 import { appIdSchema } from "@fungi.computer/puffball/effect";
-import { createOysterAppBuilds, } from "../app-builds.js";
+import { createOysterAppBuilds, OysterBuildStartError, } from "../app-builds.js";
+import { readBuildManifest, appBuildRecipe } from "../build/workspace-build.js";
 import { standaloneTenancy } from "./tenancy.js";
+import { createFleetComputers, ComputerInventoryError, } from "@fungi.computer/computer/fleet";
+import { standaloneFleetRequestSchema, } from "./computer-fleet.js";
 const standaloneAppForkIds = defineIdFamily({
     family: "oyster-app-fork",
     version: 1,
     kinds: { app: { prefix: "app" } },
 });
-/** The existing REGISTRY class identity with standalone host-owned admission. */
+/** Whether a registered source lives in this installation's own repository. */
+function sourceOwnedBy(source, installationId) {
+    return (source?.location.kind === "installation" &&
+        source.location.installationId === installationId);
+}
 export class StandaloneRegistry extends OysterRegistry {
     #env;
     #git;
     #builds;
+    #computers;
+    #fleetStorage;
     constructor(state, env, git = {}) {
         super(state, env);
         this.#env = env;
         this.#git = git;
+        this.#fleetStorage = state.storage;
+        // Native hosts own infrastructure capacity. Standalone has no Team quota.
+        this.#computers = createFleetComputers(state.storage, {
+            limit: Number.MAX_SAFE_INTEGER,
+            retryAfterSeconds: 30,
+        });
+        this.#computers.ensure();
+    }
+    /** Re-admit the live owner before inventory access or a hosted start. */
+    async computerFleet(memberId, request) {
+        const shared = await standaloneTenancy(this.#env);
+        if ((await shared.owner())?.actor.memberId !== memberId)
+            return { error: "owner_required" };
+        const input = standaloneFleetRequestSchema.parse(request);
+        switch (input.operation) {
+            case "create": {
+                const hostId = this.#env.COMPUTER_VM_DEFAULT_HOST;
+                let created;
+                try {
+                    created = this.#computers.create({ kind: "owner", id: memberId }, input.request, [
+                        hostId === undefined
+                            ? { kind: "platform-container" }
+                            : { kind: "on-box-vm", hostId },
+                    ]).computer;
+                }
+                catch (cause) {
+                    if (cause instanceof ComputerInventoryError)
+                        return { error: cause.code };
+                    throw cause;
+                }
+                const backings = this.#computers.readBacking(created.computerId);
+                if (backings === null)
+                    throw new Error("Computer backing is missing");
+                await this.#env.COMPUTER.getByName(created.computerId).initializeFleetBackings(backings);
+                return created;
+            }
+            case "list":
+                return this.#computers.list(input.page);
+            case "choices": {
+                // The configured build Computer is an existing supported workspace,
+                // not a fabricated fleet creation receipt. Keep its UI row outside inventory.
+                const { limit, offset } = input.page;
+                const first = offset === 0;
+                const configured = {
+                    computerId: this.#env.OYSTER_COMPUTER_ID,
+                    name: this.#env.OYSTER_COMPUTER_ID,
+                };
+                if (first && limit === 1)
+                    return {
+                        computers: [configured],
+                        nextOffset: this.#computers.count() > 0 ? 1 : null,
+                    };
+                const page = this.#computers.list({
+                    limit: limit - (first ? 1 : 0),
+                    offset: Math.max(0, offset - 1),
+                });
+                return {
+                    computers: first ? [configured, ...page.computers] : page.computers,
+                    nextOffset: page.nextOffset === null ? null : page.nextOffset + 1,
+                };
+            }
+            case "read":
+                return this.#computers.read(input.computerId);
+            case "resolve":
+                // Context may name the configured build Computer, which has no fleet
+                // creation receipt. Keep canonical-owner admission above this lookup.
+                return this.ownsComputer(input.computerId)
+                    ? { computerId: input.computerId }
+                    : null;
+            case "read-internet-access":
+            case "set-internet-access": {
+                if (this.#computers.read(input.computerId) === null)
+                    return null;
+                const computer = this.#env.COMPUTER.getByName(input.computerId);
+                return {
+                    enabled: await computer.internetAccess(input.operation === "set-internet-access"
+                        ? input.enabled
+                        : undefined),
+                };
+            }
+            case "select": {
+                const computer = this.#computers.read(input.computerId);
+                if (computer === null)
+                    return null;
+                await this.#fleetStorage.put("selected-computer", input.computerId);
+                return computer;
+            }
+            case "start":
+                if (this.#computers.read(input.computerId) === null)
+                    return null;
+                return this.#env.COMPUTER.getByName(input.computerId).startHostedComputer({
+                    computerId: input.computerId,
+                    actions: new Set(["start"]),
+                    expiresAt: Date.now() + 60_000,
+                    provenance: { actor: memberId },
+                });
+        }
+    }
+    /** A durable selection snapshot; the configured default remains the App build Computer. */
+    async selectedComputer() {
+        const selected = await this.#fleetStorage.get("selected-computer");
+        if (selected === undefined)
+            return this.#env.OYSTER_COMPUTER_ID;
+        const computerId = Schema.decodeUnknownSync(Schema.NonEmptyString)(selected);
+        if (this.#computers.read(computerId) === null)
+            throw new Error("Selected Computer is missing");
+        return computerId;
+    }
+    /** Frame dispatch checks inventory ownership, not a mutable UI selection. */
+    ownsComputer(computerId) {
+        return (computerId === this.#env.OYSTER_COMPUTER_ID ||
+            this.#computers.read(computerId) !== null);
     }
     /** One atomic registry admission proves the stored creator is still the owner. */
     async currentOwner(memberId, tenantId) {
@@ -134,6 +259,7 @@ export class StandaloneRegistry extends OysterRegistry {
                     name,
                     objectId: env.COMPUTER.idFromName(name).toString(),
                     port: {
+                        buildBackend: () => env.COMPUTER.getByName(name).buildBackend(),
                         runBuild: (input) => env.COMPUTER.getByName(name).runBuild(input),
                     },
                 },
@@ -143,19 +269,184 @@ export class StandaloneRegistry extends OysterRegistry {
         });
         return this.#builds;
     }
-    /** Owner: record an App's build source (one repository, pinned recipe). */
-    async registerBuildSource(source) {
-        (await this.#appBuilds()).registerSource(source);
+    /** Register the committed root App, never the installation's mutable Files projection. */
+    async registerRepositoryApp(input) {
+        const shared = await standaloneTenancy(this.#env);
+        if ((await shared.owner())?.actor.memberId !== input.memberId)
+            return { kind: "unauthorized" };
+        const scope = tenantScope(shared.tenantId, this.#env.OYSTER_ORIGIN);
+        const repository = await artifactsOf(this.#env).get(scope.repositoryPrefix(input.installationId) + input.repository);
+        const [head] = await repository.log({ ref: "main", limit: 1, offset: 0 });
+        if (head === undefined)
+            return { kind: "invalid_app" };
+        const tree = await repository.readTree(head.treeHash);
+        const entry = tree?.find((item) => item.name === "package.json" && item.type === "blob");
+        if (entry === undefined)
+            return { kind: "invalid_app" };
+        const blob = await repository.readBlob(entry.hash);
+        // Package metadata is a bounded input; this is not an App build-output budget.
+        if (blob === null || blob.size > 1_048_576)
+            return { kind: "invalid_app" };
+        const packageJson = await blob.text();
+        let app;
+        try {
+            const manifest = readBuildManifest(packageJson);
+            if (manifest.fungi.appId === undefined ||
+                manifest.fungi.build === undefined)
+                return { kind: "invalid_app" };
+            app = {
+                appId: manifest.fungi.appId,
+                recipe: appBuildRecipe(manifest, ""),
+            };
+        }
+        catch (cause) {
+            if (Schema.isSchemaError(cause))
+                return { kind: "invalid_app" };
+            throw cause;
+        }
+        const registered = (await this.#appBuilds()).registerRepositorySource({
+            appId: app.appId,
+            location: {
+                kind: "installation",
+                installationId: input.installationId,
+                repository: input.repository,
+            },
+            recipe: app.recipe,
+        });
+        if (registered.kind === "conflict")
+            return registered;
+        return {
+            kind: "registered",
+            appId: registered.source.appId,
+            sourceRevision: "git:" + head.hash,
+        };
     }
     /** Owner: start one build of an App's source at one commit; it runs on. */
     async startBuild(input) {
-        const { build, run } = await (await this.#appBuilds()).start(input);
-        this.ctx.waitUntil(run());
-        return build;
+        try {
+            const builds = await this.#appBuilds();
+            const request = {
+                appId: input.appId,
+                sourceRevision: input.sourceRevision,
+                requestedBy: input.requestedBy,
+            };
+            if (input.workflow !== undefined) {
+                // A Workflow builds only its own installation's registered App. A
+                // foreign App reads as unregistered, never as another's existence.
+                if (!sourceOwnedBy(builds.readSource(input.appId), input.workflow.callerInstallationId))
+                    return { kind: "refused", reason: "no_source" };
+                request.requestId = input.workflow.requestId;
+                if (input.workflow.installationId !== undefined)
+                    request.installAt = input.workflow.installationId;
+            }
+            const { build, run } = await builds.start(request);
+            this.ctx.waitUntil(run());
+            return { kind: "started", build };
+        }
+        catch (cause) {
+            if (cause instanceof OysterBuildStartError)
+                return { kind: "refused", reason: cause.reason };
+            throw cause;
+        }
+    }
+    /** The calling installation's existing source record, never a registration. */
+    async repositoryBuildSource(installationId, repository) {
+        const source = (await this.#appBuilds()).readRepositorySource(installationId, repository);
+        return source === null ? null : { appId: source.appId };
     }
     async readBuild(jobId) {
         return (await this.#appBuilds()).read(jobId);
     }
+    /** Repository status belongs to the same captured Git owner as registration. */
+    async readRepositoryBuild(installationId, repository) {
+        const latest = (await this.#appBuilds()).latestRepositoryBuild(installationId, repository);
+        return latest === null ? null : this.readBuild(latest.jobId);
+    }
+    /** Only the APPS dispatcher of an admitted Workflow node calls this operation.
+     * Reads and alarms never choose a Release. The build row owns the decision. */
+    async installWorkflowBuild(jobId, target, release, memberId, callerInstallationId) {
+        const builds = await this.#appBuilds();
+        const build = builds.read(jobId);
+        if (build === null ||
+            !sourceOwnedBy(builds.readSource(build.appId), callerInstallationId) ||
+            build.installation?.installationId !== target ||
+            build.release === null ||
+            canonicalJson(Schema.decodeUnknownSync(Schema.Json)(build.release)) !==
+                canonicalJson(Schema.decodeUnknownSync(Schema.Json)(release)))
+            return {
+                status: 409,
+                body: { error: "Release does not match this build and installation" },
+            };
+        const shared = await standaloneTenancy(this.#env);
+        if ((await shared.owner())?.actor.memberId !== memberId)
+            return { status: 403, body: { error: "Workflow authority revoked" } };
+        await builds.install(jobId, async (release, installationId) => {
+            const owner = await shared.owner();
+            if (owner?.actor.memberId !== memberId)
+                return {
+                    kind: "failed",
+                    installationId,
+                    detail: "App owner unavailable",
+                };
+            const scope = tenantScope(shared.tenantId, this.#env.OYSTER_ORIGIN);
+            const root = await this.hostFor(scope);
+            // Use the in-process owner port; do not RPC this registry back into itself.
+            const host = {
+                ...root,
+                installations: {
+                    ...root.installations,
+                    get: (id) => Promise.resolve(this.get(id)),
+                    generation: () => Promise.resolve(this.generation()),
+                    // Only the owner's journal commits; nothing here writes around it.
+                    compareAndPut: () => Promise.reject(new Error("Workflow installation commits only through its owner")),
+                    operations: installationOperationsPort((request) => this.installationOperation(request), { tenantId: scope.tenantId, origin: scope.origin }),
+                },
+            };
+            const principal = await host.auth.resolve(owner.actor);
+            if (principal === null)
+                return {
+                    kind: "failed",
+                    installationId,
+                    detail: "App owner unavailable",
+                };
+            const response = await installOrSelect(host, installationId, release, principal, "install-or-select", "workflow", 
+            // One retained owner command per build: a retry observes it.
+            "workflow-build:" + jobId);
+            if (response.ok)
+                return { kind: "installed", installationId };
+            const body = await response.json();
+            if (Schema.is(Schema.Struct({ error: Schema.Literal("needs_consent") }))(body))
+                return { kind: "needs_consent", installationId };
+            return {
+                kind: "failed",
+                installationId,
+                detail: "Automatic installation refused (HTTP " +
+                    String(response.status) +
+                    ")",
+            };
+        });
+        const outcome = builds.read(jobId)?.installation;
+        switch (outcome?.kind) {
+            case "installed":
+                return {
+                    status: 200,
+                    body: { installationId: target, status: "enabled" },
+                };
+            case "needs_consent":
+                return {
+                    status: 409,
+                    body: {
+                        code: "needs_consent",
+                        error: "New Release needs owner consent",
+                    },
+                };
+            case "failed":
+                return { status: 503, body: { error: outcome.detail } };
+            default:
+                // Another installer holds this owner: the Workflow waits and retries.
+                return { status: 202, body: { pending: true } };
+        }
+    }
     /** The Computer re-admits each build execution here. */
     async admitBuildExecution(jobId, computerObjectId) {
         return (await this.#appBuilds()).admitExecution(jobId, computerObjectId);

package/dist/standalone/worker.d.ts

@@ -14,19 +14,27 @@ export { OysterBinding } from "./instance.js";
 import { StandaloneWorkflowRunsBase, type StandaloneWorkflowEnv } from "./workflows.js";
 import { type StandaloneTenancyEnv } from "./tenancy.js";
 export { StandaloneTenants } from "./tenancy.js";
+import { type StandaloneMachineLinkBindings } from "./machine-link.js";
+export { MachineLinkDO } from "./machine-link.js";
 import { type OysterComputerEgressProps } from "./computer-egress.js";
 import { type AppSourceBindingEnv } from "./app-source.js";
 export { StandaloneGraphWorkflow } from "./workflows.js";
 export { MediaOperationDO } from "@fungi.computer/darkroom/cloudflare";
 /** Every binding the standalone Bonsai root receives. */
-export type StandaloneEnv = OysterGitWorkerEnv & StandaloneTenancyEnv & StandaloneComputerEnv & StandaloneAgentsEnv & OysterMediaEnv & StandaloneWorkflowEnv & AppSourceBindingEnv & {
+export type StandaloneEnv = OysterGitWorkerEnv & StandaloneTenancyEnv & StandaloneComputerEnv & StandaloneAgentsEnv & StandaloneMachineLinkBindings & OysterMediaEnv & StandaloneWorkflowEnv & AppSourceBindingEnv & {
     OYSTER_HOME_INSTALLATION: string;
     /** `disabled` closes the Computer's public download lane. */
     COMPUTER_PUBLIC_EGRESS?: string;
 };
 export { ComputerDO } from "./computer.js";
 export { WorkspaceProxy, WorkspaceServiceProxy, } from "@fungi.computer/computer";
-export { StandaloneRegistry as OysterRegistry } from "./registry.js";
+import { StandaloneRegistry as BaseRegistry, type StandaloneRegistryGit } from "./registry.js";
+/** The registry uses the same root, with its own in-process Computer selection. */
+export declare class OysterRegistry extends BaseRegistry {
+    #private;
+    constructor(state: DurableObjectState, env: StandaloneEnv, git?: StandaloneRegistryGit);
+    protected hostFor(scope: TenantScope): Promise<import("../workers-git.js").OysterGitWorkerHost>;
+}
 export { OysterKeys } from "../workers-git.js";
 export { StandaloneEventDelivery as OysterWebhooks } from "./instance.js";
 export { AgentDirectory } from "./agents.js";
@@ -35,15 +43,21 @@ export declare class OysterMcp extends OysterMcp_base {
 }
 /** Background wakes readmit members through this root's tenancy, as HTTP and MCP do. */
 export declare class StandaloneInstance extends ComputerInstance<StandaloneEnv> {
-    protected hostFor(scope: TenantScope): import("../workers-git.js").OysterGitWorkerHost;
+    protected hostFor(scope: TenantScope): Promise<import("../workers-git.js").OysterGitWorkerHost>;
 }
 /** Agent App tools derive the same catalog as HTTP and MCP for the Agent's pinned tenant. */
 export declare class StandaloneAgent extends StandaloneAgentBase<StandaloneEnv> {
-    protected hostFor(scope: TenantScope): import("../workers-git.js").OysterGitWorkerHost;
+    protected hostFor(scope: TenantScope): Promise<import("../workers-git.js").OysterGitWorkerHost>;
 }
 /** Workflow runs admit through the same root composition as HTTP. */
 export declare class StandaloneWorkflowRuns extends StandaloneWorkflowRunsBase<StandaloneEnv> {
-    protected hostFor(scope: TenantScope): import("../workers-git.js").OysterGitWorkerHost;
+    protected hostFor(scope: TenantScope): Promise<import("../workers-git.js").OysterGitWorkerHost>;
+}
+declare const OysterInstallationExecutor_base: new (ctx: ExecutionContext, env: StandaloneEnv) => WorkerEntrypoint<StandaloneEnv, unknown> & {
+    run(): Promise<import("../installation-operations.js").InstallationOutcome>;
+};
+/** Private loopback execution uses this root's ordinary host composition. */
+export declare class OysterInstallationExecutor extends OysterInstallationExecutor_base {
 }
 /** The Computer's egress gateway: its own HTTPS Git back into this Worker. */
 export declare class OysterComputerEgress extends WorkerEntrypoint<StandaloneEnv, OysterComputerEgressProps> {