@fungi.computer/oyster 0.0.1 → 0.2.0

package/dist/standalone/app-builds-binding.d.ts

@@ -0,0 +1,36 @@
+import * as Schema from "effect/Schema";
+import type { FrameBindingProps } from "../cloudflare.js";
+import type { InvocationFrame } from "../invocation.js";
+import type { OysterBindingContext, OysterBindingResult } from "../workers.js";
+import type { TenantScope } from "../tenant.js";
+import type { StandaloneComputerEnv } from "./computer.js";
+/** The Instance gate and native guest entrypoint share these argument codecs. */
+export declare const appsFrameMethods: {
+    APPS: {
+        build: {
+            decodeArgs: (raw: readonly unknown[]) => [{
+                appId: string;
+                sourceRevision: string;
+            }];
+            decodeResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Schema.Json;
+            requiredOperations: () => string[];
+        };
+        buildStatus: {
+            decodeArgs: (raw: readonly unknown[]) => [{
+                jobId: string;
+            }];
+            decodeResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Schema.Json;
+            requiredOperations: () => string[];
+        };
+        select: {
+            decodeArgs: (raw: readonly unknown[]) => [{
+                installationId: string;
+                release: unknown;
+            }];
+            decodeResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Schema.Json;
+            requiredOperations: () => string[];
+        };
+    };
+};
+/** Called only after the Instance resolves the captured frame and current grants. */
+export declare function dispatchAppsBuildsBinding(env: StandaloneComputerEnv, scope: TenantScope, frame: InvocationFrame, props: FrameBindingProps, method: string, args: readonly unknown[], backgroundHost: OysterBindingContext<StandaloneComputerEnv>["backgroundHost"]): Promise<OysterBindingResult>;

package/dist/standalone/app-builds-binding.js

@@ -0,0 +1,119 @@
+/**
+ * The APPS guest binding on the standalone Bonsai root: start a build job on
+ * this Oyster's one Computer, read a job's status, and install (or switch) a
+ * Release at an installation id. Every operation re-checks the caller is the
+ * tenant owner; the binding carries no key and no owner secret.
+ */
+import { z } from "zod";
+import * as Schema from "effect/Schema";
+import { AppInstanceError } from "../index.js";
+import { installOrSelect } from "../host.js";
+import { installationIdSchema } from "../apps/index.js";
+import { appIdSchema, releaseSchema } from "@fungi.computer/puffball/effect";
+/** The calling tenant's registry owns its App builds. */
+const buildRegistry = (env, scope) => env.REGISTRY.getByName(scope.durableName("registry"));
+const buildInput = z.lazy(() => z.strictObject({
+    appId: z.string().min(1).max(256),
+    sourceRevision: z.string().min(1).max(256),
+}));
+const buildStatusInput = z.lazy(() => z.strictObject({
+    jobId: z.string().min(1).max(256),
+}));
+const selectInput = z.lazy(() => z.strictObject({
+    installationId: z.string().min(1).max(256),
+    release: z.unknown(),
+}));
+/** The Instance gate and native guest entrypoint share these argument codecs. */
+export const appsFrameMethods = {
+    APPS: {
+        build: {
+            decodeArgs: (raw) => z.tuple([buildInput]).parse(raw),
+            decodeResult: Schema.decodeUnknownSync(Schema.Json),
+            requiredOperations: () => ["build"],
+        },
+        buildStatus: {
+            decodeArgs: (raw) => z.tuple([buildStatusInput]).parse(raw),
+            decodeResult: Schema.decodeUnknownSync(Schema.Json),
+            requiredOperations: () => ["buildStatus"],
+        },
+        select: {
+            decodeArgs: (raw) => z.tuple([selectInput]).parse(raw),
+            decodeResult: Schema.decodeUnknownSync(Schema.Json),
+            requiredOperations: () => ["select"],
+        },
+    },
+};
+/** Only a live owner call reaches build, status or select; a key or a
+ * member without the owner role is refused before any registry or host read. */
+function callerOwner(frame) {
+    const subject = frame.facts.subject;
+    if (subject.kind !== "call" ||
+        subject.context.actor.kind !== "member" ||
+        subject.context.role !== "owner")
+        throw new AppInstanceError("revoked");
+    return { actor: subject.context.actor, role: "owner" };
+}
+async function responseResult(response) {
+    return { status: response.status, body: await response.json() };
+}
+/** Called only after the Instance resolves the captured frame and current grants. */
+export async function dispatchAppsBuildsBinding(env, scope, frame, props, method, args, backgroundHost) {
+    frame.signal.throwIfAborted();
+    if (props.binding !== "APPS")
+        throw new AppInstanceError("revoked");
+    const principal = callerOwner(frame);
+    const requestedBy = principal.actor.kind === "member" ? principal.actor.memberId : "owner";
+    if (method === "build") {
+        const [input] = z.tuple([buildInput]).parse(args);
+        const appId = Schema.decodeUnknownSync(appIdSchema)(input.appId);
+        const registry = buildRegistry(env, scope);
+        let build;
+        try {
+            build = await registry.startBuild({
+                appId,
+                sourceRevision: input.sourceRevision,
+                requestedBy,
+            });
+        }
+        catch {
+            return Schema.decodeUnknownSync(Schema.Json)({
+                status: 409,
+                body: { error: "App has no build source" },
+            });
+        }
+        frame.signal.throwIfAborted();
+        return Schema.decodeUnknownSync(Schema.Json)({ status: 202, body: build });
+    }
+    if (method === "buildStatus") {
+        const [input] = z.tuple([buildStatusInput]).parse(args);
+        const build = await buildRegistry(env, scope).readBuild(input.jobId);
+        frame.signal.throwIfAborted();
+        return Schema.decodeUnknownSync(Schema.Json)({
+            status: build === null ? 404 : 200,
+            body: build ?? { error: "Not found" },
+        });
+    }
+    if (method === "select") {
+        const [input] = z.tuple([selectInput]).parse(args);
+        const installationId = installationIdSchema.parse(input.installationId);
+        let release;
+        try {
+            release = Schema.decodeUnknownSync(releaseSchema)(input.release, {
+                onExcessProperty: "error",
+            });
+        }
+        catch {
+            return Schema.decodeUnknownSync(Schema.Json)({
+                status: 400,
+                body: { error: "Invalid Release" },
+            });
+        }
+        const host = await backgroundHost();
+        if (host === null)
+            throw new AppInstanceError("revoked");
+        const response = await installOrSelect(host, installationId, release, principal);
+        frame.signal.throwIfAborted();
+        return Schema.decodeUnknownSync(Schema.Json)(await responseResult(response));
+    }
+    throw new AppInstanceError("revoked");
+}

package/dist/standalone/app-set.d.ts

@@ -0,0 +1,91 @@
+import * as Schema from "effect/Schema";
+import { type PackOptions } from "../pack.js";
+/** One starter App: where its source lives and how the Computer builds it. */
+export type StarterApp = Readonly<{
+    installationId: string;
+    appId: string;
+    /** The App's directory in a Botanical checkout; its recipe is rooted there. */
+    directory: string;
+    /** Its own public source repository's name, the App at that repository's root. */
+    repository: string;
+    recipe: PackOptions["recipe"];
+}>;
+export declare const standaloneAppSet: readonly StarterApp[];
+/** Where the starter Apps' sources come from. */
+export type StarterAppSource = Readonly<{
+    /** A Botanical checkout at one exact commit; each App is its directory. */
+    kind: "checkout";
+    directory: string;
+    revision: string;
+}> | Readonly<{
+    /**
+     * Each App's own repository, `${base}/${app.repository}.git`, at `ref`
+     * (a branch or tag): the App at the repository's root.
+     */
+    kind: "repositories";
+    base: string;
+    ref: string;
+    /** A scratch directory the installer clones into; it removes each clone. */
+    scratch: string;
+}>;
+/** Wall-clock milliseconds one App spent in each install phase. */
+export type StarterAppTimings = Readonly<{
+    /** Cloning its repository on this machine; zero for a checkout. */
+    fetch: number;
+    /** Seeding its template on the Oyster by git push. */
+    publish: number;
+    /** Waiting for a build slot on the Computer. */
+    queue: number;
+    /** From starting its build to the build's terminal state. */
+    build: number;
+    /** Installing the built Release. */
+    install: number;
+    /** The Computer's own report of its build, when it gives one. */
+    computer: Readonly<{
+        clone: number;
+        install: number;
+        build: number;
+        upload: number;
+    }> | null;
+}>;
+/** One App the installer published, built and installed. */
+export type InstalledStarterApp = Readonly<{
+    installationId: string;
+    published: "recorded" | "existing";
+    seedRevision: string;
+    sourceRevision: string;
+    jobId: string;
+    installed: "installed" | "replaced";
+    release: Schema.Json;
+    timings: StarterAppTimings;
+}>;
+/**
+ * Builds the installer runs at once by default. A build's compiler may take a
+ * 4 GB heap, so two fit the platform's 12 GiB Computer (standard-4) with room
+ * for pnpm and esbuild; a third is the most it will run.
+ */
+export declare const defaultStarterBuildConcurrency = 2;
+/**
+ * Install the standalone App set, each App built on the Oyster's own
+ * Computer. Each App's editable source is published as its template; the host
+ * builds that seed revision and the installer installs the exact Release the
+ * build recorded. Builds run `concurrency` at a time on the one Computer,
+ * Tourtois first; each App installs as soon as its own build succeeds. No App
+ * is compiled on this machine and no installed App is needed to build.
+ */
+export declare function installStandaloneAppSet(options: Readonly<{
+    source: StarterAppSource;
+    url: string;
+    key: string;
+    report: (message: string) => void;
+    /** Builds at once on the Computer, 1 to 3; one by default. */
+    concurrency?: number;
+    /** Publishes one App's source; the real installer uses `publishSource`. */
+    publish?: (app: StarterApp, located: Readonly<{
+        repositoryPath: string;
+        sourceRevision: string;
+        recipe: PackOptions["recipe"];
+    }>) => Promise<Response>;
+    pollMs?: number;
+    waitMs?: number;
+}>): Promise<readonly InstalledStarterApp[]>;

package/dist/standalone/app-set.js

@@ -0,0 +1,395 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import * as Schema from "effect/Schema";
+import { publishSource } from "../pack.js";
+import { parseSourceRevision } from "@fungi.computer/puffball";
+// Existing closed source recipes, shared by the standalone install command and
+// its real-root proof. The canonical Oyster builder owns every compilation, on
+// the Oyster's own Computer.
+const assets = {
+    maxManifestBytes: 1_048_576,
+    maxObjects: 1024,
+    maxObjectBytes: 16_777_216,
+    maxTotalBytes: 67_108_864,
+};
+const facet = { kind: "durable-facet", stateSchema: 1 };
+export const standaloneAppSet = [
+    {
+        installationId: "tourtois",
+        directory: "apps/tourtois",
+        repository: "tourtois",
+        appId: "app_tourtois",
+        recipe: {
+            entry: "apps/tourtois/index.html",
+            assets,
+            assetBase: "./",
+            backend: {
+                entry: "apps/tourtois/backend/index.ts",
+                exportName: "Tourtois",
+                compatibilityDate: "2026-09-04",
+                runtime: facet,
+            },
+            maxOutputBytes: 67_108_864,
+        },
+    },
+    {
+        installationId: "bonsai",
+        directory: "apps/bonsai",
+        repository: "bonsai",
+        appId: "app_bonsai",
+        recipe: {
+            entry: "apps/bonsai/web/index.html",
+            assets,
+            assetBase: "./",
+            maxOutputBytes: 67_108_864,
+            backend: {
+                entry: "apps/bonsai/backend/index.ts",
+                exportName: "BonsaiApp",
+                compatibilityDate: "2026-09-04",
+                runtime: facet,
+            },
+        },
+    },
+    {
+        installationId: "shed",
+        directory: "apps/shed",
+        repository: "shed",
+        appId: "app_shed",
+        recipe: {
+            entry: "apps/shed/index.html",
+            assets: {
+                maxManifestBytes: 1_048_576,
+                maxObjects: 512,
+                maxObjectBytes: 4_194_304,
+                maxTotalBytes: 16_777_216,
+            },
+            assetBase: "./",
+            maxOutputBytes: 16_777_216,
+            backend: {
+                entry: "apps/shed/backend/index.ts",
+                exportName: "Shed",
+                compatibilityDate: "2026-09-25",
+                runtime: facet,
+            },
+        },
+    },
+    {
+        installationId: "inkcap",
+        directory: "apps/inkcap",
+        repository: "inkcap",
+        appId: "app_inkcap",
+        recipe: {
+            entry: "apps/inkcap/index.html",
+            assets,
+            assetBase: "./",
+            maxOutputBytes: 16_777_216,
+            backend: {
+                entry: "apps/inkcap/backend/index.ts",
+                exportName: "Inkcap",
+                compatibilityDate: "2026-09-25",
+                runtime: facet,
+            },
+        },
+    },
+    {
+        installationId: "trellis",
+        directory: "apps/trellis",
+        repository: "trellis",
+        appId: "app_trellis",
+        recipe: {
+            entry: "apps/trellis/index.html",
+            maxOutputBytes: 16_777_216,
+            backend: {
+                entry: "apps/trellis/backend/index.ts",
+                exportName: "Trellis",
+                compatibilityDate: "2026-09-04",
+                runtime: facet,
+            },
+        },
+    },
+    {
+        installationId: "prints",
+        directory: "apps/prints",
+        repository: "prints",
+        appId: "app_prints",
+        recipe: {
+            entry: "apps/prints/index.html",
+            assets,
+            assetBase: "./",
+            maxOutputBytes: 16_777_216,
+            backend: {
+                entry: "apps/prints/backend/index.ts",
+                exportName: "Prints",
+                compatibilityDate: "2026-09-04",
+                runtime: facet,
+            },
+        },
+    },
+    {
+        installationId: "grove",
+        directory: "apps/grove",
+        repository: "grove",
+        appId: "app_grove",
+        recipe: {
+            entry: "apps/grove/index.html",
+            assets,
+            assetBase: "./",
+            maxOutputBytes: 67_108_864,
+            backend: {
+                entry: "apps/grove/backend/index.ts",
+                exportName: "Grove",
+                compatibilityDate: "2026-09-04",
+                runtime: facet,
+            },
+        },
+    },
+];
+const publishedSchema = Schema.Struct({
+    kind: Schema.Literals(["recorded", "existing"]),
+    receipt: Schema.Struct({
+        seedRevision: Schema.String,
+        /** The upstream commit this distribution was projected from. */
+        sourceRevision: Schema.String,
+    }),
+});
+const buildSchema = Schema.Struct({
+    jobId: Schema.String,
+    status: Schema.Literals(["running", "succeeded", "failed", "revoked"]),
+    detail: Schema.NullOr(Schema.String),
+    /** Installed exactly as the host encoded it. */
+    release: Schema.NullOr(Schema.Json),
+});
+/** The phases a Computer build reports in its success detail. */
+const computerPhasesSchema = Schema.fromJsonString(Schema.Struct({
+    phasesMs: Schema.Struct({
+        clone: Schema.Number,
+        install: Schema.Number,
+        build: Schema.Number,
+        upload: Schema.Number,
+    }),
+}));
+/** How long one App's build may run before the installer gives up: the
+ * host's whole-build budget plus queueing on the one Computer. */
+const appBuildWaitMs = 20 * 60_000;
+/**
+ * Builds the installer runs at once by default. A build's compiler may take a
+ * 4 GB heap, so two fit the platform's 12 GiB Computer (standard-4) with room
+ * for pnpm and esbuild; a third is the most it will run.
+ */
+export const defaultStarterBuildConcurrency = 2;
+/** The most builds at once on the 12 GiB Computer. */
+const maxStarterBuildConcurrency = 3;
+/** A recipe rooted at `from` (a checkout directory), rooted at `to` instead. */
+function relocateRecipe(recipe, from, to) {
+    const move = (path) => {
+        if (!path.startsWith(`${from}/`))
+            throw new Error(`${path} is outside its App directory ${from}`);
+        const rest = path.slice(from.length + 1);
+        return to === "" ? rest : `${to}/${rest}`;
+    };
+    const backend = recipe.backend;
+    if (backend?.entry === undefined)
+        return { ...recipe, entry: move(recipe.entry) };
+    return {
+        ...recipe,
+        entry: move(recipe.entry),
+        backend: { ...backend, entry: move(backend.entry) },
+    };
+}
+const run = (command, args, cwd) => new Promise((resolveRun, reject) => {
+    execFile(command, args, { cwd, encoding: "utf8", maxBuffer: 1_048_576 }, (error, stdout) => {
+        if (error)
+            reject(new Error(`${command} ${args[0] ?? ""} failed`, { cause: error }));
+        else
+            resolveRun(stdout);
+    });
+});
+/**
+ * Install the standalone App set, each App built on the Oyster's own
+ * Computer. Each App's editable source is published as its template; the host
+ * builds that seed revision and the installer installs the exact Release the
+ * build recorded. Builds run `concurrency` at a time on the one Computer,
+ * Tourtois first; each App installs as soon as its own build succeeds. No App
+ * is compiled on this machine and no installed App is needed to build.
+ */
+export async function installStandaloneAppSet(options) {
+    const concurrency = options.concurrency ?? defaultStarterBuildConcurrency;
+    if (!Number.isInteger(concurrency) ||
+        concurrency < 1 ||
+        concurrency > maxStarterBuildConcurrency)
+        throw new Error(`Starter builds run 1 to ${String(maxStarterBuildConcurrency)} at a time`);
+    const authorization = { Authorization: `Bearer ${options.key}` };
+    const owner = async (method, path, body, signal) => {
+        const init = body === undefined
+            ? { method, headers: authorization }
+            : {
+                method,
+                headers: { ...authorization, "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            };
+        if (signal !== undefined)
+            init.signal = signal;
+        return fetch(new URL(path, options.url), init);
+    };
+    /** Start one build and wait for its terminal outcome within the build
+     * budget; the budget cancels every request and body read it covers. */
+    const buildOnComputer = async (name, appId, seedRevision) => {
+        const budget = AbortSignal.timeout(options.waitMs ?? appBuildWaitMs);
+        let jobId = null;
+        try {
+            const started = await owner("POST", "/api/builds", { appId, sourceRevision: seedRevision }, budget);
+            if (started.status !== 202)
+                throw new Error(`${name} build refused (${String(started.status)})`);
+            let build = Schema.decodeUnknownSync(buildSchema)(await started.json());
+            jobId = build.jobId;
+            options.report(`Building ${name} on the Computer (${build.jobId})`);
+            while (build.status === "running") {
+                await sleep(options.pollMs ?? 5_000, undefined, { signal: budget });
+                const read = await owner("GET", `/api/builds/${encodeURIComponent(build.jobId)}`, undefined, budget);
+                if (!read.ok)
+                    throw new Error(`${name} build is missing (${String(read.status)})`);
+                build = Schema.decodeUnknownSync(buildSchema)(await read.json());
+            }
+            return build;
+        }
+        catch (cause) {
+            if (budget.aborted)
+                throw new Error(`${name} build did not finish (${jobId ?? "not started"})`, {
+                    cause,
+                });
+            throw cause;
+        }
+    };
+    const publish = options.publish ??
+        ((app, located) => publishSource({
+            appId: app.appId,
+            entry: located.recipe.entry,
+            repositoryPath: located.repositoryPath,
+            sourceRevision: located.sourceRevision,
+            recipe: located.recipe,
+            url: options.url,
+            key: options.key,
+        }));
+    /** Locate one App's source at an exact commit, cloning it when it has its
+     * own repository; `release` removes a clone once its template is seeded. */
+    const locate = async (app) => {
+        const source = options.source;
+        if (source.kind === "checkout")
+            return {
+                repositoryPath: source.directory,
+                sourceRevision: parseSourceRevision(source.revision),
+                recipe: app.recipe,
+                release: () => Promise.resolve(),
+            };
+        const clone = await mkdtemp(join(source.scratch, `${app.repository}-`));
+        try {
+            await run("git", [
+                "clone",
+                "--quiet",
+                "--depth=1",
+                `--branch=${source.ref}`,
+                "--",
+                `${source.base}/${app.repository}.git`,
+                clone,
+            ]);
+            const head = (await run("git", ["rev-parse", "HEAD"], clone)).trim();
+            return {
+                repositoryPath: clone,
+                sourceRevision: parseSourceRevision(`git:${head}`),
+                recipe: relocateRecipe(app.recipe, app.directory, ""),
+                release: () => rm(clone, { recursive: true, force: true }),
+            };
+        }
+        catch (cause) {
+            await rm(clone, { recursive: true, force: true });
+            throw cause;
+        }
+    };
+    // Seed every template first: a git push each, quick beside a build.
+    const seeded = [];
+    for (const app of standaloneAppSet) {
+        const name = app.installationId;
+        const fetchStarted = performance.now();
+        const located = await locate(app);
+        const publishStarted = performance.now();
+        try {
+            const published = await publish(app, located);
+            if (!published.ok)
+                throw new Error(`${name} source publish failed (${String(published.status)})`);
+            const { kind, receipt } = Schema.decodeUnknownSync(publishedSchema)(await published.json());
+            options.report(`${name} source ${kind} at ${receipt.seedRevision}`);
+            const ready = performance.now();
+            seeded.push({
+                app,
+                kind,
+                seedRevision: receipt.seedRevision,
+                sourceRevision: receipt.sourceRevision,
+                fetch: publishStarted - fetchStarted,
+                publish: ready - publishStarted,
+                ready,
+            });
+        }
+        finally {
+            await located.release();
+        }
+    }
+    // Then build `concurrency` at a time, in set order, installing each as its
+    // build succeeds. The first failure rejects the install and starts no
+    // further build; builds already running finish and install.
+    const installed = new Map();
+    const pending = [...seeded];
+    /** Set by the first failure, so no further build starts. */
+    const stop = { requested: false };
+    const slot = async () => {
+        for (let next = stop.requested ? undefined : pending.shift(); next !== undefined; next = stop.requested ? undefined : pending.shift()) {
+            const name = next.app.installationId;
+            try {
+                const buildStarted = performance.now();
+                const build = await buildOnComputer(name, next.app.appId, next.seedRevision);
+                if (build.status !== "succeeded" || build.release === null)
+                    throw new Error(`${name} build ${build.status}: ${build.detail ?? "no Release"}`);
+                const installStarted = performance.now();
+                const installation = await owner("POST", "/api/installations", {
+                    release: build.release,
+                    installationId: name,
+                });
+                if (!installation.ok)
+                    throw new Error(`${name} installation failed (${String(installation.status)})`);
+                options.report(`${installation.status === 201 ? "Installed" : "Replaced"} ${name} from its build ${build.jobId}`);
+                const phases = build.detail === null
+                    ? undefined
+                    : Schema.decodeUnknownOption(computerPhasesSchema)(build.detail);
+                installed.set(name, {
+                    installationId: name,
+                    published: next.kind,
+                    seedRevision: next.seedRevision,
+                    sourceRevision: next.sourceRevision,
+                    jobId: build.jobId,
+                    installed: installation.status === 201 ? "installed" : "replaced",
+                    release: build.release,
+                    timings: {
+                        fetch: next.fetch,
+                        publish: next.publish,
+                        queue: buildStarted - next.ready,
+                        build: installStarted - buildStarted,
+                        install: performance.now() - installStarted,
+                        computer: phases === undefined || phases._tag === "None"
+                            ? null
+                            : phases.value.phasesMs,
+                    },
+                });
+            }
+            catch (cause) {
+                stop.requested = true;
+                throw cause;
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: concurrency }, slot));
+    return standaloneAppSet.flatMap((app) => {
+        const result = installed.get(app.installationId);
+        return result === undefined ? [] : [result];
+    });
+}

package/dist/standalone/app-source.d.ts

@@ -0,0 +1,41 @@
+import { Hono } from "hono";
+import type { TenantScope } from "../tenant.js";
+import type { OysterBindingResult } from "../workers.js";
+import type { OysterEnv } from "../host.js";
+import type { InvocationFrame } from "../invocation.js";
+import type { StandaloneRegistry } from "./registry.js";
+/** The standalone App source binding needs the Git-capable registry, by
+ * identity: `worker.ts` exports `StandaloneRegistry` as the `REGISTRY`
+ * binding's class, so this Instance's env sees that same object. */
+export type AppSourceBindingEnv = Readonly<{
+    REGISTRY: DurableObjectNamespace<StandaloneRegistry>;
+}>;
+/** `catalogFrameMethods.APPS`'s descriptors already decode to
+ * `OysterBindingResult` at their owner (`catalog-frame.ts`); no re-typing
+ * is needed here. */
+export declare const appSourceFrameMethods: {
+    APPS: {
+        catalog: {
+            decodeArgs: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => readonly [{}];
+            decodeResult: (raw: unknown) => OysterBindingResult;
+            requiredOperations: () => string[];
+        };
+        fork: {
+            decodeArgs: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => readonly [{
+                readonly platformAppId: import("@fungi.computer/puffball").AppId;
+                readonly name: string;
+            }];
+            decodeResult: (raw: unknown) => OysterBindingResult;
+            requiredOperations: () => string[];
+        };
+    };
+};
+/** Serve `APPS.catalog`/`APPS.fork`; `fork` is admitted only for the tenant owner,
+ * re-checked here (never trusted from a stale captured frame). */
+export declare function dispatchAppSourceBinding(env: AppSourceBindingEnv, scope: TenantScope, frame: InvocationFrame, method: string, args: readonly unknown[]): Promise<OysterBindingResult>;
+/** Operator-only: seed one App's editable source template (`install-apps.mjs`).
+ * Mounted under `host.ownerRoutes`, already owner-key-gated for every `/api/*`
+ * path before this handler runs (`host.ts`'s `oysterPrincipalIsOwner` check).
+ * The operator `git push`es the projected source to
+ * `/api/apps/:appId/source.git`, then claims that head here. */
+export declare function appSourceOwnerRoutes(env: AppSourceBindingEnv, scope: TenantScope): Hono<OysterEnv>;